CameraX और डिवाइस में मौजूद इंटेलिजेंस की मदद से, अलग-अलग डिवाइसों पर कैमरे से जुड़ी सुविधाओं को बेहतर बनाना

सभी को नमस्ते।

हमारे सेशन में आपका स्वागत है.

मैं अमन हूं और मेरे साथ स्कॉट हैं.

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

चलिए, शुरू करते हैं.

इस बारे में सोचें कि आपको अपने फ़ोन का इस्तेमाल कैसे करना है.

हम अक्सर अपने फ़ोन के कैमरे का इस्तेमाल करके, यादगार पलों को कैप्चर करते हैं और उन्हें अपने करीबियों के साथ शेयर करते हैं.

स्मार्टफ़ोन के अनुभव में कैमरा सबसे अहम भूमिका निभाता है.

स्मार्टफ़ोन खरीदते समय, लोग अक्सर अच्छे कैमरे को प्राथमिकता देते हैं.

आज हम कैमरे का बेहतरीन अनुभव देने के लिए, दो मुख्य थीम के बारे में बात करेंगे.

सबसे पहले, हम CameraX की कुछ सुविधाओं के बारे में जानेंगे. इसके बाद, हम डिवाइस पर मौजूद मशीन लर्निंग की कुछ तकनीकों के बारे में जानेंगे.

चलिए, CameraX से शुरुआत करते हैं.

Jetpack CameraX, Android पर कैमरे की सुविधाओं को बेहतर बनाता है.

CameraX के अलावा, हमारे पास Camera1 और Camera2 भी हैं. ये Android प्लैटफ़ॉर्म फ़्रेमवर्क का हिस्सा हैं.

आपको कौनसी लाइब्रेरी इस्तेमाल करनी चाहिए?

Camera1, Android पर ओरिजनल कैमरा एपीआई था.

अब इसे बंद कर दिया गया है. इसलिए, नए ऐप्लिकेशन को Camera2 या CameraX का इस्तेमाल करना चाहिए.

Camera2, Camera1 का अपग्रेड किया गया वर्शन है.

इसलिए, अगर आपको मुश्किल मामलों में लो-लेवल कैमरा कंट्रोल की ज़रूरत है, तो Camera2 एक अच्छा विकल्प है.

हालांकि, इसके लिए आपको डिवाइस के हिसाब से कॉन्फ़िगरेशन खुद मैनेज करने होंगे.

Jetpack CameraX, Camera2 पर आधारित है.

यह एक जैसा एपीआई उपलब्ध कराता है और डिवाइस के हिसाब से कॉन्फ़िगरेशन को अपने-आप मैनेज करता है.

ज़्यादातर डेवलपर के लिए, यह विकल्प सबसे सही है.

हमें एक बहुत ज़रूरी बात बतानी है.

हम Camera1 को बंद करने की योजना बना रहे हैं. इसकी शुरुआत अगले साल Android 18 में, Google Play की नीति को लागू करने के साथ होगी.

अगर अब भी लेगसी Camera1 API का इस्तेमाल किया जा रहा है, तो आपको CameraX या Camera2 पर माइग्रेट करना होगा.

इसलिए, आपको CameraX का इस्तेमाल क्यों करना चाहिए?

सबसे पहले, यह Android 7 और इसके बाद के वर्शन के साथ काम करता है. इस वजह से, यह करीब 99% चालू Android डिवाइसों के साथ काम करता है.

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

तीसरा, यह सभी डिवाइसों पर एक जैसा अनुभव देता है. इसके लिए, यह डिवाइस के हिसाब से आने वाली समस्याओं को कम करता है. जैसे, झलक का स्ट्रेच होना. यह समस्या फ़ोल्ड किए जा सकने वाले डिवाइसों और टैबलेट पर आम है.

आखिर में, यह नाइट मोड और पोर्ट्रेट जैसी बेहतर ओईएम सुविधाओं को लागू करने की प्रोसेस को आसान बनाता है.

अब मैं स्कॉट को बुलाना चाहूंगा, ताकि वे CameraX की कुछ सुविधाओं के बारे में बता सकें.

स्कॉट, अब आपकी बारी.

धन्यवाद अमन.

सभी को नमस्ते।

मेरा नाम स्कॉट है.

आज हम CameraX की कई सुविधाओं के बारे में बात करेंगे, ताकि आप प्रोफ़ेशनल लेवल का कैमरा अनुभव तैयार कर सकें.

सबसे पहले बात करते हैं अडैप्टिव व्यूफ़ाइंडर की.

इसे इस तरह से डिज़ाइन किया गया है कि अलग-अलग साइज़, डाइमेंशन या कॉन्फ़िगरेशन वाले डिवाइसों और स्क्रीन साइज़ पर हैंडल की झलक देखने में कोई परेशानी न हो.

उपयोगकर्ता अब कई तरह के डिवाइसों का इस्तेमाल करते हैं. इनमें फ़ोल्ड किए जा सकने वाले डिवाइस, फ़ोन, लैपटॉप, और XR डिवाइस शामिल हैं.

इसलिए, यह ज़रूरी है कि कैमरे का अनुभव नए फ़ॉर्म फ़ैक्टर के हिसाब से हो.

कैमरे की झलक को सही तरीके से दिखाना काफ़ी मुश्किल होता है. खास तौर पर, वाइडस्क्रीन वाले फ़ोल्ड किए जा सकने वाले डिवाइसों पर.

इन डिवाइसों को अनफ़ोल्ड करने पर, इनका इनर कैमरा हॉरिज़ॉन्टल और बैक कैमरा वर्टिकल तौर पर माउंट होता है.

इसलिए, अगर आपको लगता है कि सभी कैमरा सेंसर वर्टिकल तौर पर माउंट किए गए हैं, तो आपको स्पेसियल मिसमैच का सामना करना पड़ेगा. इससे इमेज में डिस्टॉर्शन या साइडवेज़ की समस्या आएगी.

