मल्टी-कैमरा एपीआई

ध्यान दें: यह पेज Camera2 पैकेज के बारे में है. हमारा सुझाव है कि अगर आपके ऐप्लिकेशन को Camera2 में खास और कम लेवल की सुविधाओं की ज़रूरत न हो, तो हमारा सुझाव है कि आप CameraX इस्तेमाल करें. CameraX और Camera2, दोनों ही Android 5.0 (एपीआई लेवल 21) और इसके बाद वाले वर्शन पर काम करते हैं.

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

इस्तेमाल के कुछ सामान्य उदाहरण:

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

लॉजिकल और फ़िज़िकल कैमरों में फ़र्क़

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

कई फ़ोन मैन्युफ़ैक्चरर, पहले-पक्ष के कैमरा ऐप्लिकेशन डेवलप करते हैं. ये आम तौर पर, वे उनके डिवाइसों पर पहले से इंस्टॉल होते हैं. हार्डवेयर की सभी क्षमताओं का इस्तेमाल करने के लिए, वे निजी या छिपे हुए एपीआई का इस्तेमाल कर सकते हैं या को लागू करता है, जिसका ऐक्सेस दूसरे ऐप्लिकेशन के पास नहीं है. कुछ सूचनाएं मिल रही हैं डिवाइस, लॉजिकल कैमरों के सिद्धांत को लागू करते हैं. इसके लिए, ये जिसमें अलग-अलग कैमरे के फ़्रेम हैं, लेकिन सिर्फ़ खास अधिकार वाले लोगों के लिए का इस्तेमाल करें. अक्सर, कैमरे में से एक ही कैमरा फ़्रेमवर्क शामिल है. Android 9 से पहले के वर्शन वाले तीसरे पक्ष के डेवलपर के लिए स्थिति यह है इसे इस डायग्राम में दिखाया गया है:

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

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

एक से ज़्यादा कैमरों के लिए एपीआई

एपीआई के नए वर्शन में ये नए कॉन्सटेंट, क्लास, और मेथड जोड़े जाते हैं:

• CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA
• CameraCharacteristics.getPhysicalCameraIds()
• CameraCharacteristics.getAvailablePhysicalCameraRequestKeys()
• CameraDevice.createCaptureSession(SessionConfiguration config)
• CameraCharacteritics.LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE
• OutputConfiguration और SessionConfiguration

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

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

एक साथ कई स्ट्रीम करना

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

• स्ट्रीम 1: YUV टाइप, लॉजिकल कैमरे से MAXIMUM साइज़ id = 0

इसके बाद, कई कैमरों की सुविधा वाले डिवाइस से सेशन शुरू किया जा सकता है उस लॉजिकल YUV स्ट्रीम को दो फ़िज़िकल स्ट्रीम से बदलना:

• स्ट्रीम 1: YUV टाइप, फ़िज़िकल कैमरे से MAXIMUM साइज़ id = 1
• स्ट्रीम 2: YUV टाइप, फ़िज़िकल कैमरे से MAXIMUM साइज़ id = 2

YUV या RAW स्ट्रीम को दो मिलती-जुलती स्ट्रीम से बदला जा सकता है. ऐसा तब ही किया जा सकता है, जब वे दोनों कैमरे एक लॉजिकल कैमरा ग्रुपिंग का हिस्सा हैं,  जो CameraCharacteristics.getPhysicalCameraIds().

फ़्रेमवर्क से मिलने वाली गारंटी सिर्फ़ हमारे लिए ज़रूरी होती है. एक साथ एक से ज़्यादा भौतिक कैमरे से फ़्रेम प्राप्त करें. अन्य स्ट्रीम ज़्यादातर डिवाइसों पर काम करते हैं. कभी-कभी एक से ज़्यादा डिवाइस अलग-अलग डिवाइस पर काम करता है. क्योंकि इसकी फ़्रेमवर्क के मुताबिक, ऐसा करने के लिए हर डिवाइस के हिसाब से टेस्टिंग और ट्यूनिंग की ज़रूरत होती है करते हैं.

