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

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

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

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

बेहतरीन वीडियो रिकॉर्डिंग: हाई-स्पीड और सुविधाओं का कॉम्बिनेशन

CameraX 1.5 में वीडियो से जुड़ी सुविधाओं को बेहतर बनाया गया है. इससे, वीडियो रिकॉर्डिंग को ज़्यादा क्रिएटिव और बेहतर तरीके से किया जा सकता है.

स्लो मोशन और ज़्यादा फ़्रेम रेट वाला वीडियो

स्लो-मोशन वीडियो बनाने की सुविधा अब उपलब्ध है. यह हमारी सबसे ज़्यादा इंतज़ार की जाने वाली सुविधाओं में से एक है. अब ज़्यादा फ़्रेम रेट (जैसे, 120 या 240 एफ़पीएस) पर वीडियो कैप्चर किया जा सकता है. साथ ही, इसे सीधे तौर पर स्लो-मोशन वीडियो में बदला जा सकता है. इसके अलावा, ज़्यादा फ़्रेम रेट पर रिकॉर्ड करके भी बेहतरीन वीडियो बनाया जा सकता है.

अगर आपको VideoCapture एपीआई के बारे में पता है, तो इसे लागू करना आसान है.

1. देखें कि डिवाइस में हाई-स्पीड वीडियो रिकॉर्डिंग की सुविधा है या नहीं: यह पता लगाने के लिए कि डिवाइस में यह सुविधा है या नहीं, Recorder.getHighSpeedVideoCapabilities() तरीके का इस्तेमाल करें.

val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

if (highSpeedCapabilities == null) {
    // This camera device does not support high-speed video.
    return
}

2. इस्तेमाल के उदाहरण को कॉन्फ़िगर और बाइंड करें: HighSpeedVideoSessionConfig बनाने के लिए, दिखाए गए videoCapabilities का इस्तेमाल करें. इसमें वीडियो की क्वालिटी से जुड़ी जानकारी होती है. इसके बाद, आपको cameraInfo.getSupportedFrameRateRanges() के ज़रिए, फ़्रेम रेट की उन रेंज के बारे में क्वेरी करनी होगी जिनका इस्तेमाल किया जा सकता है. साथ ही, आपको अपनी पसंद के मुताबिक रेंज सेट करनी होगी. स्लो मोशन में वीडियो रिकॉर्ड करने के लिए, setSlowMotionEnabled(true) को लागू करें. ऐसा न करने पर, हाई-फ़्रेम-रेट वाले वीडियो रिकॉर्ड किए जाएंगे. आखिरी चरण में, वीडियो रिकॉर्डिंग शुरू करने के लिए सामान्य Recorder.prepareRecording().start() का इस्तेमाल करें.

val preview = Preview.Builder().build()
val quality = highSpeedCapabilities
        .getSupportedQualities(DynamicRange.SDR).first()

val recorder = Recorder.Builder()
      .setQualitySelector(QualitySelector.from(quality)))
      .build()

val videoCapture = VideoCapture.withOutput(recorder)

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

val sessionConfig = HighSpeedVideoSessionConfig(
    videoCapture, 
    preview, 
    frameRateRange = frameRateRange, 
    // Set true for slow-motion playback, or false for high-frame-rate
    isSlowMotionEnabled = true
)

cameraProvider.bindToLifecycle(
     lifecycleOwner, cameraSelector, sessionConfig)

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

यह किन सुविधाओं के साथ काम करती है और इसकी सीमाएं

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

ज़्यादा जानकारी के लिए, ब्लॉग पोस्ट देखें.

भरोसे के साथ सुविधाओं को जोड़ें: Feature Group API

CameraX 1.5 में Feature Group API उपलब्ध कराया गया है. इससे यह अनुमान लगाने की ज़रूरत नहीं पड़ती कि कोई सुविधा काम करेगी या नहीं. Android 15 की सुविधा के कॉम्बिनेशन के बारे में क्वेरी करने वाले एपीआई के आधार पर, अब एक साथ कई सुविधाएं चालू की जा सकती हैं. इससे कैमरे का इस्तेमाल बिना किसी रुकावट के किया जा सकेगा. फ़िलहाल, फ़ीचर ग्रुप में ये सुविधाएं काम करती हैं: एचडीआर (एचएलजी), 60 फ़्रेम प्रति सेकंड, झलक की स्थिरता, और अल्ट्रा एचडीआर. उदाहरण के लिए, Pixel 10 और Galaxy S25 सीरीज़ पर, एचडीआर, 60 फ़्रेम प्रति सेकंड, और झलक की स्टेबलाइज़ेशन सुविधा को एक साथ चालू किया जा सकता है. आने वाले समय में, इसमें 4K रिकॉर्डिंग और अल्ट्रा-वाइड ज़ूम जैसी सुविधाएं जोड़ी जाएंगी. 

