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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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. अपने Application में CameraXConfig.Provider इंटरफ़ेस लागू करें और getCameraXConfig() में अपना CameraXConfig ऑब्जेक्ट दिखाएं.
3. अपनी Application क्लास को अपनी AndroidManifest.xml फ़ाइल में इस तौर पर जोड़ें यहां बताया गया है.

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

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

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

कैमरा लिमिटर

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

अगर CameraXConfig.Builder.setAvailableCamerasLimiter() को पास किया गया CameraSelector किसी कैमरे को फ़िल्टर करता है, तो 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() के ज़रिए किया जाता है.

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

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

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

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

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

CameraX लॉगिंग की मदद से, ऐप्लिकेशन logcat मैसेज फ़िल्टर कर सकते हैं. ऐसा इसलिए, क्योंकि प्रोडक्शन कोड में ज़्यादा शब्दों वाले मैसेज से बचने के लिए, यह एक अच्छा तरीका हो सकता है. 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: मेटाडेटा आउटपुट इसलिए दिया जाता है, ताकि डिसप्ले कोऑर्डिनेट के हिसाब से इमेज बफ़र कोऑर्डिनेट पता चल सकें.
• ImageCapture: रोटेशन सेटिंग को नोट करने के लिए, इमेज के 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 में जो दिखता है उससे मैच करता है, यह मानते हुए कि PreviewView का स्केल टाइप डिफ़ॉल्ट FILL_CENTER पर सेट है. आवेदन करने के बाद क्रॉप रेक्टैंगल और आउटपुट बफ़र को घुमाना, इमेज को सभी तरह के इस्तेमाल के उदाहरण से हटाना वह एक जैसी होती है. हालांकि, यह अलग-अलग रिज़ॉल्यूशन के साथ हो सकती है. ट्रांसफ़ॉर्मेशन की जानकारी को लागू करने के तरीके के बारे में ज़्यादा जानने के लिए, आउटपुट को ट्रांसफ़ॉर्म करना देखें.

कैमरा चुनना

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

• इसके साथ डिफ़ॉल्ट सामने वाला कैमरा अनुरोध करें CameraSelector.DEFAULT_FRONT_CAMERA.
• CameraSelector.DEFAULT_BACK_CAMERA का इस्तेमाल करके, डिफ़ॉल्ट रूप से सेट किए गए पीछे वाले कैमरे का अनुरोध करें.
• उपलब्ध डिवाइसों की सूची को उनके नाम के हिसाब से फ़िल्टर करने के लिए, 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 या इसके बाद के वर्शन पर चल रहा है, तो किसी खास SessionConfiguration की पुष्टि करने के लिए, isSessionConfigurationSupported() का इस्तेमाल किया जा सकता है.

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

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()

उदाहरण के लिए, bindToLifecycle() को कॉल करने के बाद, ज़ूम और अन्य CameraControl ऑपरेशन सबमिट किए जा सकते हैं. बाइंड करने के लिए इस्तेमाल की जाने वाली गतिविधि को बंद करने या न करने के बाद कैमरा इंस्टेंस, 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 सेटिंग पर ध्यान दिए बिना. ImageCapture में मौजूद flashMode सिर्फ़ तब काम करता है, जब टॉर्च बंद हो.

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

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

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

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

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() FocusMeteringAction का इस्तेमाल किया जाता है. इसमें AF/AE/AWB के लिए एक MeteringPoint और सिर्फ़ AF और AE के लिए एक और मेज़रिंग पॉइंट होता है.

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

हर डिवाइस पर AF/AE/AWB और एक से ज़्यादा क्षेत्रों के लिए ऑटोमैटिक फ़ोकस की सुविधा काम नहीं करती. इसलिए, CameraX FocusMeteringAction को बेहतर तरीके से लागू करने की कोशिश करता है. CameraX उतने ही नंबर का इस्तेमाल करता है जितने की अनुमति है जिस क्रम में पॉइंट जोड़े गए थे, उसी क्रम में मीटरिंगपॉइंट का इस्तेमाल किया जा सकता है. सभी अधिकतम संख्या के बाद जोड़े गए मीटरिंगपॉइंट को अनदेखा कर दिया जाता है. उदाहरण के लिए, अगर किसी FocusMeteringAction को ऐसे प्लैटफ़ॉर्म पर तीन मेज़रिंग पॉइंट दिए जाते हैं जो सिर्फ़ दो मेज़रिंग पॉइंट के साथ काम करता है, तो सिर्फ़ पहले दो मेज़रिंग पॉइंट का इस्तेमाल किया जाता है. आखिरी 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 चर्चा समूह