CameraXViewfinder को इस तरह डिज़ाइन किया गया है कि यह आपके लिए जटिलता को पूरी तरह से मैनेज कर सके. इससे यह पक्का किया जा सकता है कि आपके कैमरे की झलक, सभी फ़ॉर्म फ़ैक्टर पर आसानी से काम करे.

आइए, CameraXViewfinder कंपोज़ेबल को इस्तेमाल करने का तरीका जानें.

var surfaceRequest by remember {
    mutableStateOf<SurfaceRequest?>(null)
}

LaunchedEffect(...) {
    preview.setSurfaceProvider { surfaceRequest = it }
    cameraProvider.bindToLifecycle(..., preview)
}

surfaceRequest?.let { request ->
    CameraXViewfinder(
        surfaceRequest = request,
        contentScale = ContentScale.Fit
    )
}

सबसे पहले, आपको surfaceRequest कॉन्टेंट वैरिएबल का एलान करना होगा, ताकि सरफ़ेस के अनुरोध को सेव किया जा सके.

माफ़ करें.

दूसरा, LaunchedEffect में, आपने सरफेस प्रोवाइडर को सेट किया है, ताकि वह सरफेस रिक्वेस्ट ऑब्जेक्ट को कैप्चर कर सके.

इसके बाद, आपको लाइफ़साइकल से बाइंड करना होगा और फिर कैमरा चालू करना होगा.

आखिर में, जब भी मान्य सरफ़ेस अनुरोध के साथ स्टेट अपडेट होता है और फिर से कंपोज़िशन ट्रिगर होता है, तो अनुरोध को सीधे CameraXViewfinder पर सेट किया जाता है.

यहां अपनी पसंद के मुताबिक, contentScale को फ़िट या क्रॉप करने के लिए सेट किया जा सकता है.

बस इतना ही, अब आप पूरी तरह से तैयार हैं.

CameraX 1.7 में, हमने CameraXViewfinder में कई नई सुविधाएं जोड़ी हैं.

इसमें, टैप करके फ़ोकस करने या पिंच करके ज़ूम करने जैसे नए जेस्चर शामिल हैं.

इसमें स्क्रीन फ़्लैश की सुविधा भी है. इससे सेल्फ़ी को बेहतर बनाने के लिए, स्क्रीन का इस्तेमाल किया जा सकता है.

इस सुविधा को लागू करना आसान है.

CameraXViewfinder(
    surfaceRequest = viewModel.surfaceRequest,
    contentScale = ContentScale.Fit,
    isTapToFocusEnabled = true,
    isPinchToZoomEnabled = true,
    onScreenFlashReady =
        {
           imageCapture.screenFlash = it
           imageCapture.flashMode = FLASH_MODE_SCREEN
        }
)

आपको बस टैप करके फ़ोकस करने और पिंच करके ज़ूम करने की सुविधा को चालू करना होगा.

स्क्रीन फ़्लैश के लिए, आपको onScreenFlashReady कॉलबैक से स्क्रीन फ़्लैश इंस्टेंस मिलता है. इसके बाद, इसे ImageCapture में पास करें और फ़्लैश मोड को FLASH_MODE_SCREEN पर सेट करें.

बस इतना ही!

हमने देखा है कि CameraX की मदद से, कैमरे की झलक देखने की सुविधा चालू की जा सकती है. यह सुविधा, सभी डिवाइसों पर आसानी से काम करती है.

आइए, अब Android XR पर कैमरे से कैप्चर करने के बारे में जानें.

एक्सआर डिवाइसों को तीन कैटगरी में बांटा गया है: पहली कैटगरी है एक्सआर हेडसेट.

ये पूरी तरह से बंद और इमर्सिव हेडसेट होते हैं. ये कैमरे का इस्तेमाल करके, आस-पास की दुनिया को कैप्चर करते हैं और उसे हेडसेट के अंदर दिखाते हैं.

दूसरा, वायर वाले एक्सआर स्मार्ट ग्लास.

हमने आज इस कैटगरी के कीनोट में, XREAL Aura का एलान किया है.

जैसा कि आपने कीनोट में देखा, ये पारदर्शी ग्लास हैं, जो कंप्यूट पक से कनेक्ट होते हैं. इनकी मदद से, असल दुनिया में वर्चुअल कॉन्टेंट को ओवरले करके देखा जा सकता है.

तीसरा, ऑडियो और डिसप्ले ग्लास.

ये हल्के चश्मे हैं.

इनमें ऑडियो, कैमरा, और डिसप्ले को एक साथ इस्तेमाल किया जा सकता है. इससे, बोलकर इस्तेमाल करने और एक नज़र में जानकारी पाने की सुविधा मिलती है.

साथ ही, एक्सआर हेडसेट और वायर वाले एक्सआर स्मार्ट ग्लास, Camera2 और CameraX के साथ भी काम करते हैं. ठीक वैसे ही जैसे कोई सामान्य फ़ोन काम करता है.

इसलिए, आज हम सिर्फ़ ऑडियो और डिसप्ले ग्लास के बारे में बात करेंगे.

इन स्मार्ट ग्लास पर, ऐप्लिकेशन स्मार्ट ग्लास के बजाय Android फ़ोन, होस्ट Android फ़ोन पर चलते हैं. हालांकि, यहां फ़ोन के कैमरे और स्मार्ट ग्लास के कैमरे, दोनों का ऐक्सेस होता है.

सबसे अहम सवाल यह है कि आपको कैसे पता चलेगा कि किस कैमरे से बात की जा रही है?

इसलिए, यह आसान है.

स्टैंडर्ड कॉन्टेक्स्ट के साथ, CameraX आपके फ़ोन के कैमरे को ऐक्सेस करता है.

ProjectedDeviceContext की मदद से, CameraX स्मार्ट ग्लास के कैमरे को ऐक्सेस करता है.