एक से ज़्यादा कैमरे के साथ सेशन बनाना

कई कैमरों वाले डिवाइस पर कैमरे का इस्तेमाल करते समय, किसी एक डिवाइस को खोलें CameraDevice (लॉजिकल कैमरा) को अनुमति दें और एक ही समय में इससे इंटरैक्ट करें सत्र. एपीआई का इस्तेमाल करके सिंगल सेशन बनाना CameraDevice.createCaptureSession(SessionConfiguration config), जो एपीआई लेवल 28 में जोड़ा गया. सेशन कॉन्फ़िगरेशन में कई आउटपुट हैं कॉन्फ़िगरेशन, जिनमें से हर एक में आउटपुट टारगेट का एक सेट होता है और, वैकल्पिक रूप से, आपको ज़रूरत के मुताबिक फ़िज़िकल कैमरा आईडी चाहिए.

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

कैमरे के जोड़े का इस्तेमाल करना

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

/**
     * Helper class used to encapsulate a logical camera and two underlying
     * physical cameras
     */
    data class DualCamera(val logicalId: String, val physicalId1: String, val physicalId2: String)

    fun findDualCameras(manager: CameraManager, facing: Int? = null): List {
        val dualCameras = MutableList()

        // Iterate over all the available camera characteristics
        manager.cameraIdList.map {
            Pair(manager.getCameraCharacteristics(it), it)
        }.filter {
            // Filter by cameras facing the requested direction
            facing == null || it.first.get(CameraCharacteristics.LENS_FACING) == facing
        }.filter {
            // Filter by logical cameras
            // CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA requires API >= 28
            it.first.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)!!.contains(
                CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA)
        }.forEach {
            // All possible pairs from the list of physical cameras are valid results
            // NOTE: There could be N physical cameras as part of a logical camera grouping
            // getPhysicalCameraIds() requires API >= 28
            val physicalCameras = it.first.physicalCameraIds.toTypedArray()
            for (idx1 in 0 until physicalCameras.size) {
                for (idx2 in (idx1 + 1) until physicalCameras.size) {
                    dualCameras.add(DualCamera(
                        it.second, physicalCameras[idx1], physicalCameras[idx2]))
                }
            }
        }

        return dualCameras
    }

/**
     * Helper class used to encapsulate a logical camera and two underlying
     * physical cameras
     */
    final class DualCamera {
        final String logicalId;
        final String physicalId1;
        final String physicalId2;

        DualCamera(String logicalId, String physicalId1, String physicalId2) {
            this.logicalId = logicalId;
            this.physicalId1 = physicalId1;
            this.physicalId2 = physicalId2;
        }
    }
    List findDualCameras(CameraManager manager, Integer facing) {
        List dualCameras = new ArrayList<>();

        List cameraIdList;
        try {
            cameraIdList = Arrays.asList(manager.getCameraIdList());
        } catch (CameraAccessException e) {
            e.printStackTrace();
            cameraIdList = new ArrayList<>();
        }

        // Iterate over all the available camera characteristics
        cameraIdList.stream()
                .map(id -> {
                    try {
                        CameraCharacteristics characteristics = manager.getCameraCharacteristics(id);
                        return new Pair<>(characteristics, id);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();
                        return null;
                    }
                })
                .filter(pair -> {
                    // Filter by cameras facing the requested direction
                    return (pair != null) &&
                            (facing == null || pair.first.get(CameraCharacteristics.LENS_FACING).equals(facing));
                })
                .filter(pair -> {
                    // Filter by logical cameras
                    // CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA requires API >= 28
                    IntPredicate logicalMultiCameraPred =
                            arg -> arg == CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA;
                    return Arrays.stream(pair.first.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES))
                            .anyMatch(logicalMultiCameraPred);
                })
                .forEach(pair -> {
                    // All possible pairs from the list of physical cameras are valid results
                    // NOTE: There could be N physical cameras as part of a logical camera grouping
                    // getPhysicalCameraIds() requires API >= 28
                    String[] physicalCameras = pair.first.getPhysicalCameraIds().toArray(new String[0]);
                    for (int idx1 = 0; idx1 < physicalCameras.length; idx1++) {
                        for (int idx2 = idx1 + 1; idx2 < physicalCameras.length; idx2++) {
                            dualCameras.add(
                                    new DualCamera(pair.second, physicalCameras[idx1], physicalCameras[idx2]));
                        }
                    }
                });
