Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

CameraX आर्किटेक्चर

इस पेज पर, CameraX के आर्किटेक्चर के बारे में बताया गया है. इसमें इसके स्ट्रक्चर, एपीआई के साथ काम करने के तरीके, लाइफ़साइकल के साथ काम करने के तरीके, और इस्तेमाल के उदाहरणों को जोड़ने के तरीके के बारे में बताया गया है.

CameraX का स्ट्रक्चर

CameraX का इस्तेमाल करके, किसी डिवाइस के कैमरे को ऐब्स्ट्रैक्शन के ज़रिए इंटरफ़ेस किया जा सकता है. इसे इस्तेमाल का उदाहरण कहा जाता है. इस्तेमाल के ये उदाहरण उपलब्ध हैं:

झलक: झलक दिखाने के लिए, किसी प्लैटफ़ॉर्म को स्वीकार करता है, जैसे कि PreviewView.
इमेज का विश्लेषण: यह विश्लेषण के लिए, सीपीयू से ऐक्सेस किए जा सकने वाले बफ़र उपलब्ध कराता है. जैसे, मशीन लर्निंग के लिए.
इमेज कैप्चर करने की सुविधा: इससे फ़ोटो कैप्चर की जाती है और सेव की जाती है.
वीडियो कैप्चर करना: VideoCapture की मदद से वीडियो और ऑडियो कैप्चर करना

इस्तेमाल के उदाहरणों को एक साथ जोड़ा जा सकता है और एक साथ चालू किया जा सकता है. उदाहरण के लिए, कोई ऐप्लिकेशन उपयोगकर्ता को झलक दिखाने वाले यूज़ केस का इस्तेमाल करके, कैमरे से ली गई इमेज देखने की सुविधा दे सकता है. साथ ही, इमेज का विश्लेषण करने वाले यूज़ केस का इस्तेमाल करके, यह पता लगा सकता है कि फ़ोटो में मौजूद लोग मुस्कुरा रहे हैं या नहीं. इसके अलावा, इमेज कैप्चर करने वाले यूज़ केस का इस्तेमाल करके, मुस्कुराते हुए लोगों की फ़ोटो ले सकता है.

एपीआई मॉडल

लाइब्रेरी के साथ काम करने के लिए, आपको ये चीज़ें बतानी होंगी:

कॉन्फ़िगरेशन के विकल्पों के साथ, इस्तेमाल का पसंदीदा उदाहरण.
लिसनर अटैच करके, आउटपुट डेटा का क्या करना है.
इस्तेमाल के उदाहरण को Android आर्किटेक्चर लाइफ़साइकल से बाइंड करके, तय किया गया फ़्लो. जैसे, कैमरे कब चालू करने हैं और डेटा कब जनरेट करना है.

CameraX ऐप्लिकेशन को दो तरीकों से लिखा जा सकता है: CameraController (अगर आपको CameraX का इस्तेमाल करने का सबसे आसान तरीका चाहिए, तो यह बेहतर है) या CameraProvider (अगर आपको ज़्यादा सुविधाएं चाहिए, तो यह बेहतर है).

CameraController

CameraController, CameraX के ज़्यादातर मुख्य फ़ंक्शन को एक ही क्लास में उपलब्ध कराता है. इसे सेटअप करने के लिए, बहुत कम कोड की ज़रूरत होती है. साथ ही, यह कैमरा शुरू करने, इस्तेमाल के उदाहरण को मैनेज करने, टारगेट रोटेशन, टैप-टू-फ़ोकस, पिंच-टू-ज़ूम वगैरह को अपने-आप मैनेज करता है. CameraController को एक्सटेंड करने वाली कॉन्क्रीट क्लास, LifecycleCameraController है.

val previewView: PreviewView = viewBinding.previewView
var cameraController = LifecycleCameraController(baseContext)
cameraController.bindToLifecycle(this)
cameraController.cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
previewView.controller = cameraController

CameraController के लिए डिफ़ॉल्ट UseCase, Preview, ImageCapture, और ImageAnalysis हैं. ImageCapture या ImageAnalysis को बंद करने या VideoCapture को चालू करने के लिए, setEnabledUseCases() तरीके का इस्तेमाल करें.

CameraController के अन्य इस्तेमाल के बारे में जानने के लिए, क्यूआर कोड स्कैनर का सैंपल या CameraController के बारे में बुनियादी जानकारी देने वाला वीडियो देखें.