इसलिए, अलग-अलग कॉन्टेक्स्ट के हिसाब से अलग-अलग टारगेट कैमरा इस्तेमाल किया जाएगा.

ध्यान रखें कि कैमरे और स्मार्ट ग्लास को ऐक्सेस करने की अनुमति अलग-अलग होती है.

फ़ोन और स्मार्ट ग्लास की अनुमतियां अलग-अलग होती हैं. इसलिए, आपको स्मार्ट ग्लास की अनुमति के लिए अलग से अनुरोध करना होगा.

दूसरा विकल्प, Projected Activity का इस्तेमाल करना है. यह भी होस्ट Android डिवाइसों पर चलता है. हालांकि, आपका यूज़र इंटरफ़ेस (यूआई) स्मार्ट ग्लास पर दिखता है.

यहां नियम बदल जाता है.

अगर स्टैंडर्ड कॉन्टेक्स्ट का इस्तेमाल किया जा रहा है, तो आपको स्मार्ट ग्लास के कैमरे का ऐक्सेस मिलेगा.

अगर आपको फ़ोन के कैमरे को ऐक्सेस करना है, तो आपको HostContext का इस्तेमाल करना होगा.

चलिए, कोड देखते हैं और जानते हैं कि स्मार्ट ग्लास के कैमरे से फ़ोटो कैसे कैप्चर की जा सकती है.

// In a coroutine
val imageCapture = ImageCapture.Builder().build()

ProjectedContext.isProjectedDeviceConnected(activity, coroutineContext)
    .collectLatest { isConnected ->
        if (isConnected) {
            val projectedContext = ProjectedContext.createProjectedDeviceContext(activity)
            val cameraConfig = CameraXConfig.Builder.fromConfig(Camera2Config.defaultConfig())
                .setRepeatingStreamForced(false)
                .build()
            val cameraProvider = LifecycleCameraProvider.createInstance(projectedContext, cameraConfig)
            cameraProvider.bindToLifecycle(activity, DEFAULT_BACK_CAMERA, imageCapture)
        }
    }
// Shutter button clicked
imageCapture.takePicture(...)

सबसे पहले, isProjectedDeviceConnected को चालू करके देखें कि स्मार्ट ग्लास कनेक्ट हैं या नहीं.

इसके बाद, projectedContext पाने के लिए createProjectedDeviceContext पर कॉल करें.

दूसरा, यहां CameraX को शुरू करने के लिए, ProcessCameraProvider के बजाय LifecycleCameraProvider का इस्तेमाल किया जाता है.

इसलिए, ProcessCameraProvider एक सिंगलटन है, जिसका कॉन्टेक्स्ट, शुरू होने के बाद नहीं बदला जा सकता.

इसलिए, LifecycleCameraProvider का इस्तेमाल करके, कॉन्टेक्स्ट को कभी भी बदला जा सकता है.

इसके बाद, आपको CameraX में अतिरिक्त रिपीटिंग स्ट्रीम को बंद करना होगा.

ऐसा इसलिए ज़रूरी है, क्योंकि आज के स्मार्ट ग्लास सिर्फ़ एक स्ट्रीम के साथ काम करते हैं.

फ़िलहाल, यह एपीआई सिर्फ़ हमारे लिए उपलब्ध है. हालांकि, हम इसे जल्द ही सार्वजनिक तौर पर उपलब्ध कराएंगे.

बस इतना ही!

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

ठीक है।

इसके बाद, आइए देखें कि CameraX आपको एक साथ काम करने वाली सुविधाओं का कॉम्बिनेशन ढूंढने और डिवाइस से सबसे बेहतर नतीजे पाने में कैसे मदद करता है.

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

हालांकि, डेवलपर के तौर पर हम जानते हैं कि इन सुविधाओं को एक साथ जोड़ना हमेशा आसान नहीं होता.

अलग-अलग सुविधाओं के काम करने की जांच करने से, यह गारंटी नहीं मिलती कि वे एक साथ काम करेंगी.

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

इस समस्या को हल करने के लिए, हमने Feature Group API लॉन्च किया है. यह Camera2 की कई सुविधाओं को एक साथ इस्तेमाल करने की कोशिश करने वाले फ़्रेमवर्क की मदद से काम करता है.

इसका इस्तेमाल दो तरीकों से किया जा सकता है: पहला, requiredFeatureGroup का इस्तेमाल करके, सुविधाओं के कॉम्बिनेशन की जांच करें और उसे चालू करें. ऐसा तब करें, जब यह सुविधा काम करती हो.

दूसरा, preferredFeatureGroup की मदद से यह तय किया जा सकता है कि आपको कौनसी सुविधा पहले चाहिए. इसके बाद, CameraX आपके लिए सबसे सही कॉम्बिनेशन चुनता है.

यहां इसका उदाहरण दिया गया है.

दाईं ओर, बाईं ओर, माफ़ करें, कुछ भी चालू नहीं है. बस एक सामान्य फ़ोन, सामान्य रिकॉर्डिंग.

बाईं ओर, हमने एचडीआर, 60 FPS, और झलक को स्टैबलाइज़ करने की सुविधा को एक साथ चालू किया है.

साथ ही, आपको वीडियो की क्वालिटी में काफ़ी सुधार दिखेगा. वीडियो ज़्यादा ब्राइट, स्मूद, और शेक-फ़्री दिखेगा.

चलिए, कोड देखते हैं.

cameraProvider.bindToLifecycle(
    lifecycleOwner,
    cameraSelector,
    SessionConfig(
        useCases = listOf(preview, videoCapture),
        // HDR_HLG10 > FPS_60 > Preview Stabilization.
        preferredFeatureGroup =
           listOf(HDR_HLG10, FPS_60, PREVIEW_STABILIZATION),
    )
)