return dualCameras;
}

कैमरे को किस तरह हैंडल किया जा रहा है, यह लॉजिकल कैमरे से कंट्रोल किया जाता है. यहां की यात्रा पर हूं "ड्यूअल कैमरा" खोलें, फ़िज़िकल इमेज से मिलता-जुलता लॉजिकल कैमरा चालू करो कैमरा:

fun openDualCamera(cameraManager: CameraManager,
                       dualCamera: DualCamera,
        // AsyncTask is deprecated beginning API 30
                       executor: Executor = AsyncTask.SERIAL_EXECUTOR,
                       callback: (CameraDevice) -> Unit) {

        // openCamera() requires API >= 28
        cameraManager.openCamera(
            dualCamera.logicalId, executor, object : CameraDevice.StateCallback() {
                override fun onOpened(device: CameraDevice) = callback(device)
                // Omitting for brevity...
                override fun onError(device: CameraDevice, error: Int) = onDisconnected(device)
                override fun onDisconnected(device: CameraDevice) = device.close()
            })
    }

void openDualCamera(CameraManager cameraManager,
                        DualCamera dualCamera,
                        Executor executor,
                        CameraDeviceCallback cameraDeviceCallback
    ) {

        // openCamera() requires API >= 28
        cameraManager.openCamera(dualCamera.logicalId, executor, new CameraDevice.StateCallback() {
            @Override
            public void onOpened(@NonNull CameraDevice cameraDevice) {
               cameraDeviceCallback.callback(cameraDevice);
            }

            @Override
            public void onDisconnected(@NonNull CameraDevice cameraDevice) {
                cameraDevice.close();
            }

            @Override
            public void onError(@NonNull CameraDevice cameraDevice, int i) {
                onDisconnected(cameraDevice);
            }
        });
    }

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

/**
 * Helper type definition that encapsulates 3 sets of output targets:
 *
 *   1. Logical camera
 *   2. First physical camera
 *   3. Second physical camera
 */
typealias DualCameraOutputs =
        Triple?, MutableList?, MutableList?>

fun createDualCameraSession(cameraManager: CameraManager,
                            dualCamera: DualCamera,
                            targets: DualCameraOutputs,
                            // AsyncTask is deprecated beginning API 30
                            executor: Executor = AsyncTask.SERIAL_EXECUTOR,
                            callback: (CameraCaptureSession) -> Unit) {

    // Create 3 sets of output configurations: one for the logical camera, and
    // one for each of the physical cameras.
    val outputConfigsLogical = targets.first?.map { OutputConfiguration(it) }
    val outputConfigsPhysical1 = targets.second?.map {
        OutputConfiguration(it).apply { setPhysicalCameraId(dualCamera.physicalId1) } }
    val outputConfigsPhysical2 = targets.third?.map {
        OutputConfiguration(it).apply { setPhysicalCameraId(dualCamera.physicalId2) } }

    // Put all the output configurations into a single flat array
    val outputConfigsAll = arrayOf(
        outputConfigsLogical, outputConfigsPhysical1, outputConfigsPhysical2)
        .filterNotNull().flatMap { it }

    // Instantiate a session configuration that can be used to create a session
    val sessionConfiguration = SessionConfiguration(
        SessionConfiguration.SESSION_REGULAR,
        outputConfigsAll, executor, object : CameraCaptureSession.StateCallback() {
            override fun onConfigured(session: CameraCaptureSession) = callback(session)
            // Omitting for brevity...
            override fun onConfigureFailed(session: CameraCaptureSession) = session.device.close()
        })

    // Open the logical camera using the previously defined function
    openDualCamera(cameraManager, dualCamera, executor = executor) {

        // Finally create the session and return via callback
        it.createCaptureSession(sessionConfiguration)
    }
}