CameraProvider

CameraProvider का इस्तेमाल करना अब भी आसान है. हालांकि, ऐप्लिकेशन डेवलपर सेटअप को ज़्यादा हैंडल करता है. इसलिए, कॉन्फ़िगरेशन को पसंद के मुताबिक बनाने के ज़्यादा मौके मिलते हैं. जैसे, आउटपुट इमेज को घुमाने की सुविधा चालू करना या ImageAnalysis में आउटपुट इमेज का फ़ॉर्मैट सेट करना. कैमरे की झलक के लिए, कस्टम Surface का भी इस्तेमाल किया जा सकता है. इससे आपको ज़्यादा सुविधाएं मिलती हैं. हालांकि, CameraController के साथ आपको PreviewView का इस्तेमाल करना होगा. अगर आपके ऐप्लिकेशन के अन्य हिस्सों में पहले से ही Surface कोड का इस्तेमाल किया जा रहा है, तो मौजूदा कोड का इस्तेमाल करना फ़ायदेमंद हो सकता है.

set() तरीकों का इस्तेमाल करके, इस्तेमाल के उदाहरण कॉन्फ़िगर किए जाते हैं. इसके बाद, build() तरीके का इस्तेमाल करके उन्हें फ़ाइनल किया जाता है. इस्तेमाल के हर उदाहरण का ऑब्जेक्ट, इस्तेमाल के उदाहरण के हिसाब से एपीआई का एक सेट उपलब्ध कराता है. उदाहरण के लिए, इमेज कैप्चर करने के उदाहरण में, takePicture() को कॉल करने का तरीका बताया गया है.

onResume() और onPause() में, ऐप्लिकेशन को शुरू और बंद करने के लिए, खास तरीके इस्तेमाल करने के बजाय, ऐप्लिकेशन एक लाइफ़साइकल तय करता है. इससे कैमरे को cameraProvider.bindToLifecycle() का इस्तेमाल करके जोड़ा जाता है. इसके बाद, वह लाइफ़साइकल CameraX को बताती है कि कैमरा कैप्चर सेशन को कब कॉन्फ़िगर करना है. साथ ही, यह पक्का करती है कि कैमरे की स्थिति में सही तरीके से बदलाव हो, ताकि वह लाइफ़साइकल ट्रांज़िशन से मैच कर सके.

हर इस्तेमाल के उदाहरण को लागू करने के चरणों के लिए, झलक लागू करें, इमेज का विश्लेषण करें, इमेज कैप्चर करें, और वीडियो कैप्चर करें देखें

झलक दिखाने के लिए, इस्तेमाल का उदाहरण Surface के साथ इंटरैक्ट करता है. ऐप्लिकेशन कॉन्फ़िगरेशन के विकल्पों के साथ इस्तेमाल का उदाहरण बनाने के लिए, इस कोड का इस्तेमाल करें:

val preview = Preview.Builder().build()
val viewFinder: PreviewView = findViewById(R.id.previewView)

// The use case is bound to an Android Lifecycle with the following code.
val camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview)

// PreviewView creates a surface provider and is the recommended provider.
preview.setSurfaceProvider(viewFinder.getSurfaceProvider())Architecture.kt

कोड के ज़्यादा उदाहरण देखने के लिए, CameraX का आधिकारिक सैंपल ऐप्लिकेशन देखें.

CameraX लाइफ़साइकल

CameraX, लाइफ़साइकल को मॉनिटर करता है, ताकि यह तय किया जा सके कि कैमरा कब खोलना है, कैप्चर सेशन कब बनाना है, और कब रोकना और बंद करना है. इस्तेमाल के उदाहरण वाले एपीआई, प्रोग्रेस को मॉनिटर करने के लिए, मेथड कॉल और कॉलबैक उपलब्ध कराते हैं.

इस्तेमाल के उदाहरणों को जोड़ने के बारे में बताया गया है कि इस्तेमाल के कुछ उदाहरणों को एक ही लाइफ़साइकल से जोड़ा जा सकता है. जब आपके ऐप्लिकेशन को ऐसे इस्तेमाल के उदाहरणों के साथ काम करना हो जिन्हें एक साथ नहीं जोड़ा जा सकता, तो इनमें से कोई एक काम किया जा सकता है:

एक साथ काम करने वाले इस्तेमाल के उदाहरणों को एक से ज़्यादा फ़्रैगमेंट में ग्रुप करें. इसके बाद, फ़्रैगमेंट के बीच स्विच करें
कस्टम लाइफ़साइकल कॉम्पोनेंट बनाएं और कैमरे की लाइफ़साइकल को मैन्युअल तरीके से कंट्रोल करने के लिए, इसका इस्तेमाल करें

अगर व्यू और कैमरे के इस्तेमाल के उदाहरणों के लाइफ़साइकल के मालिकों को अलग किया जाता है (उदाहरण के लिए, अगर कस्टम लाइफ़साइकल या रिटेन फ़्रैगमेंट का इस्तेमाल किया जाता है), तो आपको यह पक्का करना होगा कि इस्तेमाल के सभी उदाहरण, CameraX से अनबाउंड हों. इसके लिए, ProcessCameraProvider.unbindAll() का इस्तेमाल करें या इस्तेमाल के हर उदाहरण को अलग-अलग अनबाउंड करें. इसके अलावा, इस्तेमाल के उदाहरणों को लाइफ़साइकल से बाइंड करने पर, CameraX को कैप्चर सेशन खोलने और बंद करने के साथ-साथ, इस्तेमाल के उदाहरणों को अनबाइंड करने की अनुमति दी जा सकती है.

अगर आपके कैमरे के सभी फ़ंक्शन, लाइफ़साइकल के बारे में जानकारी देने वाले किसी एक कॉम्पोनेंट की लाइफ़साइकल के हिसाब से काम करते हैं, जैसे कि AppCompatActivity या AppCompat फ़्रैगमेंट, तो इस्तेमाल के सभी ज़रूरी उदाहरणों को बाइंड करते समय उस कॉम्पोनेंट की लाइफ़साइकल का इस्तेमाल करने से यह पक्का होगा कि लाइफ़साइकल के बारे में जानकारी देने वाला कॉम्पोनेंट चालू होने पर, कैमरे के फ़ंक्शन तैयार हों. साथ ही, उन्हें सुरक्षित तरीके से बंद किया जा सके, ताकि वे किसी भी संसाधन का इस्तेमाल न करें.

कस्टम LifecycleOwners

ज़्यादा ऐडवांस मामलों के लिए, कस्टम LifecycleOwner बनाया जा सकता है. इससे आपके ऐप्लिकेशन को CameraX सेशन के लाइफ़साइकल को साफ़ तौर पर कंट्रोल करने की सुविधा मिलती है. इसके लिए, उसे स्टैंडर्ड Android LifecycleOwner से जोड़ने की ज़रूरत नहीं पड़ती.

यहां दिए गए कोड सैंपल में, एक सामान्य कस्टम LifecycleOwner बनाने का तरीका बताया गया है:

class CustomLifecycle : LifecycleOwner {
    private val lifecycleRegistry: LifecycleRegistry

    init {
        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.currentState = Lifecycle.State.CREATED
    }
    // ...
    fun doOnResume() {
        lifecycleRegistry.currentState = State.RESUMED
    }
    // ...
    override val lifecycle: Lifecycle
        get() = lifecycleRegistry
}Architecture.kt

इस LifecycleOwner का इस्तेमाल करके, आपका ऐप्लिकेशन अपने कोड में मनचाही जगहों पर स्टेट ट्रांज़िशन जोड़ सकता है. अपने ऐप्लिकेशन में इस सुविधा को लागू करने के बारे में ज़्यादा जानने के लिए, कस्टम LifecycleOwner को लागू करना लेख पढ़ें.

एक साथ इस्तेमाल करने के उदाहरण

इस्तेमाल के उदाहरण एक साथ चलाए जा सकते हैं. इस्तेमाल के उदाहरणों को क्रम से लाइफ़साइकल से जोड़ा जा सकता है. हालांकि, इस्तेमाल के सभी उदाहरणों को CameraProcessProvider.bindToLifecycle() के एक कॉल से जोड़ना बेहतर होता है. कॉन्फ़िगरेशन में बदलाव करने के सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, कॉन्फ़िगरेशन में बदलावों को मैनेज करना लेख पढ़ें.

यहां दिए गए कोड सैंपल में, ऐप्लिकेशन ने एक साथ बनाए जाने और चलाए जाने वाले दो इस्तेमाल के उदाहरणों के बारे में बताया है. यह दोनों इस्तेमाल के उदाहरणों के लिए इस्तेमाल की जाने वाली लाइफ़साइकल के बारे में भी बताता है, ताकि दोनों लाइफ़साइकल के हिसाब से शुरू और बंद हों.