इसलिए, हम यहां preferredFeatureGroup का इस्तेमाल करके, अपनी सुविधाओं की प्राथमिकता सूची उपलब्ध कराते हैं. इसमें एचडीआर, 60 एफ़पीएस, और झलक को स्टेबलाइज़ करने की सुविधा शामिल है.

इसके बाद, CameraX इस कॉम्बिनेशन की जांच करेगा और डिवाइस पर काम करने वाले सबसे अच्छे कॉम्बिनेशन को चुनेगा.

CameraX 1.6 और इसके बाद के वर्शन में, हम Feature Group API में 4K रिकॉर्डिंग और वीडियो स्टेबलाइज़ेशन की सुविधा जोड़ रहे हैं.

// CameraX 1.6+ supports:
// 4K, video stabilization & Effect
val sessionConfig = SessionConfig(
   useCases = listOf(preview, videoCapture),
   requiredFeatureGroup =
     setOf(UHD_RECORDING, VIDEO_STABILIZATION),
   effects = listOf(overlayEffect)
)

कई प्रीमियम डिवाइसों में, 4K और वीडियो स्टेबलाइज़ेशन की सुविधा को एक साथ इस्तेमाल किया जा सकता है.

अब Feature Group API की मदद से, उन्हें एक साथ चालू किया जा सकता है.

इसके अलावा, अब आपके पास Feature Group API की मदद से, रीयल-टाइम में इफ़ेक्ट लागू करने की सुविधा है. पहले ऐसा नहीं किया जा सकता था.

चलिए, अब बात करते हैं कि CameraX में अच्छी क्वालिटी की इमेज कैसे कैप्चर की जा सकती हैं.

CameraX अब DNG RAW फ़ॉर्मैट में फ़ोटो कैप्चर करने की सुविधा देता है.

इससे आपको सीधे कैमरे के सेंसर से, RAW फ़ॉर्मैट में इमेज मिलती है. यह इमेज, अनप्रोसेस्ड और अनकंप्रेस्ड होती है. इससे आपको प्रोफ़ेशनल एडिटिंग करने में मदद मिलती है.

इसके बाद, हमने नाइट मोड एक्सटेंशन को बेहतर बनाया है.

इस एक्सटेंशन की मदद से, कम रोशनी में भी फ़्लैश का इस्तेमाल किए बिना, साफ़ और अच्छी क्वालिटी की फ़ोटो ली जा सकती हैं.

साथ ही, हमने एक नया नाइट मोड इंडिकेटर एपीआई लॉन्च किया है.

यह मॉनिटर करेगा कि आस-पास कब अंधेरा है और नाइट मोड के लिए सही समय है. इसका इस्तेमाल, नाइट मोड इंडिकेटर दिखाने के लिए किया जा सकता है.

साथ ही, CameraX एक्सटेंशन में अब अल्ट्रा एचडीआर की सुविधा उपलब्ध है.

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

यहां सामान्य, नाइट, और अल्ट्रा एचडीआर वाले नाइट मोड के बीच का अंतर देखा जा सकता है.

चलिए, देखते हैं कि इसे कैसे लागू किया जाए.

val cameraInfo = cameraProvider.getCameraInfo(cameraSelector,
        ExtensionSessionConfig(ExtensionMode.NIGHT, extensionsManager))

val imageCapabilities = ImageCapture.getImageCaptureCapabilities(cameraInfo)

val imageCapture = ImageCapture.Builder().apply {
       if (imageCapabilities.supportedOutputFormats
                .contains(OUTPUT_FORMAT_JPEG_ULTRA_HDR)) {
           setOutputFormat(OUTPUT_FORMAT_JPEG_ULTRA_HDR)
       }
     }.build()

val extensionSessionConfig = ExtensionSessionConfig(
    ExtensionMode.NIGHT, extensionsManager, preview, imageCapture
)

cameraProvider.bindToLifecycle(...,  extensionSessionConfig)

सबसे पहले, नाइट मोड के लिए ExtensionSessionConfig बनाएं. इसके बाद, CameraInfo इंस्टेंस पाने के लिए इसका इस्तेमाल करें.

इसके बाद, इमेज कैप्चर करने की सुविधा पाने के लिए, CameraInfo का इस्तेमाल करें. इसके बाद, क्वेरी करें कि अल्ट्रा एचडीआर की सुविधा काम करती है या नहीं.

इसके बाद, आउटपुट फ़ॉर्मैट को अल्ट्रा एचडीआर पर सेट करें.

आखिर में, इस्तेमाल के उदाहरणों के साथ ExtensionSessionConfig को फिर से बनाएं और लाइफ़साइकल से बाइंड करें.

अब आप अल्ट्रा एचडीआर फ़ोटो के साथ नाइट मोड में फ़ोटो कैप्चर करने के लिए तैयार हैं.

हम CameraX में मोशन फ़ोटो की सुविधा भी उपलब्ध करा रहे हैं.

मोशन फ़ोटो में, फ़ोटो के आस-पास की आवाज़ और हलचल को कैप्चर किया जाता है. इससे सिर्फ़ एक इमेज नहीं, बल्कि उस पल को सेव किया जाता है.

हमने इस फ़ॉर्मैट को अलग-अलग फ़ोन और Android डिवाइसों के लिए स्टैंडर्ड बना दिया है. इससे मोशन फ़ोटो को आसानी से सपोर्ट किया जा सकता है.

मोशन फ़ोटो की सुविधा, साल 2027 की पहली तिमाही में CameraX पर उपलब्ध होगी.

यह सुविधा उपलब्ध होने के बाद, ImageCapture.Builder में जाकर मोशन फ़ोटो मोड सेट करें. इसके बाद, मोशन फ़ोटो कैप्चर की जा सकती हैं.

val imageCapture = ImageCapture.Builder()
        .setMotionPhotoMode(
             ImageCapture.MOTION_PHOTO_MODE_ON,
             customConfig
         )
        .build()

