कॉन्फ़िगरेशन विकल्प

CameraX के इस्तेमाल के अलग-अलग उदाहरण को कॉन्फ़िगर करें, ताकि अलग-अलग पहलुओं को कंट्रोल किया जा सके केस की कार्रवाइयां.

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

val imageCapture = ImageCapture.Builder()
    .setFlashMode(...)
    .setTargetAspectRatio(...)
    .build()

ImageCapture imageCapture =
    new ImageCapture.Builder()
        .setFlashMode(...)
        .setTargetAspectRatio(...)
        .build();

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

कैमराएक्सफ़िग

आसानी से इस्तेमाल करने के लिए, CameraX में डिफ़ॉल्ट कॉन्फ़िगरेशन होते हैं, जैसे कि इंटरनल एक्ज़िक्यूटर और ऐसे हैंडलर हैं जो इस्तेमाल के ज़्यादातर मामलों में सही हैं. हालांकि, अगर आपके ऐप्लिकेशन के लिए विशेष आवश्यकताएं हैं या फिर उन शर्तों को कस्टमाइज़ करना कॉन्फ़िगरेशन, CameraXConfig उस उद्देश्य के लिए इंटरफ़ेस है.

CameraXConfig के साथ, एक ऐप्लिकेशन ये काम कर सकता है:

• इसकी मदद से, ऐप्लिकेशन के शुरू होने में लगने वाले समय को ऑप्टिमाइज़ करें setAvailableCameraLimiter().
• इसके साथ, CameraX को ऐप्लिकेशन का एक्ज़ीक्यूटर उपलब्ध कराएं setCameraExecutor().
• डिफ़ॉल्ट शेड्यूलर हैंडलर को इससे बदलें setSchedulerHandler().
• लॉग इन करने के लेवल को इसमें बदलें setMinimumLoggingLevel().

इस्तेमाल का मॉडल

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

1. पसंद के मुताबिक बनाए गए कॉन्फ़िगरेशन के साथ CameraXConfig ऑब्जेक्ट बनाएं.
2. लागू करें CameraXConfig.Provider आपके Application में इंटरफ़ेस और अपना CameraXConfig ऑब्जेक्ट इसमें दिखाएं getCameraXConfig().
3. अपनी Application क्लास को अपनी AndroidManifest.xml फ़ाइल में इस तौर पर जोड़ें यहां बताया गया है.

उदाहरण के लिए, नीचे दिया गया कोड सैंपल, CameraX में लॉग इन करने में गड़बड़ी को रोकता है केवल संदेश:

class CameraApplication : Application(), CameraXConfig.Provider {
   override fun getCameraXConfig(): CameraXConfig {
       return CameraXConfig.Builder.fromConfig(Camera2Config.defaultConfig())
           .setMinimumLoggingLevel(Log.ERROR).build()
   }
}

अगर आपके ऐप्लिकेशन को ज़रूरी शर्तें पूरी करने की ज़रूरत हो, तो CameraXConfig ऑब्जेक्ट की एक लोकल कॉपी अपने पास रखें CameraX को सेट करने के बाद उसका कॉन्फ़िगरेशन पता चलेगा.

कैमरा लिमिटर

इसके पहली बार शुरू करने के दौरान ProcessCameraProvider.getInstance(), CameraX, इन डिवाइस. क्योंकि CameraX को हार्डवेयर कॉम्पोनेंट के साथ कम्यूनिकेशन की ज़रूरत होती है, इसलिए यह हर कैमरे को प्रोसेस करने में थोड़ा समय लग सकता है. खास तौर पर, कम कीमत वाले डिवाइस. यदि आपका ऐप्लिकेशन डिवाइस पर केवल विशिष्ट कैमरों का उपयोग करता है, जैसे कि डिफ़ॉल्ट फ़्रंट कैमरा, CameraX को सेट करके अन्य कैमरों को अनदेखा किया जा सकता है, जो आपके ऐप्लिकेशन में इस्तेमाल होने वाले कैमरों के शुरू होने में लगने वाला समय कम कर सकता है.

अगर CameraSelector पास हो गया हो से CameraXConfig.Builder.setAvailableCamerasLimiter() किसी कैमरे को फ़िल्टर कर देता है, तो CameraX ऐसे काम करता है जैसे वह कैमरा मौजूद ही नहीं है. इसके लिए उदाहरण के लिए, निम्न कोड ऐप्लिकेशन को केवल डिवाइस के डिफ़ॉल्ट बैक कैमरा:

class MainApplication : Application(), CameraXConfig.Provider {
   override fun getCameraXConfig(): CameraXConfig {
       return CameraXConfig.Builder.fromConfig(Camera2Config.defaultConfig())
              .setAvailableCamerasLimiter(CameraSelector.DEFAULT_BACK_CAMERA)
              .build()
   }
}

थ्रेड