private lateinit var imageCapture: ImageCapture

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

    cameraProviderFuture.addListener(
        Runnable {
            // Camera provider is now guaranteed to be available.
            val cameraProvider = cameraProviderFuture.get()

            // Set up the preview use case to display camera preview.
            val preview = Preview.Builder().build()

            // Set up the capture use case to allow users to take photos.
            imageCapture = ImageCapture.Builder()
                .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
                .build()

            // Choose the camera by requiring a lens facing.
            val cameraSelector = CameraSelector.Builder()
                .requireLensFacing(CameraSelector.LENS_FACING_FRONT)
                .build()

            // Attach use cases to the camera with the same lifecycle owner.
            val camera = cameraProvider.bindToLifecycle(
                this as LifecycleOwner, cameraSelector, preview, imageCapture
            )

            // Connect the preview use case to the previewView.
            preview.setSurfaceProvider(
                previewView.getSurfaceProvider()
            )
        },
        ContextCompat.getMainExecutor(this)
    )
}Architecture.kt

CameraX की मदद से, Preview, VideoCapture, ImageAnalysis, और ImageCapture के एक-एक इंस्टेंस को एक साथ इस्तेमाल किया जा सकता है. इसके अलावा,

इस्तेमाल का हर उदाहरण अपने-आप काम कर सकता है. उदाहरण के लिए, कोई ऐप्लिकेशन झलक दिखाए बिना वीडियो रिकॉर्ड कर सकता है.
एक्सटेंशन चालू होने पर, सिर्फ़ ImageCapture और Preview के कॉम्बिनेशन के काम करने की गारंटी होती है. ओईएम के लागू करने के तरीके के आधार पर, हो सकता है कि ImageAnalysis को भी न जोड़ा जा सके. VideoCapture के इस्तेमाल के उदाहरण के लिए, एक्सटेंशन चालू नहीं किए जा सकते. ज़्यादा जानकारी के लिए, एक्सटेंशन रेफ़रंस दस्तावेज़ देखें.
कैमरे की क्षमता के आधार पर, कुछ कैमरे कम रिज़ॉल्यूशन वाले मोड में कॉम्बिनेशन के साथ काम कर सकते हैं. हालांकि, कुछ ज़्यादा रिज़ॉल्यूशन वाले मोड में, वे उसी कॉम्बिनेशन के साथ काम नहीं कर सकते.
FULL या इससे कम लेवल के कैमरा हार्डवेयर वाले डिवाइसों पर, Preview, VideoCapture, और ImageCapture या ImageAnalysis को जोड़ने पर, CameraX को Preview और VideoCapture के लिए, कैमरे की PRIV स्ट्रीम का डुप्लीकेट बनाना पड़ सकता है. इस डुप्लिकेशन को स्ट्रीम शेयरिंग कहा जाता है. इसकी मदद से, इन सुविधाओं को एक साथ इस्तेमाल किया जा सकता है. हालांकि, इसके लिए ज़्यादा प्रोसेसिंग पावर की ज़रूरत होती है. इस वजह से, आपको इंतज़ार का समय थोड़ा ज़्यादा लग सकता है और बैटरी लाइफ़ कम हो सकती है.

इस्तेमाल किए जा सकने वाले हार्डवेयर लेवल की जानकारी, Camera2CameraInfo से हासिल की जा सकती है. उदाहरण के लिए, यहां दिया गया कोड यह जांच करता है कि डिफ़ॉल्ट बैक कैमरा, LEVEL_3 डिवाइस है या नहीं:

@androidx.annotation.OptIn(ExperimentalCamera2Interop::class)
fun isBackCameraLevel3Device(cameraProvider: ProcessCameraProvider): Boolean {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        return CameraSelector.DEFAULT_BACK_CAMERA
            .filter(cameraProvider.availableCameraInfos)
            .firstOrNull()
            ?.let { Camera2CameraInfo.from(it) }
            ?.getCameraCharacteristic(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) ==
            CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3
    }
    return false
}Architecture.kt