/**
 * Helper class definition that encapsulates 3 sets of output targets:
 * 

 * 1. Logical camera
 * 2. First physical camera
 * 3. Second physical camera
 */
final class DualCameraOutputs {
    private final List logicalCamera;
    private final List firstPhysicalCamera;
    private final List secondPhysicalCamera;

    public DualCameraOutputs(List logicalCamera, List firstPhysicalCamera, List third) {
        this.logicalCamera = logicalCamera;
        this.firstPhysicalCamera = firstPhysicalCamera;
        this.secondPhysicalCamera = third;
    }

    public List getLogicalCamera() {
        return logicalCamera;
    }

    public List getFirstPhysicalCamera() {
        return firstPhysicalCamera;
    }

    public List getSecondPhysicalCamera() {
        return secondPhysicalCamera;
    }
}

interface CameraCaptureSessionCallback {
    void callback(CameraCaptureSession cameraCaptureSession);
}

void createDualCameraSession(CameraManager cameraManager,
                                 DualCamera dualCamera,
                                 DualCameraOutputs targets,
                                 Executor executor,
                                 CameraCaptureSessionCallback cameraCaptureSessionCallback) {

        // Create 3 sets of output configurations: one for the logical camera, and
        // one for each of the physical cameras.
        List outputConfigsLogical = targets.getLogicalCamera().stream()
                .map(OutputConfiguration::new)
                .collect(Collectors.toList());
        List outputConfigsPhysical1 = targets.getFirstPhysicalCamera().stream()
                .map(s -> {
                    OutputConfiguration outputConfiguration = new OutputConfiguration(s);
                    outputConfiguration.setPhysicalCameraId(dualCamera.physicalId1);
                    return outputConfiguration;
                })
                .collect(Collectors.toList());
        List outputConfigsPhysical2 = targets.getSecondPhysicalCamera().stream()
                .map(s -> {
                    OutputConfiguration outputConfiguration = new OutputConfiguration(s);
                    outputConfiguration.setPhysicalCameraId(dualCamera.physicalId2);
                    return outputConfiguration;
                })
                .collect(Collectors.toList());

        // Put all the output configurations into a single flat array
        List outputConfigsAll = Stream.of(
                        outputConfigsLogical, outputConfigsPhysical1, outputConfigsPhysical2
                )
                .filter(Objects::nonNull)
                .flatMap(Collection::stream)
                .collect(Collectors.toList());

        // Instantiate a session configuration that can be used to create a session
        SessionConfiguration sessionConfiguration = new SessionConfiguration(
                SessionConfiguration.SESSION_REGULAR,
                outputConfigsAll, executor, new CameraCaptureSession.StateCallback() {
            @Override
            public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                cameraCaptureSessionCallback.callback(cameraCaptureSession);
            }
            // Omitting for brevity...
            @Override
            public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
                cameraCaptureSession.getDevice().close();
            }
        });

        // Open the logical camera using the previously defined function
        openDualCamera(cameraManager, dualCamera, executor, (CameraDevice c) ->
                // Finally create the session and return via callback
                c.createCaptureSession(sessionConfiguration));
    }

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

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

Zoom के इस्तेमाल के उदाहरण का उदाहरण

फ़िज़िकल कैमरों को किसी एक स्ट्रीम में मर्ज किया जा सकता है, इसलिए कि लोग अलग-अलग कैमरों के बीच स्विच कर सकें, ताकि जो अलग-अलग "ज़ूम लेवल" को असरदार तरीके से कैप्चर करते हैं.

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