जिन प्लैटफ़ॉर्म एपीआई पर CameraX बनाया गया है उनमें से कई प्लैटफ़ॉर्म एपीआई को ब्लॉक करना ज़रूरी है हार्डवेयर के साथ इंटरप्रोसेस कम्यूनिकेशन (आईपीसी) जिसमें कभी-कभी सैकड़ों मिलीसेकंड में. इस वजह से, CameraX सिर्फ़ इन एपीआई को यहां से कॉल करता है बैकग्राउंड थ्रेड, ताकि मुख्य थ्रेड को ब्लॉक न किया जाए और यूज़र इंटरफ़ेस (यूआई) भी दिखे एक जैसा बना रहता है. CameraX इन बैकग्राउंड थ्रेड को अंदरूनी तौर पर मैनेज करता है, ताकि यह व्यवहार साफ़ तौर पर दिखता है. हालांकि, कुछ ऐप्लिकेशन के लिए सख्त कंट्रोल की ज़रूरत होती है में से थ्रेड. CameraXConfig, किसी ऐप्लिकेशन को बैकग्राउंड थ्रेड सेट करने की सुविधा देता है जिनका इस्तेमाल इसके ज़रिए किया जाता है CameraXConfig.Builder.setCameraExecutor() और CameraXConfig.Builder.setSchedulerHandler().

कैमरा एक्ज़ेक्यूटर

कैमरा एक्ज़िक्यूटर का इस्तेमाल सभी अंदरूनी कैमरा प्लैटफ़ॉर्म एपीआई कॉल के लिए भी किया जाता है जैसे कि इन एपीआई के कॉलबैक के लिए. CameraX, किसी इंटरनल स्टोरेज को तय और मैनेज करता है इन टास्क को करने के लिए, Executor. हालांकि, अगर आपके ऐप्लिकेशन को थ्रेड पर ज़्यादा कंट्रोल रखने की ज़रूरत है, तो CameraXConfig.Builder.setCameraExecutor().

शेड्यूलर हैंडलर

शेड्यूलर हैंडलर का इस्तेमाल, अंदरूनी टास्क को तय इंटरवल पर शेड्यूल करने के लिए किया जाता है, जैसे, कैमरा मौजूद न होने पर उसे फिर से खोलने की कोशिश करना. यह हैंडलर यह काम करता है जॉब को एक्ज़ीक्यूट नहीं करता है. साथ ही, उन्हें सिर्फ़ कैमरा एक्ज़िकेटर को भेजता है. यह भी है इसे कभी-कभी ऐसे लेगसी एपीआई प्लैटफ़ॉर्म पर इस्तेमाल किया जाता है जिन्हें कॉलबैक के लिए Handler. ऐसे मामलों में, कॉलबैक अब भी सीधे कैमरा एक्ज़िक्यूटर को ही भेजे जाते हैं. कैमराएक्स आपकी कंपनी को यह तय करता है कि इन टास्क को करने के लिए, HandlerThread, लेकिन आप इसे CameraXConfig.Builder.setSchedulerHandler() से बदल सकते हैं.

लॉग इन हो रहा है

CameraX में लॉग इन करने की सुविधा की मदद से, ऐप्लिकेशन लॉगकैट मैसेज को फ़िल्टर कर सकते हैं, क्योंकि यह अच्छा काम हो सकता है अपने प्रोडक्शन कोड में ज़्यादा शब्दों वाले मैसेज का इस्तेमाल करने से बचें. CameraX काम करता है ये चार लॉगिंग लेवल हैं, जिनमें सबसे ज़्यादा शब्दों से लेकर सबसे गंभीर के रूप में जानकारी दी गई है:

• Log.DEBUG (डिफ़ॉल्ट)
• Log.INFO
• Log.WARN
• Log.ERROR

Android लॉग दस्तावेज़ देखें इन लॉग लेवल की पूरी जानकारी पाने के लिए. इस्तेमाल की जाने वाली चीज़ें CameraXConfig.Builder.setMinimumLoggingLevel(int) ताकि आप अपने ऐप्लिकेशन के लिए सही लॉगिंग स्तर सेट कर सकें.

अपने-आप चुनना

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

CameraX का मकसद, कैमरा सेशन शुरू करना है. इसका मतलब है CameraX, डिवाइस की क्षमता के आधार पर रिज़ॉल्यूशन और आसपेक्ट रेशियो पर असर डालता है. समझौता इन वजहों से हो सकता है:

• डिवाइस, अनुरोध किए गए रिज़ॉल्यूशन पर काम नहीं करता.
• डिवाइस पर काम करने से जुड़ी समस्याएं हैं. जैसे, वे लेगसी डिवाइस जिन्हें कुछ रिज़ॉल्यूशन में काम कर सकते हैं.
• कुछ डिवाइसों पर, कुछ फ़ॉर्मैट सिर्फ़ खास आसपेक्ट रेशियो के लिए उपलब्ध होते हैं अनुपात.
• डिवाइस में "सबसे नज़दीकी mod16" को प्राथमिकता दी गई हो JPEG या वीडियो के लिए एन्कोडिंग ज़्यादा जानकारी के लिए, यह देखें SCALER_STREAM_CONFIGURATION_MAP.