Feature Group API की मदद से, दो ज़रूरी काम किए जा सकते हैं:

इस्तेमाल का पहला उदाहरण: सबसे अच्छी क्वालिटी को प्राथमिकता देना

अगर आपको सुविधाओं के सबसे अच्छे कॉम्बिनेशन का इस्तेमाल करके डेटा इकट्ठा करना है, तो प्राथमिकता के हिसाब से सूची दी जा सकती है. CameraX, इन सुविधाओं को क्रम से चालू करने की कोशिश करेगा. साथ ही, वह पहले ऐसे कॉम्बिनेशन को चुनेगा जिसे डिवाइस पूरी तरह से सपोर्ट करता है.

val sessionConfig = SessionConfig(
    useCases = listOf(preview, videoCapture),
    preferredFeatureGroup = listOf(
        GroupableFeature.HDR_HLG10,
        GroupableFeature.FPS_60,
        GroupableFeature.PREVIEW_STABILIZATION
    )
).apply {
    // (Optional) Get a callback with the enabled features to update your UI.
    setFeatureSelectionListener { selectedFeatures ->
        updateUiIndicators(selectedFeatures)
    }
}
processCameraProvider.bindToLifecycle(activity, cameraSelector, sessionConfig)

इस उदाहरण में, CameraX इन सुविधाओं को इस क्रम में चालू करने की कोशिश करता है:

1. HDR + 60 FPS + प्रीव्यू स्टेबलाइज़ेशन
2. एचडीआर + 60 FPS
3. एचडीआर + प्रीव्यू स्टेबलाइज़ेशन
4. एचडीआर
5. 60 FPS + प्रीव्यू स्टेबलाइज़ेशन
6. 60 एफ़पीएस
7. स्टेबलाइज़ेशन की झलक देखें
8. कोई नहीं

इस्तेमाल का दूसरा उदाहरण: उपयोगकर्ताओं के लिए सेटिंग का यूज़र इंटरफ़ेस (यूआई) बनाना

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

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

fun disableFeatureIfNotSuported(
   enabledFeatures: Set<GroupableFeature>,     
   featureToCheck:GroupableFeature
) {
 val sessionConfig = SessionConfig(
     useCases = useCases,
     requiredFeatureGroup = enabledFeatures + featureToCheck
 )
 val isSupported = cameraInfo.isFeatureGroupSupported(sessionConfig)

 if (!isSupported) {
     // disable the toggle for featureToCheck
 }
}

ज़्यादा जानकारी के लिए, कृपया सुविधा ग्रुप की ब्लॉग पोस्ट पढ़ें. 

वीडियो को बेहतर बनाने की अन्य सुविधाएं

• एक साथ कई कैमरों का इस्तेमाल करने की सुविधा: CameraX 1.5.1 की मदद से, अब नॉन-कंपोज़िशन मोड में हर SingleCameraConfig के लिए, Preview + ImageCapture + VideoCapture के इस्तेमाल के उदाहरणों को एक साथ बाइंड किया जा सकता है. इसके अलावा, कंपोज़िशन मोड (CompositionSettings के साथ इस्तेमाल के उदाहरण) में, अब CameraEffect सेट किया जा सकता है. यह CameraEffect, कंपोज़िशन के फ़ाइनल नतीजे पर लागू होता है.
• डाइनैमिक म्यूटिंग: अब PendingRecording.withAudioEnabled(boolean initialMuted) का इस्तेमाल करके, म्यूट मोड में रिकॉर्डिंग शुरू की जा सकती है. साथ ही, उपयोगकर्ता को Recording.mute(boolean muted) का इस्तेमाल करके, बाद में इसे अनम्यूट करने की अनुमति दी जा सकती है.
• स्टोरेज कम होने की समस्या को बेहतर तरीके से हैंडल करना: CameraX अब VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE गड़बड़ी को भरोसेमंद तरीके से भेजता है. इससे आपका ऐप्लिकेशन, स्टोरेज कम होने की स्थितियों को आसानी से हैंडल कर पाता है और उपयोगकर्ता को इसकी सूचना दे पाता है.
• कम रोशनी में बूस्ट करने की सुविधा: इस सुविधा को Pixel 10 सीरीज़ जैसे डिवाइसों पर इस्तेमाल किया जा सकता है. इसके लिए, CameraControl.enableLowLightBoostAsync को चालू करें. इससे, कम रोशनी वाली जगहों पर प्रीव्यू और वीडियो स्ट्रीम की रोशनी अपने-आप बढ़ जाएगी.