ध्यान दें: अगर इस्तेमाल के उदाहरणों का ऐसा कॉम्बिनेशन बनाया जाता है जो काम नहीं करता, तो पहली बार createCaptureSession() को कॉल करने पर, रनटाइम से जुड़ी गड़बड़ी का मैसेज दिखता है. अगर चल रहे सेशन में इस्तेमाल के अन्य उदाहरण जोड़े जाते हैं, तो हो सकता है कि आपको फिर से कॉन्फ़िगर करना पड़े. इससे, स्क्रीन पर कोई गड़बड़ी दिख सकती है.

अनुमतियां

आपके ऐप्लिकेशन को CAMERA अनुमति की ज़रूरत होगी. इमेज को फ़ाइलों में सेव करने के लिए, WRITE_EXTERNAL_STORAGE की अनुमति भी ज़रूरी होगी. हालांकि, Android 10 या इसके बाद के वर्शन वाले डिवाइसों पर ऐसा करने की ज़रूरत नहीं होगी.

अपने ऐप्लिकेशन के लिए अनुमतियां कॉन्फ़िगर करने के बारे में ज़्यादा जानने के लिए, ऐप्लिकेशन की अनुमतियों का अनुरोध करना लेख पढ़ें.

ज़रूरी शर्तें

CameraX के लिए, कम से कम ये वर्शन ज़रूरी हैं:

Android एपीआई लेवल 21
Android आर्किटेक्चर के कॉम्पोनेंट 1.1.1

लाइफ़साइकल के बारे में जानकारी देने वाली गतिविधियों के लिए, FragmentActivity या AppCompatActivity का इस्तेमाल करें.

डिपेंडेंसी का एलान करना

CameraX पर डिपेंडेंसी जोड़ने के लिए, आपको अपने प्रोजेक्ट में Google Maven रिपॉज़िटरी जोड़नी होगी.

अपने प्रोजेक्ट के लिए settings.gradle फ़ाइल खोलें और google() रिपॉज़िटरी जोड़ें, जैसा कि यहां दिखाया गया है:

Groovy

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

Kotlin

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

Android ब्लॉक के आखिर में यह जोड़ें:

Groovy

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    // For Kotlin projects
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Kotlin

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    // For Kotlin projects
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

किसी ऐप्लिकेशन के हर मॉड्यूल की build.gradle फ़ाइल में, यह कोड जोड़ें:

Groovy

dependencies {
  // CameraX core library using the camera2 implementation
  def camerax_version = "1.7.0-rc01"
  // The following line is optional, as the core library is included indirectly by camera-camera2
  implementation "androidx.camera:camera-core:${camerax_version}"
  implementation "androidx.camera:camera-camera2:${camerax_version}"
  // If you want to additionally use the CameraX Lifecycle library
  implementation "androidx.camera:camera-lifecycle:${camerax_version}"
  // If you want to additionally use the CameraX VideoCapture library
  implementation "androidx.camera:camera-video:${camerax_version}"
  // If you want to additionally use the CameraX View class
  implementation "androidx.camera:camera-view:${camerax_version}"
  // If you want to additionally add CameraX ML Kit Vision Integration
  implementation "androidx.camera:camera-mlkit-vision:${camerax_version}"
  // If you want to additionally use the CameraX Extensions library
  implementation "androidx.camera:camera-extensions:${camerax_version}"
}

Kotlin

dependencies {
    // CameraX core library using the camera2 implementation
    val camerax_version = "1.7.0-rc01"
    // The following line is optional, as the core library is included indirectly by camera-camera2
    implementation("androidx.camera:camera-core:${camerax_version}")
    implementation("androidx.camera:camera-camera2:${camerax_version}")
    // If you want to additionally use the CameraX Lifecycle library
    implementation("androidx.camera:camera-lifecycle:${camerax_version}")
    // If you want to additionally use the CameraX VideoCapture library
    implementation("androidx.camera:camera-video:${camerax_version}")
    // If you want to additionally use the CameraX View class
    implementation("androidx.camera:camera-view:${camerax_version}")
    // If you want to additionally add CameraX ML Kit Vision Integration
    implementation("androidx.camera:camera-mlkit-vision:${camerax_version}")
    // If you want to additionally use the CameraX Extensions library
    implementation("androidx.camera:camera-extensions:${camerax_version}")
}

इन ज़रूरी शर्तों के मुताबिक अपने ऐप्लिकेशन को कॉन्फ़िगर करने के बारे में ज़्यादा जानने के लिए, डिपेंडेंसी का एलान करना लेख पढ़ें.