cameraProvider.bindToLifecycle(.. imageCapture)
imageCapture.takePicture(...)

इसके बाद, आइए जानते हैं कि CameraX की मदद से, हाई स्पीड वीडियो रिकॉर्डिंग की सुविधा कैसे चालू की जाती है.

तेज़ी से हो रही गतिविधि को साफ़ तौर पर रिकॉर्ड करना, आधुनिक कैमरा ऐप्लिकेशन की एक ज़रूरी सुविधा है.

यह सुविधा, खेल-कूद जैसे तेज़ी से होने वाले इवेंट के लिए खास तौर पर मददगार है.

इसके लिए, 120 या 240 एफ़पीएस पर हाई-स्पीड कैप्चर का इस्तेमाल किया जाता है.

इसे इस्तेमाल करने के दो तरीके हैं.

सबसे पहले, वीडियो को उसी फ़्रेम रेट पर एन्कोड करें. इसके बाद, आपको हाई-फ़्रेम-रेट वाला वीडियो मिलेगा.

दूसरा विकल्प यह है कि इसे 30 एफ़पीएस पर एन्कोड करके, स्लो-मोशन वीडियो बनाया जाए.

उदाहरण के लिए, 120 एफ़पीएस पर रिकॉर्ड किए गए एक सेकंड के वीडियो को 30 एफ़पीएस पर चलाने में चार सेकंड लगते हैं.

इसलिए, इस तरह से वीडियो बनाने पर स्लो-मोशन इफ़ेक्ट मिलता है.

तेज़ रफ़्तार से रिकॉर्डिंग करने के लिए, अपने videoCapture के साथ HighSpeedVideoSessionConfig बनाएं.

val recorder = Recorder.Builder().build()
val videoCapture = VideoCapture.withOutput(recorder)

val frameRateRange = cameraInfo.getSupportedFrameRateRanges(
       HighSpeedVideoSessionConfig(videoCapture, preview)).first()

val sessionConfig = HighSpeedVideoSessionConfig(
    videoCapture,
    preview,
    frameRateRange = frameRateRange,
    isSlowMotionEnabled = true
)

cameraProvider.bindToLifecycle(
     lifecycleOwner, cameraSelector, sessionConfig)

// Start recording slow motion videos.
val recording = recorder.prepareRecording(context, outputOption)
      .start(executor, {})

इसके बाद, स्लो-मोशन वीडियो बनाने के लिए, isSlowMotionEnabled को 'सही' पर सेट करें, ताकि इसे 30 एफ़पीएस पर एन्कोड किया जा सके. इसके अलावा, हाई स्पीड फ़्रेम रेट वाला वीडियो बनाने के लिए, इसे 'गलत' पर सेट करें.

स्लो मोशन मोड चालू होने पर, Google Photos अपने-आप इसकी पहचान कर लेता है. साथ ही, थंबनेल पर स्लो मोशन बैज जोड़ देता है.

आइए, देखते हैं कि यह Google Photos में कैसे काम करता है.

यहां स्लो मोशन इफ़ेक्ट की वजह से, बिल्ली का वीडियो काफ़ी ड्रमैटिक लग रहा है.

मेरी बिल्ली कभी नहीं चाहती कि मैं उसे छूऊं.

माफ़ करें.

आखिर में, आइए हमारे Concurrent Camera API में कुछ सुधार देखते हैं.

कॉन्करेंट एपीआई की मदद से, आपका ऐप्लिकेशन सामने और पीछे वाले कैमरे से एक साथ स्ट्रीम कर सकता है.

इस साल, हमने Concurrent Camera API में कुछ सुधार किए हैं.

लाइफ़साइकल से बाइंड करने और कैमरा खोलने के बाद, कैमरा कंपोज़िशन को डाइनैमिक तौर पर अपडेट किया जा सकता है.

इसमें पोज़िशन, साइज़, और रेंडरिंग ऑर्डर बदलना शामिल है.

इसमें राउंडेड कॉर्नर, बॉर्डर की चौड़ाई, और बॉर्डर का रंग जैसी स्टाइल भी जोड़ी जा सकती हैं.

इसे करने का तरीका यहां बताया गया है: राउंडिंग कॉर्नर, बॉर्डर की चौड़ाई, और रंग जैसी स्टाइलिंग को कॉन्फ़िगर करने के लिए, बस CompositionSettings का इस्तेमाल करें. साथ ही, रेंडरिंग के क्रम को अडजस्ट करने के लिए, setZOrder का इस्तेमाल करें.

val concurrentCamera =
        cameraProvider.bindToLifecycle(list(config1, config2))
// CameraX 1.7 features: rounded corner, border width & color
val pipSettings = CompositionSettings.Builder()
    .setOffset(0.2f, 0.2f)
    .setScale(0.35f, 0.35f)
    .setRoundedCornerRatio(0.15f)
    .setBorderWidthRatio(0.02f)
    .setBorderColor(Color.WHITE)
    .setZOrder(1)
    .build()
// CameraX 1.7 features: dynamical composition update
concurrentCamera.setCompositionSettings(
listOf(mainSettings, pipSettings))

इसके बाद, कंपोज़िशन को डाइनैमिक तौर पर अपडेट करने के लिए, चालू कॉन्करेंट कैमरे पर setCompositionSettings को कॉल करें.

बस इतना ही!

कंपोज़िशन को डाइनैमिक तौर पर अपडेट किया जा सकता है.

ठीक है।

अब हमने सभी सुविधाओं के बारे में जान लिया है.

हमारे पास यहां एक अहम जानकारी है. इसलिए, हमारा सुझाव है कि आप CameraX 1.6 और इसके बाद के वर्शन पर अपग्रेड करें.

इससे नए फ़ॉर्मैट, Eclipsa Video के साथ काम करने वाले आने वाले डिवाइसों पर क्रैश होने से बचा जा सकता है. साथ ही, यह पक्का किया जा सकता है कि आपका CameraX एक्सटेंशन, आने वाले समय में Pixel के अपडेट पर काम करता रहे.

