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

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

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

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

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

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

एपीआई मॉडल

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

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

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

CameraController

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

Kotlin

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

Java

PreviewView previewView = viewBinding.previewView;
LifecycleCameraController cameraController = new LifecycleCameraController(baseContext);
cameraController.bindToLifecycle(this);
cameraController.setCameraSelector(CameraSelector.DEFAULT_BACK_CAMERA);
previewView.setController(cameraController);

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

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

CameraProvider

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

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

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

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

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

Kotlin

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

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

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

Java

Preview preview = new Preview.Builder().build();
PreviewView viewFinder = findViewById(R.id.view_finder);

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

// PreviewView creates a surface provider, using a Surface from a different
// kind of view will require you to implement your own surface provider.
preview.previewSurfaceProvider = viewFinder.getSurfaceProvider();

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

CameraX के लाइफ़साइकल

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

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

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

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

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

कस्टम LifecycleOwner

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

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

Kotlin

class CustomLifecycle : LifecycleOwner {
    private val lifecycleRegistry: LifecycleRegistry

    init {
        lifecycleRegistry = LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }
    ...
    fun doOnResume() {
        lifecycleRegistry.markState(State.RESUMED)
    }
    ...
    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

Java

public class CustomLifecycle implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;
    public CustomLifecycle() {
        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }
   ...
   public void doOnResume() {
        lifecycleRegistry.markState(State.RESUMED);
    }
   ...
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

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

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

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

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

Kotlin

private lateinit var imageCapture: ImageCapture

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

    val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

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

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

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

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

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

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

Java

private ImageCapture imageCapture;

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    PreviewView previewView = findViewById(R.id.previewView);

    ListenableFuture<ProcessCameraProvider> cameraProviderFuture =
            ProcessCameraProvider.getInstance(this);

    cameraProviderFuture.addListener(() -> {
        try {
            // Camera provider is now guaranteed to be available
            ProcessCameraProvider cameraProvider = cameraProviderFuture.get();

            // Set up the view finder use case to display camera preview
            Preview preview = new Preview.Builder().build();

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

            // Choose the camera by requiring a lens facing
            CameraSelector cameraSelector = new CameraSelector.Builder()
                    .requireLensFacing(lensFacing)
                    .build();

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

            // Connect the preview use case to the previewView
            preview.setSurfaceProvider(
                    previewView.getSurfaceProvider());
        } catch (InterruptedException | ExecutionException e) {
            // Currently no exceptions thrown. cameraProviderFuture.get()
            // shouldn't block since the listener is being called, so no need to
            // handle InterruptedException.
        }
    }, ContextCompat.getMainExecutor(this));
}

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

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

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

Kotlin

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

Java

@androidx.annotation.OptIn(markerClass = ExperimentalCamera2Interop.class)
Boolean isBackCameraLevel3Device(ProcessCameraProvider cameraProvider) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        List\<CameraInfo\> filteredCameraInfos = CameraSelector.DEFAULT_BACK_CAMERA
                .filter(cameraProvider.getAvailableCameraInfos());
        if (!filteredCameraInfos.isEmpty()) {
            return Objects.equals(
                Camera2CameraInfo.from(filteredCameraInfos.get(0)).getCameraCharacteristic(
                        CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL),
                CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3);
        }
    }
    return false;
}

अनुमतियां

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

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

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

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

  • Android API लेवल 21
  • Android आर्किटेक्चर कॉम्पोनेंट 1.1.1

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

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

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

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

Groovy

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

Kotlin

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

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

Groovy

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

Kotlin

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

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

Groovy

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

Kotlin

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

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

CameraX और Camera2 के बीच इंटरऑपरेबिलिटी

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

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

  • Camera2CameraControl का इस्तेमाल करें. इससे आपको CaptureRequest पर प्रॉपर्टी सेट करने में मदद मिलती है. जैसे, ऑटो-फ़ोकस मोड.

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

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

Kotlin

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

val videoCallStreamId =
    CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong()

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

val cameraSelector = frontCameraInfo.cameraSelector

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

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

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

Java

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

Long videoCallStreamId =
    CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong();

// Check available CameraInfos to find the first one that supports
// the video call stream use case.
List<CameraInfo> cameraInfos = cameraProvider.getAvailableCameraInfos();
CameraInfo frontCameraInfo = null;
for (cameraInfo in cameraInfos) {
    Long[] availableStreamUseCases = Camera2CameraInfo.from(cameraInfo)
        .getCameraCharacteristic(
            CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES
        );
    boolean isVideoCallStreamingSupported = Arrays.List(availableStreamUseCases)
                .contains(videoCallStreamId);
    boolean isFrontFacing = (cameraInfo.getLensFacing() ==
                             CameraSelector.LENS_FACING_FRONT);

    if (isVideoCallStreamingSupported && isFrontFacing) {
        frontCameraInfo = cameraInfo;
    }
}

if (frontCameraInfo == null) {
    // Handle case where video call streaming is not supported.
}

CameraSelector cameraSelector = frontCameraInfo.getCameraSelector();

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

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

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

अन्य संसाधन

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

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

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

    • कोड सैंपल

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

    •