fun findShortLongCameraPair(manager: CameraManager, facing: Int? = null): DualCamera? {

    return findDualCameras(manager, facing).map {
        val characteristics1 = manager.getCameraCharacteristics(it.physicalId1)
        val characteristics2 = manager.getCameraCharacteristics(it.physicalId2)

        // Query the focal lengths advertised by each physical camera
        val focalLengths1 = characteristics1.get(
            CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS) ?: floatArrayOf(0F)
        val focalLengths2 = characteristics2.get(
            CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS) ?: floatArrayOf(0F)

        // Compute the largest difference between min and max focal lengths between cameras
        val focalLengthsDiff1 = focalLengths2.maxOrNull()!! - focalLengths1.minOrNull()!!
        val focalLengthsDiff2 = focalLengths1.maxOrNull()!! - focalLengths2.minOrNull()!!

        // Return the pair of camera IDs and the difference between min and max focal lengths
        if (focalLengthsDiff1 < focalLengthsDiff2) {
            Pair(DualCamera(it.logicalId, it.physicalId1, it.physicalId2), focalLengthsDiff1)
        } else {
            Pair(DualCamera(it.logicalId, it.physicalId2, it.physicalId1), focalLengthsDiff2)
        }

        // Return only the pair with the largest difference, or null if no pairs are found
    }.maxByOrNull { it.second }?.first
}

// Utility functions to find min/max value in float[]
    float findMax(float[] array) {
        float max = Float.NEGATIVE_INFINITY;
        for(float cur: array)
            max = Math.max(max, cur);
        return max;
    }
    float findMin(float[] array) {
        float min = Float.NEGATIVE_INFINITY;
        for(float cur: array)
            min = Math.min(min, cur);
        return min;
    }