प्रोफ़ेशनल क्वालिटी में इमेज कैप्चर करना

CameraX 1.5 में, ImageCapture को बेहतर बनाया गया है. यह उन डेवलपर के लिए है जिन्हें सबसे अच्छी क्वालिटी और फ़्लेक्सिबिलिटी चाहिए.

DNG (RAW) फ़ॉर्मैट में फ़ोटो कैप्चर करके, क्रिएटिविटी को बढ़ावा दें

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

val capabilities = ImageCapture.getImageCaptureCapabilities(cameraInfo)
val imageCapture = ImageCapture.Builder().apply {
    if (capabilities.supportedOutputFormats
             .contains(OUTPUT_FORMAT_RAW_JPEG)) {
        // Capture both RAW and JPEG formats.
        setOutputFormat(OUTPUT_FORMAT_RAW_JPEG)
    }
}.build()
// ... bind imageCapture to lifecycle ...


// Provide separate output options for each format.
val outputOptionRaw = /* ... configure for image/x-adobe-dng ... */
val outputOptionJpeg = /* ... configure for image/jpeg ... */
imageCapture.takePicture(
    outputOptionRaw,
    outputOptionJpeg,
    executor,
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(results: OutputFileResults) {
            // This callback is invoked twice: once for the RAW file
            // and once for the JPEG file.
        }

        override fun onError(exception: ImageCaptureException) {}
    }
)

कैमरे के एक्सटेंशन के लिए अल्ट्रा एचडीआर

दोनों सुविधाओं का फ़ायदा पाएं: कैमरा एक्सटेंशन (जैसे कि नाइट मोड) की बेहतरीन कंप्यूटेशनल फ़ोटोग्राफ़ी के साथ-साथ, अल्ट्रा एचडीआर की शानदार रंग और डाइनैमिक रेंज. यह सुविधा अब हाल ही में लॉन्च हुए कई प्रीमियम Android फ़ोन पर काम करती है. जैसे, Pixel 9/10 सीरीज़ और Samsung S24/S25 सीरीज़.

// Support UltraHDR when Extension is enabled. 

val extensionsEnabledCameraSelector = extensionsManager
     .getExtensionEnabledCameraSelector(
        CameraSelector.DEFAULT_BACK_CAMERA, ExtensionMode.NIGHT)

val imageCapabilities = ImageCapture.getImageCaptureCapabilities(
               cameraProvider.getCameraInfo(extensionsEnabledCameraSelector)

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

       }

     }.build()

Core API और इस्तेमाल में आसानी से जुड़े सुधार

कॉन्फ़िगर करने का नया तरीका: SessionConfig

ऊपर दिए गए उदाहरणों में दिखाया गया है कि SessionConfig, CameraX 1.5 में एक नई सुविधा है. यह कॉन्फ़िगरेशन को एक जगह पर मैनेज करता है. साथ ही, एपीआई को दो मुख्य तरीकों से आसान बनाता है:

1. अब मैन्युअल unbind() कॉल नहीं करने होंगे: CameraX API, लाइफ़साइकल की जानकारी रखते हैं. गतिविधि या अन्य LifecycleOwner बंद होने पर, यह आपके इस्तेमाल के उदाहरणों को “अनबाइंड” कर देगा. हालांकि, इस्तेमाल के उदाहरणों को अपडेट करने या कैमरे बदलने के लिए, आपको फिर से बाइंड करने से पहले unbind() या unbindAll() को कॉल करना होगा. CameraX 1.5 में, नया SessionConfig बाइंड करने पर, CameraX आपके लिए सेशन को आसानी से अपडेट कर देता है. इससे, अनबाइंड कॉल करने की ज़रूरत नहीं पड़ती.
2. फ़्रेम रेट को कंट्रोल करने का तरीका: नए SessionConfig API में, फ़्रेम रेट को मैनेज करने का एक तरीका शामिल किया गया है. पिछली setTargetFrameRate में, सिर्फ़ एक सुझाव दिया जाता था. हालांकि, इस नए तरीके से यह गारंटी मिलती है कि कॉन्फ़िगरेशन पूरा होने के बाद, तय की गई फ़्रेम रेट रेंज लागू हो जाएगी. सटीक जानकारी पाने के लिए, आपको CameraInfo.getSupportedFrameRateRanges(SessionConfig) का इस्तेमाल करके, काम करने वाले फ़्रेम रेट के बारे में क्वेरी करनी होगी. पूरा SessionConfig पास करने पर, CameraX स्ट्रीम कॉन्फ़िगरेशन के आधार पर, काम करने वाली रेंज का सटीक पता लगा सकता है.