हालांकि CameraX सेशन बनाता और उसे मैनेज करता है, लेकिन हमेशा आपके कोड में इस्तेमाल के उदाहरण वाले आउटपुट में इमेज के साइज़ दिखाता है और उसके हिसाब से उनमें बदलाव करता है.

रोटेशन

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

आपका ऐप्लिकेशन, कॉन्फ़िगरेशन सेटिंग का इस्तेमाल करके टारगेट रोटेशन सेट कर सकता है. इसके बाद यह काम कर सकता है इस्तेमाल के उदाहरण वाले एपीआई में दिए गए तरीकों का इस्तेमाल करके, रोटेशन सेटिंग अपडेट करें (जैसे ImageAnalysis.setTargetRotation()), भले ही लाइफ़साइकल चल रही हो. आप इसका इस्तेमाल तब कर सकते हैं जब ऐप्लिकेशन पोर्ट्रेट मोड में लॉक हो जाता है—और इसलिए, घुमाना—लेकिन फ़ोटो या विश्लेषण के उपयोग के मामले में, डिवाइस का मौजूदा रोटेशन. उदाहरण के लिए, रोटेशन जागरूकता की आवश्यकता हो सकती है तो चेहरे की पहचान करने के लिए, चेहरे सही तरीके से ओरिएंटेशन में हों या फ़ोटो लैंडस्केप पर सेट हों या पोर्ट्रेट.

कैप्चर की गई इमेज का डेटा, रोटेशन की जानकारी के बिना सेव किया जा सकता है. Exif डेटा इसमें रोटेशन की जानकारी होती है, ताकि गैलरी ऐप्लिकेशन में इमेज दिखा सके सहेजने के बाद सही ओरिएंटेशन.

झलक वाले डेटा को सही ओरिएंटेशन के साथ दिखाने के लिए, मेटाडेटा का इस्तेमाल करें से आउटपुट Preview.PreviewOutput() काफ़ी कुछ कर सकते हैं.

नीचे दिया गया कोड सैंपल, ओरिएंटेशन वाले इवेंट पर रोटेशन सेट करने का तरीका बताता है:

override fun onCreate() {
    val imageCapture = ImageCapture.Builder().build()

    val orientationEventListener = object : OrientationEventListener(this as Context) {
        override fun onOrientationChanged(orientation : Int) {
            // Monitors orientation values to determine the target rotation value
            val rotation : Int = when (orientation) {
                in 45..134 -> Surface.ROTATION_270
                in 135..224 -> Surface.ROTATION_180
                in 225..314 -> Surface.ROTATION_90
                else -> Surface.ROTATION_0
            }

            imageCapture.targetRotation = rotation
        }
    }
    orientationEventListener.enable()
}

@Override
public void onCreate() {
    ImageCapture imageCapture = new ImageCapture.Builder().build();

    OrientationEventListener orientationEventListener = new OrientationEventListener((Context)this) {
       @Override
       public void onOrientationChanged(int orientation) {
           int rotation;

           // Monitors orientation values to determine the target rotation value
           if (orientation >= 45 && orientation < 135) {
               rotation = Surface.ROTATION_270;
           } else if (orientation >= 135 && orientation < 225) {
               rotation = Surface.ROTATION_180;
           } else if (orientation >= 225 && orientation < 315) {
               rotation = Surface.ROTATION_90;
           } else {
               rotation = Surface.ROTATION_0;
           }

           imageCapture.setTargetRotation(rotation);
       }
    };

    orientationEventListener.enable();
}

सेट किए गए रोटेशन के आधार पर, इस्तेमाल का हर उदाहरण या तो इमेज के डेटा को घुमाता है इसकी मदद से सीधे तौर पर या बिना घुमाई गई इमेज के उपभोक्ताओं को रोटेशन मेटाडेटा देता है डेटा शामिल है.

• झलक देखें: मेटाडेटा आउटपुट दिया जाता है, ताकि टारगेट को घुमाया जा सके रिज़ॉल्यूशन का इस्तेमाल, Preview.getTargetRotation().
• ImageAnalysis: मेटाडेटा आउटपुट दिया जाता है, ताकि इमेज बफ़र हो सके निर्देशांकों को डिसप्ले निर्देशांक के आधार पर मापा जाता है.
• Image Capture: इमेज का Exif मेटाडेटा, बफ़र या बफ़र और रोटेशन सेटिंग को नोट करने के लिए मेटाडेटा बदल दिया जाता है. वैल्यू में बदलाव किया गया है एचएएल के इस्तेमाल पर निर्भर करता है.

क्रॉप रेक्टैंगल

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

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

val viewPort =  ViewPort.Builder(Rational(width, height), display.rotation).build()
val useCaseGroup = UseCaseGroup.Builder()
    .addUseCase(preview)
    .addUseCase(imageAnalysis)
    .addUseCase(imageCapture)
    .setViewPort(viewPort)
    .build()
cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, useCaseGroup)

ViewPort viewPort = new ViewPort.Builder(
         new Rational(width, height),
         getDisplay().getRotation()).build();