इसी के साथ हमारा पहला सेशन खत्म हुआ.

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

स्कॉट, CameraX की सुविधाओं के बारे में बताने के लिए धन्यवाद.

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

उपयोगकर्ता के डिवाइस पर मौजूद मशीन लर्निंग की सुविधा, कैमरे के इस्तेमाल के कई उदाहरणों में मदद करती है. मुख्य रूप से, यह दो क्षेत्रों में काम करती है.

पहला है, प्री-कैप्चर.

यहां ऑब्जेक्ट का पता लगाने जैसी चीज़ें करने के लिए, रीयल टाइम में कैमरे की झलक का विश्लेषण किया जा सकता है. इसके अलावा, झलक को बेहतर भी बनाया जा सकता है.

दूसरा है, फ़ोटो लेने के बाद.

इमेज कैप्चर करने के बाद, उसकी क्वालिटी को बेहतर बनाया जा सकता है या इमेज के लिए ब्यौरा जनरेट करने जैसे काम किए जा सकते हैं.

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

डिवाइस पर मौजूद पहली एमएल लाइब्रेरी, जिसके बारे में हम बात करने जा रहे हैं वह ML Kit है.

ML Kit को मुख्य रूप से, विज़न और नैचुरल लैंग्वेज डोमेन में आने वाली सामान्य समस्याओं को हल करने के लिए बनाया गया था. जैसे, टेक्स्ट की पहचान करना, चेहरे की पहचान करना, और भाषा का अनुवाद करना.

पिछले साल, हमने ML Kit को लॉन्च किया था.

यहां ML Kit Vision API के कुछ उदाहरण दिए गए हैं. जैसे, फ़ेस मेश डिटेक्शन, सब्जेक्ट सेगमेंटेशन, और रीयल-टाइम में ऑब्जेक्ट का पता लगाने की सुविधा.

हां.

पिछले साल हमने GenAI API लॉन्च किए थे.

ये एपीआई, Gemini Nano की मदद से काम करते हैं. इनकी मदद से, टेक्स्ट की खास जानकारी पाने, इमेज की जानकारी पाने, और कई अन्य सुविधाएं मिलती हैं.

यहां Prompt API का इस्तेमाल करके, इमेज की जानकारी देने का एक उदाहरण दिया गया है.

हम टेक्स्ट प्रॉम्प्ट के साथ इमेज बिटमैप को मॉडल को पास करते हैं. इसके बाद, नतीजे के ब्यौरे में लिखा होता है कि कैक्टस जैसे डिज़ाइन वाला एक छोटा हरा Android रोबोट, काली सतह पर बैठा है.

यह सब आपके डिवाइस पर होता है.

यह काफ़ी लाजवाब है, है न?

Adobe Photoshop, अपने ऐप्लिकेशन में उपयोगकर्ता अनुभव को बेहतर बनाने के लिए, Prompt API का इस्तेमाल कर रहा है.

ऐसेट में बदलाव करते समय, उपयोगकर्ताओं को अक्सर Photoshop ऐप्लिकेशन में कई लेयर मैनेज करनी पड़ती हैं.

Prompt API का इस्तेमाल करके, अब ऐप्लिकेशन उन लेयर का नाम अपने-आप बदल सकता है जो व्यवस्थित नहीं हैं.

यह ऐप्लिकेशन, इमेज के लिए कैप्शन और हैशटैग जनरेट करने के लिए भी Prompt API का इस्तेमाल करता है. इससे सोशल मीडिया पर इमेज शेयर करना काफ़ी आसान हो जाता है.

आइए, Prompt API का इस्तेमाल करके इमेज की जानकारी देने वाला कोड देखें.

// 1. Initialize the on-device GenerativeModel client
val generativeModel = Generation.getClient()

// 2. Check whether Gemini Nano is available on the device
val status = generativeModel.checkStatus()
when (status) {
    FeatureStatus.UNAVAILABLE -> {}
    FeatureStatus.DOWNLOADABLE -> {}
    FeatureStatus.DOWNLOADING -> {}
    FeatureStatus.AVAILABLE -> {}
}

सबसे पहले, आपको generativeModel क्लाइंट ऑब्जेक्ट की ज़रूरत होगी. इसके बाद, देखें कि आपके डिवाइस पर Gemini Nano उपलब्ध है या उसे डाउनलोड किया जा सकता है या नहीं.

इसके बाद, अपनी इमेज और टेक्स्ट प्रॉम्प्ट को जोड़कर कॉन्टेंट का अनुरोध जनरेट करें. आखिर में, Gemini Nano पर अनुमान लगाने और इमेज का ब्यौरा पाने के लिए, इस अनुरोध को generateContent कॉल में भेजें.

// 3. Build a multimodal request with the image and text prompt
val request = generateContentRequest(
    ImagePart(bitmap),
    TextPart("Describe this image in detail.")
) {}

// 4. Run inference on-device and get the description
val response = generativeModel.generateContent(request)
val description = response.candidates.first().text

हां, हमारे पास डिवाइस पर मौजूद एमएल लाइब्रेरी के तौर पर MediaPipe भी है.

MediaPipe, आपके ऐप्लिकेशन के लिए मशीन लर्निंग के कई तरह के समाधान उपलब्ध कराता है.

MediaPipe की वेबसाइट पर जाकर, चेहरे की पहचान, ऑब्जेक्ट का पता लगाने की सुविधा, इमेज सेगमेंटेशन वगैरह जैसे अलग-अलग सैंपल आज़माए जा सकते हैं.

इस्तेमाल के ये सभी उदाहरण, ML Kit से काफ़ी मिलते-जुलते हैं. इसलिए, आपको किस लाइब्रेरी का इस्तेमाल करना चाहिए?