Camera-Compose अब स्टेबल हो गया है

हमें पता है कि आपको Jetpack Compose कितना पसंद है. इसलिए, हमें यह बताते हुए खुशी हो रही है कि camera-compose लाइब्रेरी का वर्शन 1.5.1 अब स्टेबल हो गया है! इस रिलीज़ में, CameraXViewfinder के इस्तेमाल से जुड़ी गंभीर गड़बड़ियों को ठीक किया गया है. ये गड़बड़ियां, moveableContentOf और Pager जैसी Compose सुविधाओं से जुड़ी हैं. साथ ही, इसमें झलक के स्ट्रेच होने की समस्या को भी ठीक किया गया है. हम आने वाले समय में, camera-compose में और सुविधाएं जोड़ते रहेंगे.

ImageAnalysis और CameraControl में सुधार

• टॉर्च की रोशनी को अडजस्ट करना: नए एपीआई की मदद से, डिवाइस की टॉर्च की रोशनी को बेहतर तरीके से कंट्रोल करें. CameraInfo.getMaxTorchStrengthLevel() का इस्तेमाल करके, टॉर्च की ज़्यादा से ज़्यादा इंटेंसिटी के बारे में क्वेरी की जा सकती है. इसके बाद, CameraControl.setTorchStrengthLevel() का इस्तेमाल करके, टॉर्च की इंटेंसिटी को अपनी पसंद के मुताबिक सेट किया जा सकता है.
• ImageAnalysis में NV21 फ़ॉर्मैट के लिए सहायता उपलब्ध है: अब ImageAnalysis से सीधे NV21 इमेज फ़ॉर्मैट का अनुरोध किया जा सकता है. इससे अन्य लाइब्रेरी और एपीआई के साथ इंटिग्रेट करना आसान हो जाता है. ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21) को चालू करने पर यह सुविधा चालू हो जाती है.

आज ही शुरू करें

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

CameraX 1.5 का इस्तेमाल करने के लिए,  कृपया अपनी libs.versions.toml फ़ाइल में ये डिपेंडेंसी जोड़ें. (हमारा सुझाव है कि आप 1.5.1 वर्शन का इस्तेमाल करें. इसमें कई ज़रूरी गड़बड़ियों को ठीक किया गया है. साथ ही, कैमरे की परफ़ॉर्मेंस को बेहतर बनाया गया है.) 

[versions]

camerax = "1.5.1"


[libraries]

..

androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "camerax" }

androidx-camera-compose = { module = "androidx.camera:camera-compose", version.ref = "camerax" }

androidx-camera-view = { module = "androidx.camera:camera-view", version.ref = "camerax" }

androidx-camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "camerax" }

androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax" }

androidx-camera-extensions = { module = "androidx.camera:camera-extensions", version.ref = "camerax" }

इसके बाद, इन्हें अपने मॉड्यूल की build.gradle.kts डिपेंडेंसी में जोड़ें:

dependencies {

  ..

  implementation(libs.androidx.camera.core)
  implementation(libs.androidx.camera.lifecycle)

  implementation(libs.androidx.camera.camera2)

  implementation(libs.androidx.camera.view) // for PreviewView 
  implementation(libs.androidx.camera.compose) // for compose UI

  implementation(libs.androidx.camera.extensions) // For Extensions 

}

क्या आपको कोई सवाल पूछना है या CameraX टीम से संपर्क करना है? CameraX डेवलपर के चर्चा ग्रुप में शामिल हों या गड़बड़ी की रिपोर्ट दर्ज करें:

• CameraX डेवलपर चर्चा ग्रुप
• गड़बड़ी की शिकायत करें