UseCaseGroup useCaseGroup = new UseCaseGroup.Builder()
    .addUseCase(preview)
    .addUseCase(imageAnalysis)
    .addUseCase(imageCapture)
    .setViewPort(viewPort)
    .build();
cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, useCaseGroup);

ViewPort, असली उपयोगकर्ताओं को दिखने वाले बफ़र रेक्टैंगल के बारे में जानकारी देता है. फिर CameraX कैलकुलेट करता है व्यूपोर्ट की विशेषताओं और इस्तेमाल के उदाहरण अटैच किए गए हैं. आम तौर पर, WYSIWYG इफ़ेक्ट पाने के लिए, व्यूपोर्ट को सही तरीके से सेट किया जा सकता है. व्यूपोर्ट प्राप्त करने का एक आसान तरीका यह है PreviewView का इस्तेमाल करने के लिए.

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

val viewport = findViewById<PreviewView>(R.id.preview_view).viewPort

ViewPort viewPort = ((PreviewView)findViewById(R.id.preview_view)).getViewPort();

पिछले उदाहरण में, ऐप्लिकेशन को ImageAnalysis से क्या मिलता है और ImageCapture, असली उपयोगकर्ता को PreviewView में जो दिखता है उससे ImageCapture मैच होता है. ऐसा यह मानते हुए किया जाता है कि PreviewView का स्केल टाइप डिफ़ॉल्ट FILL_CENTER पर सेट है. आवेदन करने के बाद क्रॉप रेक्टैंगल और आउटपुट बफ़र को घुमाना, इमेज को सभी तरह के इस्तेमाल के उदाहरण से हटाना वह एक जैसा होता है. हालांकि, यह अलग-अलग रिज़ॉल्यूशन के साथ हो सकता है. ज़्यादा के लिए ट्रांसफ़ॉर्मेशन की जानकारी को लागू करने का तरीका जानने के लिए, ट्रांसफ़ॉर्म करें आउटपुट.

कैमरा चुनना

CameraX आपके ऐप्लिकेशन के लिए सबसे अच्छा कैमरा डिवाइस अपने-आप चुन लेता है ज़रूरी शर्तें और इस्तेमाल के उदाहरण. अगर आपको डिवाइस के बजाय किसी दूसरे डिवाइस का इस्तेमाल करना है आपके लिए चुना गया है, तो कुछ विकल्प मौजूद हैं:

• इसके साथ डिफ़ॉल्ट सामने वाला कैमरा अनुरोध करें CameraSelector.DEFAULT_FRONT_CAMERA.
• इसके साथ डिफ़ॉल्ट रीयर कैमरा इस्तेमाल करने का अनुरोध करें CameraSelector.DEFAULT_BACK_CAMERA.
• उपलब्ध डिवाइसों की सूची को, उनके हिसाब से फ़िल्टर करें CameraCharacteristics के साथ CameraSelector.Builder.addCameraFilter().

नीचे दिया गया कोड सैंपल बताता है कि कैसे CameraSelector बनाया जाता है डिवाइस चयन को प्रभावित करें:

fun selectExternalOrBestCamera(provider: ProcessCameraProvider):CameraSelector? {
   val cam2Infos = provider.availableCameraInfos.map {
       Camera2CameraInfo.from(it)
   }.sortedByDescending {
       // HARDWARE_LEVEL is Int type, with the order of:
       // LEGACY < LIMITED < FULL < LEVEL_3 < EXTERNAL
       it.getCameraCharacteristic(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL)
   }

   return when {
       cam2Infos.isNotEmpty() -> {
           CameraSelector.Builder()
               .addCameraFilter {
                   it.filter { camInfo ->
                       // cam2Infos[0] is either EXTERNAL or best built-in camera
                       val thisCamId = Camera2CameraInfo.from(camInfo).cameraId
                       thisCamId == cam2Infos[0].cameraId
                   }
               }.build()
       }
       else -> null
    }
}

// create a CameraSelector for the USB camera (or highest level internal camera)
val selector = selectExternalOrBestCamera(processCameraProvider)
processCameraProvider.bindToLifecycle(this, selector, preview, analysis)

एक साथ कई कैमरे चुनें

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

समवर्ती कैमरे की सुविधा का इस्तेमाल करते समय, डिवाइस में दो कैमरे काम कर सकते हैं में एक ही समय में अलग-अलग लेंस इस्तेमाल किए जा सकते हैं या दो बैक कैमरे इस्तेमाल किए जा सकते हैं एक साथ. नीचे दिया गया कोड ब्लॉक दिखाता है कि दो कैमरे कैसे सेट किए जाते हैं bindToLifecycle को कॉल करो और लौटाए गए कैमरे से दोनों ऑब्जेक्ट लेने का तरीका बताओ ConcurrentCamera ऑब्जेक्ट.

// Build ConcurrentCameraConfig
val primary = ConcurrentCamera.SingleCameraConfig(
    primaryCameraSelector,
    useCaseGroup,
    lifecycleOwner
)