Camera2 के साथ CameraX की इंटरऑपरेबिलिटी

CameraX को Camera2 पर बनाया गया है. CameraX, Camera2 के लागू होने पर प्रॉपर्टी को पढ़ने और लिखने के तरीके दिखाता है. पूरी जानकारी के लिए, Interop पैकेज देखें.

CameraX ने Camera2 की प्रॉपर्टी को कैसे कॉन्फ़िगर किया है, इस बारे में ज़्यादा जानने के लिए, Camera2CameraInfo का इस्तेमाल करके, CameraCharacteristics को पढ़ें. आपके पास Camera2 की प्रॉपर्टी को इनमें से किसी एक तरीके से लिखने का विकल्प भी है:

Camera2CameraControl का इस्तेमाल करें. इससे, CaptureRequest पर प्रॉपर्टी सेट की जा सकती हैं. जैसे, ऑटो-फ़ोकस मोड.
Camera2Interop.Extender की मदद से, CameraX UseCase को एक्सटेंड करें. इससे आपको CaptureRequest पर प्रॉपर्टी सेट करने की सुविधा मिलती है. ठीक वैसे ही जैसे Camera2CameraControl में मिलती है. इससे आपको कुछ अतिरिक्त कंट्रोल भी मिलते हैं. जैसे, स्ट्रीम के इस्तेमाल का उदाहरण सेट करना, ताकि कैमरे को आपके इस्तेमाल के हिसाब से ऑप्टिमाइज़ किया जा सके. ज़्यादा जानकारी के लिए, बेहतर परफ़ॉर्मेंस के लिए, स्ट्रीम के इस्तेमाल के उदाहरण देखें.

ध्यान दें: CameraX में, Camera2 की प्रॉपर्टी सेट करने की सुविधा को "एक्सपेरिमेंटल" के तौर पर मार्क किया गया है. ऐसा इसलिए, क्योंकि Google को उम्मीद है कि डेवलपर इसके इस्तेमाल को समझेंगे. आपकी सेट की गई वैल्यू, CameraX की सेट की गई वैल्यू को बदल देती हैं. हमारा सुझाव है कि ऐसा सिर्फ़ तब करें, जब बहुत ज़रूरी हो. साथ ही, हम आपको अपनी तरफ़ से अतिरिक्त टेस्टिंग करने का सुझाव देते हैं.

यहां दिए गए कोड सैंपल में, वीडियो कॉल को ऑप्टिमाइज़ करने के लिए, स्ट्रीम के इस्तेमाल के उदाहरणों का इस्तेमाल किया गया है. Camera2CameraInfo का इस्तेमाल करके, यह पता लगाएं कि वीडियो कॉल स्ट्रीम के इस्तेमाल का उदाहरण उपलब्ध है या नहीं. इसके बाद, Camera2Interop.Extender का इस्तेमाल करके, स्ट्रीम के इस्तेमाल का उदाहरण सेट करें.

// Set underlying Camera2 stream use case to optimize for video calls.

val videoCallStreamId =
    CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong()

// Check available CameraInfos to find the first one that supports
// the video call stream use case.
val frontCameraInfo = cameraProvider.getAvailableCameraInfos()
    .first { cameraInfo ->
        val isVideoCallStreamingSupported = Camera2CameraInfo.from(cameraInfo)
            .getCameraCharacteristic(
                CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES
            )?.contains(videoCallStreamId)
        val isFrontFacing = (cameraInfo.getLensFacing() == 
                             CameraSelector.LENS_FACING_FRONT)
        (isVideoCallStreamingSupported == true) && isFrontFacing
    }

val cameraSelector = frontCameraInfo.cameraSelector

// Start with a Preview Builder.
val previewBuilder = Preview.Builder()
    .setTargetAspectRatio(screenAspectRatio)
    .setTargetRotation(rotation)

// Use Camera2Interop.Extender to set the video call stream use case.
Camera2Interop.Extender(previewBuilder).setStreamUseCase(videoCallStreamId)

// Bind the Preview UseCase and the corresponding CameraSelector.
val preview = previewBuilder.build()
camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)

अन्य संसाधन

CameraX के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें.

कोडलैब (कोड बनाना सीखना)

CameraX का इस्तेमाल शुरू करना

कोड सैंपल

CameraX के सैंपल ऐप्लिकेशन