DualCamera findShortLongCameraPair(CameraManager manager, Integer facing) {
        return findDualCameras(manager, facing).stream()
                .map(c -> {
                    CameraCharacteristics characteristics1;
                    CameraCharacteristics characteristics2;
                    try {
                        characteristics1 = manager.getCameraCharacteristics(c.physicalId1);
                        characteristics2 = manager.getCameraCharacteristics(c.physicalId2);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();
                        return null;
                    }

                    // Query the focal lengths advertised by each physical camera
                    float[] focalLengths1 = characteristics1.get(
                            CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
                    float[] focalLengths2 = characteristics2.get(
                            CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);

                    // Compute the largest difference between min and max focal lengths between cameras
                    Float focalLengthsDiff1 = findMax(focalLengths2) - findMin(focalLengths1);
                    Float focalLengthsDiff2 = findMax(focalLengths1) - findMin(focalLengths2);

                    // Return the pair of camera IDs and the difference between min and max focal lengths
                    if (focalLengthsDiff1 < focalLengthsDiff2) {
                        return new Pair<>(new DualCamera(c.logicalId, c.physicalId1, c.physicalId2), focalLengthsDiff1);
                    } else {
                        return new Pair<>(new DualCamera(c.logicalId, c.physicalId2, c.physicalId1), focalLengthsDiff2);
                    }

                }) // Return only the pair with the largest difference, or null if no pairs are found
                .max(Comparator.comparing(pair -> pair.second)).get().first;
    }

इसके लिए एक सही आर्किटेक्चर में दो SurfaceViews—हर स्ट्रीम के लिए एक. उपयोगकर्ता के इंटरैक्शन के आधार पर, इन SurfaceViews की अदला-बदली की जाती है. ऐसा इसलिए, ताकि सिर्फ़ एक को किसी भी समय दिखाई दे सकते हैं.

नीचे दिए गए कोड में, लॉजिकल कैमरा खोलने और कैमरे को कॉन्फ़िगर करने का तरीका बताया गया है आउटपुट, कैमरा सेशन बनाएं, और दो झलक स्ट्रीम शुरू करें:

val cameraManager: CameraManager = ...

// Get the two output targets from the activity / fragment
val surface1 = ...  // from SurfaceView
val surface2 = ...  // from SurfaceView

val dualCamera = findShortLongCameraPair(manager)!!
val outputTargets = DualCameraOutputs(
    null, mutableListOf(surface1), mutableListOf(surface2))

// Here you open the logical camera, configure the outputs and create a session
createDualCameraSession(manager, dualCamera, targets = outputTargets) { session ->

  // Create a single request which has one target for each physical camera
  // NOTE: Each target receive frames from only its associated physical camera
  val requestTemplate = CameraDevice.TEMPLATE_PREVIEW
  val captureRequest = session.device.createCaptureRequest(requestTemplate).apply {
    arrayOf(surface1, surface2).forEach { addTarget(it) }
  }.build()

  // Set the sticky request for the session and you are done
  session.setRepeatingRequest(captureRequest, null, null)
}

CameraManager manager = ...;

        // Get the two output targets from the activity / fragment
        Surface surface1 = ...;  // from SurfaceView
        Surface surface2 = ...;  // from SurfaceView

        DualCamera dualCamera = findShortLongCameraPair(manager, null);
                DualCameraOutputs outputTargets = new DualCameraOutputs(
                null, Collections.singletonList(surface1), Collections.singletonList(surface2));

        // Here you open the logical camera, configure the outputs and create a session
        createDualCameraSession(manager, dualCamera, outputTargets, null, (session) -> {
            // Create a single request which has one target for each physical camera
            // NOTE: Each target receive frames from only its associated physical camera
            CaptureRequest.Builder captureRequestBuilder;
            try {
                captureRequestBuilder = session.getDevice().createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
                Arrays.asList(surface1, surface2).forEach(captureRequestBuilder::addTarget);

                // Set the sticky request for the session and you are done
                session.setRepeatingRequest(captureRequestBuilder.build(), null, null);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        });

बस उपयोगकर्ता को एक यूज़र इंटरफ़ेस (यूआई) उपलब्ध कराना है, ताकि वह इन दोनों के बीच स्विच कर सके जैसे कि बटन या SurfaceView पर दो बार टैप करना. आप चाहें तो किसी सीन का विश्लेषण करके दो स्ट्रीम के बीच स्विच करना स्वचालित रूप से.

लेंस डिस्टॉर्शन

सभी लेंस एक तय मात्रा में डिस्टॉर्शन पैदा करते हैं. Android में, आप इसका इस्तेमाल करके लेंस में आने वाला डिस्टॉर्शन CameraCharacteristics.LENS_DISTORTION, जो अब ख़ारिज हो चुकी है CameraCharacteristics.LENS_RADIAL_DISTORTION. लॉजिकल कैमरों के लिए, डिस्टॉर्शन कम होता है और आपका ऐप्लिकेशन वे कैमरे से आने वाले फ़्रेम से कम या ज़्यादा फ़्रेम आते हैं. फ़िज़िकल कैमरों के लिए, लेंस के कॉन्फ़िगरेशन बहुत अलग-अलग होते हैं. खास तौर पर, वाइड लेंस के लिए लेंस.

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

val cameraSession: CameraCaptureSession = ...

        // Use still capture template to build the capture request
        val captureRequest = cameraSession.device.createCaptureRequest(
            CameraDevice.TEMPLATE_STILL_CAPTURE
        )

        // Determine if this device supports distortion correction
        val characteristics: CameraCharacteristics = ...
        val supportsDistortionCorrection = characteristics.get(
            CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES
        )?.contains(
            CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY
        ) ?: false

        if (supportsDistortionCorrection) {
            captureRequest.set(
                CaptureRequest.DISTORTION_CORRECTION_MODE,
                CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY
            )
        }

        // Add output target, set other capture request parameters...

        // Dispatch the capture request
        cameraSession.capture(captureRequest.build(), ...)

CameraCaptureSession cameraSession = ...;

        // Use still capture template to build the capture request
        CaptureRequest.Builder captureRequestBuilder = null;
        try {
            captureRequestBuilder = cameraSession.getDevice().createCaptureRequest(
                    CameraDevice.TEMPLATE_STILL_CAPTURE
            );
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }

        // Determine if this device supports distortion correction
        CameraCharacteristics characteristics = ...;
        boolean supportsDistortionCorrection = Arrays.stream(
                        characteristics.get(
                                CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES
                        ))
                .anyMatch(i -> i == CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY);
        if (supportsDistortionCorrection) {
            captureRequestBuilder.set(
                    CaptureRequest.DISTORTION_CORRECTION_MODE,
                    CameraMetadata.DISTORTION_CORRECTION_MODE_HIGH_QUALITY
            );
        }

        // Add output target, set other capture request parameters...

        // Dispatch the capture request
        cameraSession.capture(captureRequestBuilder.build(), ...);

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