val secondary = ConcurrentCamera.SingleCameraConfig(
    secondaryCameraSelector,
    useCaseGroup,
    lifecycleOwner
)

val concurrentCamera = cameraProvider.bindToLifecycle(
    listOf(primary, secondary)
)

val primaryCamera = concurrentCamera.cameras[0]
val secondaryCamera = concurrentCamera.cameras[1]

// Build ConcurrentCameraConfig
SingleCameraConfig primary = new SingleCameraConfig(
    primaryCameraSelector,
    useCaseGroup,
    lifecycleOwner
);

SingleCameraConfig secondary = new SingleCameraConfig(
    primaryCameraSelector,
    useCaseGroup,
    lifecycleOwner
);

ConcurrentCamera concurrentCamera =  
    mCameraProvider.bindToLifecycle(Arrays.asList(primary, secondary));

Camera primaryCamera = concurrentCamera.getCameras().get(0);
Camera secondaryCamera = concurrentCamera.getCameras().get(1);

कैमरे का रिज़ॉल्यूशन

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

अपने-आप रिज़ॉल्यूशन

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

इमेज कैप्चर करने और इमेज का विश्लेषण करने के लिए, इस्तेमाल के उदाहरणों के लिए डिफ़ॉल्ट आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) 4:3 है.

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

उदाहरण के लिए, कोई ऐप्लिकेशन इनमें से कोई भी काम कर सकता है:

• इस्तेमाल के उदाहरण के लिए, टारगेट रिज़ॉल्यूशन को 4:3 या 16:9 पर सेट करें
• अपनी पसंद के मुताबिक रिज़ॉल्यूशन सेट करें, जिसे CameraX सबसे करीब ढूंढने की कोशिश करता है इससे मिलान करें
• ImageCapture को काटने का आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) बताएं

CameraX, Camera2 में मौजूद सतह के रिज़ॉल्यूशन को अपने-आप चुनता है. कॉन्टेंट बनाने नीचे दी गई टेबल में समाधान दिखाए गए हैं:

कोई रिज़ॉल्यूशन तय करें

इस्तेमाल के उदाहरण तैयार करते समय, खास रिज़ॉल्यूशन सेट करने के लिए setTargetResolution(Size resolution) तरीका, जैसा कि इस कोड में दिखाया गया है नमूना:

val imageAnalysis = ImageAnalysis.Builder()
    .setTargetResolution(Size(1280, 720))
    .build()

ImageAnalysis imageAnalysis =
  new ImageAnalysis.Builder()
    .setTargetResolution(new Size(1280, 720))
    .build();

एक ही इस्तेमाल में, टारगेट आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) और टारगेट रिज़ॉल्यूशन, दोनों को एक साथ सेट नहीं किया जा सकता केस. ऐसा करने से कॉन्फ़िगरेशन बनाते समय एक IllegalArgumentException दिखता है ऑब्जेक्ट है.

निर्देशांक में रिज़ॉल्यूशन Size को बताएं टारगेट रोटेशन से समर्थित साइज़ों को घुमाने के बाद फ़्रेम. उदाहरण के लिए, नैचुरल टारगेट रोटेशन में पोर्ट्रेट नैचुरल ओरिएंटेशन वाला डिवाइस पोर्ट्रेट चित्र 480x640 निर्दिष्ट कर सकती है, और उसी डिवाइस को 90 डिग्री घुमाया जा सकता है और टारगेटिंग लैंडस्केप ओरिएंटेशन 640x480 तय कर सकता है.

टारगेट रिज़ॉल्यूशन, इमेज के लिए कम से कम सीमा तय करने की कोशिश करता है का रिज़ॉल्यूशन. इमेज का असल रिज़ॉल्यूशन, इमेज के सबसे करीब मौजूद रिज़ॉल्यूशन के बराबर होता है का आकार, टारगेट रिज़ॉल्यूशन से कम नहीं होना चाहिए. कैमरा लागू करना.

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

अनुरोध के आधार पर, CameraX सबसे अच्छा रिज़ॉल्यूशन लागू करता है. अगर मुख्य तौर पर, आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) पूरा करना ज़रूरी है. सिर्फ़ setTargetAspectRatio बताएं. और CameraX, डिवाइस के हिसाब से खास रिज़ॉल्यूशन तय करता है. अगर ऐप्लिकेशन की मुख्य ज़रूरत इमेज बनाने के लिए, रिज़ॉल्यूशन तय करना है (उदाहरण के लिए, छोटी या मीडियम साइज़ की इमेज को डिवाइस प्रोसेस करने की क्षमता), setTargetResolution(Size resolution) का इस्तेमाल करें.

अगर आपके ऐप्लिकेशन को रिज़ॉल्यूशन की ज़रूरत है, तो इसके अंदर दी गई टेबल देखें createCaptureSession() का इस्तेमाल करें. यहां की यात्रा पर हूं वर्तमान डिवाइस द्वारा समर्थित विशिष्ट रिज़ॉल्यूशन जांचें, StreamConfigurationMap.getOutputSizes(int).