MediaPipe और ML Kit, एक जैसी समस्याओं को हल करते हैं. हालांकि, दोनों में कुछ खास अंतर हैं.

पहला है, प्लैटफ़ॉर्म से जुड़ी सहायता.

MediaPipe, Android, iOS, वेब, और Python पर काम करता है. वहीं, ML Kit सिर्फ़ Android और iOS पर काम करता है.

इसके अलावा, MediaPipe में मॉडल को पसंद के मुताबिक बनाने की सुविधा मिलती है. वहीं, ML Kit में इस्तेमाल के लिए तैयार एपीआई मिलते हैं.

आखिर में, MediaPipe एक ओपन सोर्स है, जबकि ML Kit एक Google SDK टूल है.

यहां MediaPipe Vision API का इस्तेमाल करके, हाथ के जेस्चर की पहचान करने का एक उदाहरण दिया गया है.

यह एपीआई, कैमरे से मिले इनपुट के आधार पर, रीयल टाइम में हाथ के जेस्चर का पता लगाता है.

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

चलिए, कोड देखते हैं.

इसलिए, सबसे पहले आपको GestureRecognizerOptions ऑब्जेक्ट बनाना होगा. इसके लिए, मॉडल पाथ, लाइव स्ट्रीमिंग मोड, और रिज़ल्ट लिसनर की जानकारी दें.

// 1. Build GestureRecognizerOptions
val options = GestureRecognizerOptions.builder().setBaseOptions(
    BaseOptions.builder().setModelAssetPath(MP_RECOGNIZER_TASK).build())
    .setRunningMode(RunningMode.LIVE_STREAM)
    .setResultListener { result, image -> /* Handle detected gesture */ }
    .build()

// 2. Create the GestureRecognizer
val gestureRecognizer = GestureRecognizer.createFromOptions(context, options)

// 3. Convert CameraX ImageProxy to MediaPipe MPImage
val bitmap = rotateBitmap(imageProxy.toBitmap(),
imageProxy.imageInfo.rotationDegrees)
val mpImage = BitmapImageBuilder(bitmap).build()

// 4. Run gesture recognition on the image
gestureRecognizer.recognizeAsync(mpImage, frameTime)

इसके बाद, विकल्पों में से जेस्चर पहचानने वाला ऑब्जेक्ट बनाएं.

इसके बाद, CameraX ImageProxy को बिटमैप में बदलें. फिर बिटमैप का इस्तेमाल करके, MediaPipe mpImage ऑब्जेक्ट जनरेट करें.

आखिर में, आपको रीयल-टाइम में जेस्चर का पता लगाने के लिए, MediaPipe mpImage ऑब्जेक्ट को recognizeAsync कॉल में पास करना होगा.

इसके बाद, हमारे पास उपयोगकर्ता के डिवाइस पर मौजूद इमेज और वीडियो को बेहतर बनाने की सुविधा है. इसे Google Play services API के ज़रिए इस्तेमाल किया जा सकता है.

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

यहां एक इमेज का उदाहरण दिया गया है, जिसे इस मॉडल का इस्तेमाल करके टोन मैप और अपस्केल किया गया है.

बेहतर बनाई गई इमेज में, आसमान और समुद्र के रंग ज़्यादा गहरे दिखते हैं. साथ ही, इमेज की शार्पनेस भी बेहतर दिखती है.

आइए, इमेज को बेहतर बनाने की सुविधा के लिए कोड देखें.

// Step 1: Verify device support & install module
val enhancementClient = Enhancement.getClient(context)

suspend fun prepare(): Boolean {
    if (!enhancementClient.isDeviceSupported().await()) return false
    if (!enhancementClient.isModuleInstalled().await()) {
        check(enhancementClient.installModule().await()) {
            "Enhancement module install failed"
        }
    }
    return true
}

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

इसके बाद, बिटमैप और अपनी पसंद के हिसाब से बेहतर बनाने की सुविधा को तय करके, EnhancementOptions ऑब्जेक्ट बनाएं.

// Step 2: Select Enhancement options & create session
val options = EnhancementOptions(
    width = bitmap.width,
    height = bitmap.height,
    enhancementMode = EnhancementMode.BITMAP,
    isTonemappingEnabled = true,
    isDeblurAndDenoisePhotoEnabled = true,
    isDeblurAndDenoiseVideoEnabled = false,
    isUpscalePhotoEnabled = false,
    isUpscaleVideoEnabled = false
)

val enhancementSession = enhancementClient
    .createSessionAsync(options, enhancementExecutor)

इसके बाद, Google Play services API की मदद से क्लाइंट सेशन बनाएं. फिर, नतीजे के तौर पर मिलने वाले बिट मैप को मैनेज करने के लिए, कॉलबैक तय करें. आखिर में, बिट मैप और इमेज को बेहतर बनाने के विकल्पों के साथ प्रोसेस फ़ंक्शन को कॉल करें.

// Step 3: Process Enhancement
val enhancedBitmap = suspendCancellableCoroutine { continuation ->
    val enhancementCallback = object : EnhancementCallback {
        override fun onBitmapProcessed(result: Bitmap) {
            if (continuation.isActive) continuation.resume(result)
        }
        override fun onError(statusCode: Int) {
            if (continuation.isActive) {
                continuation.resumeWithException(
                    Exception("Bitmap processing failed: $statusCode")
                )
            }
        }
        override fun onSurfaceProcessed(timestamp: Long) {}
    }

    enhancementSession.process(bitmap, options, enhancementCallback)
}

हमने हाल ही में, वीडियो को बेहतर बनाने वाले एपीआई को Jetpack Media3 में इंटिग्रेट किया है.

इमेज और वीडियो को बेहतर बनाने वाले एपीआई के बारे में ज़्यादा जानने के लिए, मीडिया टॉक देखें.

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