अगर आपका ऐप्लिकेशन Android 10 या इसके बाद वाले वर्शन पर चल रहा है, तो isSessionConfigurationSupported() किसी खास SessionConfiguration की पुष्टि करने के लिए.

कैमरे के आउटपुट को कंट्रोल करें

इसके अलावा, आपको हर डिवाइस के लिए, ज़रूरत के हिसाब से कैमरे से आउटपुट कॉन्फ़िगर करने की अनुमति भी मिलती है अलग-अलग इस्तेमाल के लिए, CameraX इन इंटरफ़ेस को भी लागू करता है, ताकि कैमरे की कार्रवाइयां, इस्तेमाल के सभी मामलों में आम तौर पर की जाती हैं:

• CameraControl आपको कैमरे की सामान्य सुविधाएं कॉन्फ़िगर करने के लिए.
• CameraInfo आपको क्वेरी करने देता है उन सामान्य कैमरा सुविधाओं की स्थिति को समझ लिया जाता है.

CameraControl के साथ काम करने वाले कैमरे की ये सुविधाएं हैं:

• Zoom
• टॉर्च
• फ़ोकस और मीटरिंग (टैप-टू-फ़ोकस)
• एक्सपोज़र मुआवज़ा

CameraControl और CameraInfo के इंस्टेंस पाना

इसका इस्तेमाल करके CameraControl और CameraInfo के इंस्टेंस फिर से पाएं Camera ऑब्जेक्ट को इन्होंने लौटाया ProcessCameraProvider.bindToLifecycle(). यह कोड एक उदाहरण दिखाता है:

val camera = processCameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview)

// For performing operations that affect all outputs.
val cameraControl = camera.cameraControl
// For querying information and states.
val cameraInfo = camera.cameraInfo

Camera camera = processCameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview)

// For performing operations that affect all outputs.
CameraControl cameraControl = camera.getCameraControl()
// For querying information and states.
CameraInfo cameraInfo = camera.getCameraInfo()

उदाहरण के लिए, इसके बाद ज़ूम और अन्य CameraControl कार्रवाइयां सबमिट की जा सकती हैं bindToLifecycle() को कॉल किया जा रहा है. बाइंड करने के लिए इस्तेमाल की जाने वाली गतिविधि को बंद करने या न करने के बाद कैमरा इंस्टेंस, CameraControl अब कार्रवाइयां नहीं कर सकता और गड़बड़ी ListenableFuture दिखाता है.

Zoom

CameraControl, ज़ूम स्तर बदलने के दो तरीके ऑफ़र करता है:

• setZoomRatio() ज़ूम अनुपात को ज़ूम करता है.

  अनुपात, इसकी रेंज के अंदर होना चाहिए CameraInfo.getZoomState().getValue().getMinZoomRatio() और CameraInfo.getZoomState().getValue().getMaxZoomRatio(). वरना फ़ंक्शन, नतीजा नहीं पाने वाला ListenableFuture दिखाता है.

• setLinearZoom() मौजूदा ज़ूम को 0 से 1.0 के बीच के लीनियर ज़ूम वैल्यू के साथ सेट करता है.

  लीनियर ज़ूम का फ़ायदा यह है कि यह फ़ील्ड ऑफ़ व्यू (एफ़ओवी) बनाता है साथ ही, ज़ूम इन बदलावों से भी मिलता है. इस वजह से, यह प्रॉडक्ट के साथ इस्तेमाल करने के लिए सही है Slider व्यू.

CameraInfo.getZoomState() ज़ूम की मौजूदा स्थिति का LiveData दिखाता है. कैमरा चुनने पर वैल्यू बदल जाती है शुरू हो जाता है या setZoomRatio() का इस्तेमाल करके ज़ूम लेवल सेट किया गया हो या setLinearZoom(). किसी भी तरीके को कॉल करने से, बैक की जाने वाली वैल्यू सेट हो जाती हैं ZoomState.getZoomRatio() और ZoomState.getLinearZoom(). अगर आपको ज़ूम रेशियो वाले टेक्स्ट को स्लाइडर के साथ दिखाना है, तो यह तरीका मददगार होता है. बिना कोई बदलाव किए, दोनों को अपडेट करने के लिए, ZoomState LiveData पर नज़र डालें कन्वर्ज़न होता है.

दोनों एपीआई से मिले ListenableFuture में, ऐप्लिकेशन इस्तेमाल करने का विकल्प होता है दिए गए ज़ूम मान के साथ बार-बार होने वाले अनुरोध की पूरा हुआ. इसके अतिरिक्त, यदि आप पिछली कार्रवाई के दौरान नया ज़ूम मान सेट करते हैं तो ज़ूम करने की पिछली कार्रवाई का ListenableFuture पूरा नहीं हुआ तुरंत.

टॉर्च

CameraControl.enableTorch(boolean) टॉर्च को चालू या बंद करती है (जिसे फ़्लैशलाइट के नाम से भी जाना जाता है).

CameraInfo.getTorchState() का इस्तेमाल टॉर्च की मौजूदा स्थिति के बारे में क्वेरी करने के लिए किया जा सकता है. आप लौटाया गया मान देख सकते हैं लेखक CameraInfo.hasFlashUnit() का इस्तेमाल करके यह पता लगाया जा सकता है कि कोई टॉर्च उपलब्ध है या नहीं. अगर नहीं, तो कॉल किया जा रहा है CameraControl.enableTorch(boolean) की वजह से, ListenableFuture ये आइटम वापस आता है पूरा न होने पर, तुरंत पूरा होता है. साथ ही, टॉर्च की स्थिति को TorchState.OFF.

टॉर्च चालू होने पर, फ़ोटो और वीडियो कैप्चर करने के दौरान यह चालू रहती है FlashMode सेटिंग पर ध्यान दिए बिना. कॉन्टेंट बनाने flashMode इंच ImageCapture सिर्फ़ टॉर्च के बंद होने पर ही काम करता है.

फ़ोकस और मीटरिंग

CameraControl.startFocusAndMetering() AF/AE/AWB मीटरिंग क्षेत्र सेट करके ऑटोफ़ोकस और एक्सपोज़र मीटरिंग ट्रिगर करता है यह विकल्प दिए गए FocusMeteringAction के हिसाब से तय होता है. इसका इस्तेमाल अक्सर “टैप का इस्तेमाल करें” सुविधा का इस्तेमाल करें.

मीटरिंगपॉइंट

शुरू करने के लिए, MeteringPoint का इस्तेमाल किया जा रहा है MeteringPointFactory.createPoint(float x, float y, float size). MeteringPoint, कैमरे पर सिंगल पॉइंट दिखाता है Surface. यह एक नॉर्मलाइज़्ड रूप में सेव होती है ताकि इसे निर्दिष्ट करने के लिए सेंसर निर्देशांक में आसानी से बदला जा सके AF/AE/AWB क्षेत्र.

MeteringPoint का साइज़ 0 से 1 तक होता है. साथ ही, साइज़ का डिफ़ॉल्ट साइज़ 0.15f. MeteringPointFactory.createPoint(float x, float y, float size) को कॉल करते समय, CameraX दिए गए बॉक्स के लिए एक रेक्टैंगल क्षेत्र बनाता है, जो (x, y) के बीच में होता है size.

यह कोड, MeteringPoint बनाने का तरीका बताता है:

// Use PreviewView.getMeteringPointFactory if PreviewView is used for preview.
previewView.setOnTouchListener((view, motionEvent) ->  {
val meteringPoint = previewView.meteringPointFactory
    .createPoint(motionEvent.x, motionEvent.y)
…
}

// Use DisplayOrientedMeteringPointFactory if SurfaceView / TextureView is used for
// preview. Please note that if the preview is scaled or cropped in the View,
// it’s the application's responsibility to transform the coordinates properly
// so that the width and height of this factory represents the full Preview FOV.
// And the (x,y) passed to create MeteringPoint might need to be adjusted with
// the offsets.
val meteringPointFactory = DisplayOrientedMeteringPointFactory(
     surfaceView.display,
     camera.cameraInfo,
     surfaceView.width,
     surfaceView.height
)

// Use SurfaceOrientedMeteringPointFactory if the point is specified in
// ImageAnalysis ImageProxy.
val meteringPointFactory = SurfaceOrientedMeteringPointFactory(
     imageWidth,
     imageHeight,
     imageAnalysis)

startFocusAndMetering और FocusMeteringAction

शुरू करने के लिए startFocusAndMetering(), ऐप्लिकेशन को एक FocusMeteringAction जिसमें वैकल्पिक मीटरिंग मोड के साथ एक या ज़्यादा MeteringPoints शामिल है से संयोजन FLAG_AF, FLAG_AE, FLAG_AWB. कॉन्टेंट बनाने 'फ़ॉलो करें' कोड में इसके इस्तेमाल की जानकारी दी गई है:

val meteringPoint1 = meteringPointFactory.createPoint(x1, x1)
val meteringPoint2 = meteringPointFactory.createPoint(x2, y2)
val action = FocusMeteringAction.Builder(meteringPoint1) // default AF|AE|AWB
      // Optionally add meteringPoint2 for AF/AE.
      .addPoint(meteringPoint2, FLAG_AF | FLAG_AE)
      // The action is canceled in 3 seconds (if not set, default is 5s).
      .setAutoCancelDuration(3, TimeUnit.SECONDS)
      .build()

val result = cameraControl.startFocusAndMetering(action)
// Adds listener to the ListenableFuture if you need to know the focusMetering result.
result.addListener({
   // result.get().isFocusSuccessful returns if the auto focus is successful or not.
}, ContextCompat.getMainExecutor(this)

जैसा कि पिछले कोड में दिखाया गया है, startFocusAndMetering() AF/AE/AWB के लिए एक MeteringPoint वाला FocusMeteringAction लेता है सिर्फ़ AF और AE के लिए मीटरिंग क्षेत्र और दूसरा मीटरिंगपॉइंट.

अंदरूनी तौर पर, CameraX इसे Camera2 में बदल देता है MeteringRectangles और संबंधित कीवर्ड को सेट करता है CONTROL_AF_REGIONS / CONTROL_AE_REGIONS / CONTROL_AWB_REGIONS पैरामीटर का इस्तेमाल करें.

हर डिवाइस AF/AE/AWB और कई क्षेत्रों के साथ काम नहीं करता है, इसलिए CameraX काम करता है FocusMeteringAction को बेहतर बनाने में साथ दें. CameraX उतने ही नंबर का इस्तेमाल करता है जितने की अनुमति है जिस क्रम में पॉइंट जोड़े गए थे, उसी क्रम में मीटरिंगपॉइंट का इस्तेमाल किया जा सकता है. सभी अधिकतम संख्या के बाद जोड़े गए मीटरिंगपॉइंट को अनदेखा कर दिया जाता है. उदाहरण के लिए, अगर FocusMeteringAction को ऐसे प्लैटफ़ॉर्म पर तीन मीटरिंगपॉइंट के साथ सप्लाई किया जाता है: सिर्फ़ 2, सिर्फ़ पहले 2 मीटरिंगपॉइंट का इस्तेमाल किया जाता है. आखिरी MeteringPoint है CameraX ने अनदेखा कर दिया.

एक्सपोज़र मुआवज़ा

एक्सपोज़र मुआवज़ा तब काम आता है, जब ऐप्लिकेशन को एक्सपोज़र को बेहतर बनाने की ज़रूरत होती है ऑटो एक्सपोज़र (एई) आउटपुट के अलावा, अन्य वैल्यू (ईवी) भी शामिल हैं. एक्सपोज़र मुआवज़ा इस डेटा को इस तरह से जोड़ा जाता है कि इमेज की मौजूदा स्थितियां:

Exposure = ExposureCompensationIndex * ExposureCompensationStep

CameraX, Camera.CameraControl.setExposureCompensationIndex() का इस्तेमाल, एक्सपोज़र कंपंसेशन को इंडेक्स वैल्यू के रूप में सेट करने के लिए किया जाता है.

पॉज़िटिव इंडेक्स वैल्यू से इमेज की चमक बढ़ जाती है, जबकि नेगेटिव वैल्यू से इमेज की रोशनी कम हो जाती है इमेज. ऐप्लिकेशन इसके ज़रिए समर्थित श्रेणी पर क्वेरी कर सकते हैं CameraInfo.ExposureState.exposureCompensationRange() अगले सेक्शन में बताया गया है. अगर यह वैल्यू इस्तेमाल की जा सकती है, तो ListenableFuture में वैल्यू तब पूरी होती है, जब कैप्चर करने का अनुरोध; अगर दिया गया इंडेक्स, इस्तेमाल की जा सकने वाली रेंज से बाहर है, setExposureCompensationIndex() की वजह से ListenableFuture, जो नतीजा न मिला हो उसे तुरंत पूरा करें.

CameraX, सिर्फ़ सबसे सही setExposureCompensationIndex() को सेव रखता है और पिछले अनुरोध से पहले फ़ंक्शन को कई बार कॉल किया जा सकता है को रद्द करने पर, एक्ज़ीक्यूट किए गए नतीजे मिल जाते हैं.

नीचे दिया गया स्निपेट एक एक्सपोज़र कंपंसेशन इंडेक्स सेट करता है और एक्सपोज़र में बदलाव का अनुरोध पूरा होने के बाद, इसके लिए कॉलबैक करें:

camera.cameraControl.setExposureCompensationIndex(exposureCompensationIndex)
   .addListener({
      // Get the current exposure compensation index, it might be
      // different from the asked value in case this request was
      // canceled by a newer setting request.
      val currentExposureIndex = camera.cameraInfo.exposureState.exposureCompensationIndex
      …
   }, mainExecutor)

• Camera.CameraInfo.getExposureState() मौजूदा जानकारी को वापस लाता है ExposureState शामिल हैं:

  • एक्सपोज़र मुआवज़ा कंट्रोल की सपोर्टेबिलिटी.
  • मौजूदा एक्सपोज़र मुआवज़ा इंडेक्स.
  • एक्सपोज़र कंपंसेशन इंडेक्स की रेंज.
  • एक्सपोज़र कंपंसेशन की वैल्यू में इस्तेमाल किया गया एक्सपोज़र कंपंसेशन का चरण गणना.

उदाहरण के लिए, यहां दिया गया कोड एक्सपोज़र के लिए सेटिंग शुरू करता है मौजूदा ExposureState के साथ SeekBar मान:

val exposureState = camera.cameraInfo.exposureState
binding.seekBar.apply {
   isEnabled = exposureState.isExposureCompensationSupported
   max = exposureState.exposureCompensationRange.upper
   min = exposureState.exposureCompensationRange.lower
   progress = exposureState.exposureCompensationIndex
}

अन्य संसाधन

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

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

कोड सैंपल

डेवलपर कम्यूनिटी

Android CameraX चर्चा समूह