कम रोशनी में फ़ोटो खींचना, स्मार्टफ़ोन इस्तेमाल करने वाले लोगों के लिए एक आम समस्या है.

ऐसे उपयोगकर्ताओं के बारे में सोचें जो कम रोशनी वाली जगहों पर फ़ोटो खींच रहे हैं या वीडियो कॉल कर रहे हैं.

कम रोशनी में बेहतर फ़ोटो लेने की सुविधा, रीयल-टाइम में कैमरे की झलक को ज़्यादा चमकदार बनाकर इस समस्या को हल करती है.

कम रोशनी में बेहतर फ़ोटो खींचने की सुविधा के दो वैरिएंट हैं: हार्डवेयर और सॉफ़्टवेयर.

हार्डवेयर का वर्शन, ओईएम हार्डवेयर का इस्तेमाल करके कम रोशनी वाले फ़्रेम को बेहतर बनाता है. इसके लिए, मशीन लर्निंग का इस्तेमाल नहीं किया जाता.

वहीं, सॉफ़्टवेयर का वर्शन फ़्रेम को बेहतर बनाने के लिए, उपयोगकर्ता के डिवाइस पर मौजूद एमएल मॉडल का इस्तेमाल करता है.

आइए, फटाफट यह देखते हैं कि CameraX को सॉफ़्टवेयर Low Light Boost के साथ कैसे इंटिग्रेट किया जा सकता है. इसे Google Low Light Boost भी कहा जाता है.

Google Low Light Boost के लिए, दो मुख्य प्लैटफ़ॉर्म की ज़रूरत होती है: पहला, आपको रॉ कैमरा फ़्रेम के लिए इनपुट प्लैटफ़ॉर्म की ज़रूरत होती है. दूसरा, बेहतर आउटपुट फ़्रेम के लिए आउटपुट टारगेट प्लैटफ़ॉर्म की ज़रूरत होती है.

CameraX के साथ इंटिग्रेट करने के लिए, Google की कम रोशनी में बेहतर फ़ोटो लेने की सुविधा वाली पाइपलाइन को CameraEffect में रैप करें.

CameraX, आपके लिए सरफ़ेस लाइफ़साइकल और रूटिंग को अपने-आप मैनेज करता है.

आखिर में, हम साल 2026 की चौथी तिमाही में, CameraX में कम रोशनी में बेहतर फ़ोटो खींचने वाला इफ़ेक्ट लॉन्च कर रहे हैं.

// Integrates SW Low Light Boost
val lowLightBoostEffect =
    LowLightBoostEffect(
        CameraEffect.PREVIEW or
        CameraEffect.VIDEO_CAPTURE or
        CameraEffect.IMAGE_CAPTURE
    )

val sessionConfig = SessionConfig(
    useCases = listOf(preview, imageCapture),
    effects = lowLightBoostEffect
)

cameraProvider.bindToLifecycle(.. sessionConfig)

इससे, Low Light Boost ऑब्जेक्ट बनाया जा सकता है और उसे सेशन कॉन्फ़िगरेशन में जोड़ा जा सकता है. इसके बाद, सेशन कॉन्फ़िगरेशन को कैमरे की लाइफ़साइकल से बाइंड किया जा सकता है. यह सुविधा, सिर्फ़ उन डिवाइसों पर काम करती है जिन पर यह सुविधा उपलब्ध है.

इसी के साथ, दोनों सेक्शन खत्म होते हैं.

आइए, आज हमने जो कुछ सीखा है, उस पर एक नज़र डालते हैं.

आज हमने इस बारे में बात की कि CameraX और उपयोगकर्ता के डिवाइस पर मशीन लर्निंग की मदद से, अलग-अलग डिवाइसों पर कैमरे के इस्तेमाल को कैसे बेहतर बनाया जा सकता है.

CameraXViewfinder की मदद से, कैमरे की झलक को अलग-अलग फ़ॉर्म फ़ैक्टर के हिसाब से अडजस्ट किया जा सकता है.

इसके बाद, हमने देखा कि CameraX की मदद से, एक्सआर डिवाइसों पर भी फ़ोटो खींची जा सकती हैं.

इसके बाद, Feature Group API की मदद से, हार्डवेयर की सुविधाओं का सबसे सही कॉम्बिनेशन ढूंढा जा सकता है.

हमने इमेज कैप्चर करने की सुविधा में किए गए अपग्रेड भी देखे. साथ ही, स्लो मोशन वीडियो के लिए हाई-स्पीड वीडियो रिकॉर्डिंग के बारे में जाना.

आखिर में, हमने कॉन्करेंट कैमरा की झलक को डाइनैमिक तरीके से बेहतर बनाने का तरीका सीखा.

इसके बाद, हमने डिवाइस पर मौजूद मशीन लर्निंग के कुछ समाधानों के बारे में जाना. जैसे, ML Kit और MediaPipe. इनकी मदद से, इंटेलिजेंट विज़न के अनुभव बनाए जा सकते हैं.

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

जैसा कि पहले बताया गया है, हम Camera1 को बंद करने की योजना बना रहे हैं. इसलिए, हमारा सुझाव है कि आप CameraX पर माइग्रेट करें.

इस माइग्रेशन में मदद करने के लिए, हमने हाल ही में CameraX स्किल लॉन्च की है.

आपकी मदद के लिए, हमारे पास माइग्रेट करने से जुड़ी गाइड और कैमरा सैंपल का डेटाबेस भी है.

आज हमने जिन सुविधाओं के बारे में बात की है उनके बारे में ज़्यादा जानने के लिए, इस लिंक पर जाएं.

इसमें दस्तावेज़, ब्लॉग, और माइग्रेशन के संसाधनों के लिंक एक ही जगह पर मौजूद होते हैं.

मैं एक सेकंड के लिए रुकूंगा.

ठीक है।

आप सभी का धन्यवाद.

इसी के साथ हमारी बातचीत खत्म होती है.