Camera2 एक्सटेंशन एपीआई

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

Camera2, एक्सटेंशन को ऐक्सेस करने के लिए Extensions API उपलब्ध कराता है. डिवाइस बनाने वाली कंपनियों ने इन एक्सटेंशन को अलग-अलग Android डिवाइसों पर लागू किया है. इस्तेमाल किए जा सकने वाले एक्सटेंशन मोड की सूची देखने के लिए, कैमरा एक्सटेंशन पर जाएं.

एक्सटेंशन की सुविधा वाले डिवाइसों की सूची देखने के लिए, एक्सटेंशन की सुविधा वाले डिवाइस पर जाएँ.

एक्सटेंशन का आर्किटेक्चर

यहां दी गई इमेज में, कैमरा एक्सटेंशन का आर्किटेक्चर दिखाया गया है.

पहली इमेज. कैमरा एक्सटेंशन का आर्किटेक्चर

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

Camera2 Extensions API के साथ काम करने की क्षमता की जांच करने के लिए, किसी कैमरा डिवाइस का इस्तेमाल करना

यहां दिया गया कोड स्निपेट यह जांच करता है कि डिवाइस, Camera2 Extensions API के साथ काम करता है या नहीं. सभी डिवाइसों पर एक्सटेंशन काम नहीं करते. इसके अलावा, ऐसा हो सकता है कि डिवाइस पर कुछ ही एक्सटेंशन काम करें. स्निपेट, काम करने वाले कैमरा आईडी की सूची दिखाता है. ये आईडी, कैमरा एक्सटेंशन के साथ काम करते हैं.

Kotlin

private fun getExtensionCameraIds(cameraManager: CameraManager): List<String> =
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
        cameraManager.cameraIdList.filter { cameraId ->
            val characteristics = cameraManager.getCameraCharacteristics(cameraId)
            val extensionCharacteristics =
                cameraManager.getCameraExtensionCharacteristics(cameraId)
            val capabilities =
                characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)
            extensionCharacteristics.supportedExtensions.isNotEmpty() &&
                    capabilities?.contains(
                        CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE
                    ) ?: false
        }
    } else emptyList()

Java

private List<String> getExtensionCameraIds(CameraManager cameraManager)
        throws CameraAccessException {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
        return Arrays.stream(cameraManager.getCameraIdList()).filter(cameraId -> {
            try {
                CameraCharacteristics characteristics =
                        cameraManager.getCameraCharacteristics(cameraId);
                CameraExtensionCharacteristics extensionCharacteristics =
                        cameraManager.getCameraExtensionCharacteristics(cameraId);
                IntStream capabilities =
                    Arrays.stream(
                                characteristics.get(
                                        CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES
                                )
                        );
                return !extensionCharacteristics.getSupportedExtensions().isEmpty() &&
                       capabilities.anyMatch(capability -> capability == CameraCharacteristics
                                        .REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE
                        );
            } catch (CameraAccessException e) {
                throw new RuntimeException(e);
            }
        }).collect(Collectors.toList());
    } else {
        return Collections.emptyList();
    }
}

Camera2 Extensions API की मदद से CameraExtensionSession बनाना

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

Kotlin

private val captureCallbacks = object : CameraExtensionSession.ExtensionCaptureCallback() {
    // Implement Capture Callbacks
}
private val extensionSessionStateCallback = object : CameraExtensionSession.StateCallback() {
    override fun onConfigured(session: CameraExtensionSession) {
        cameraExtensionSession = session
        try {
            val captureRequest =
                cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
                    addTarget(previewSurface)
                }.build()
            session.setRepeatingRequest(
                captureRequest,
                Dispatchers.IO.asExecutor(),
                captureCallbacks
            )
        } catch (e: CameraAccessException) {
            Snackbar.make(
                previewView,
                "Failed to preview capture request",
                Snackbar.LENGTH_SHORT
            ).show()
            requireActivity().finish()
        }
    }

    override fun onClosed(session: CameraExtensionSession) {
        super.onClosed(session)
        cameraDevice.close()
    }

    override fun onConfigureFailed(session: CameraExtensionSession) {
        Snackbar.make(
            previewView,
            "Failed to start camera extension preview",
            Snackbar.LENGTH_SHORT
        ).show()
        requireActivity().finish()
    }
}

private fun startExtensionSession() {
    val outputConfig = arrayListOf(
        OutputConfiguration(stillImageReader.surface),
        OutputConfiguration(previewSurface)
    )
    val extensionConfiguration = ExtensionSessionConfiguration(
        CameraExtensionCharacteristics.EXTENSION_NIGHT,
        outputConfig,
        Dispatchers.IO.asExecutor(),
        extensionSessionStateCallback
    )
    cameraDevice.createExtensionSession(extensionConfiguration)
}

Java

private CameraExtensionSession.ExtensionCaptureCallback captureCallbacks =
        new CameraExtensionSession.ExtensionCaptureCallback() {
            // Implement Capture Callbacks
        };

private CameraExtensionSession.StateCallback extensionSessionStateCallback =
        new CameraExtensionSession.StateCallback() {
            @Override
            public void onConfigured(@NonNull CameraExtensionSession session) {
                cameraExtensionSession = session;
                try {
                    CaptureRequest.Builder captureRequestBuilder =
                            cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
                    captureRequestBuilder.addTarget(previewSurface);
                    CaptureRequest captureRequest = captureRequestBuilder.build();
                    session.setRepeatingRequest(captureRequest, backgroundExecutor, captureCallbacks);
                } catch (CameraAccessException e) {
                    Snackbar.make(
                            previewView,
                            "Failed to preview capture request",
                            Snackbar.LENGTH_SHORT
                    ).show();
                    requireActivity().finish();
                }
            }

            @Override
            public void onClosed(@NonNull CameraExtensionSession session) {
                super.onClosed(session);
                cameraDevice.close();
            }

            @Override
            public void onConfigureFailed(@NonNull CameraExtensionSession session) {
                Snackbar.make(
                        previewView,
                        "Failed to start camera extension preview",
                        Snackbar.LENGTH_SHORT
                ).show();
                requireActivity().finish();
            }
        };

private void startExtensionSession() {
    ArrayList<OutputConfiguration> outputConfig = new ArrayList<>();
    outputConfig.add(new OutputConfiguration(stillImageReader.getSurface()));
    outputConfig.add(new OutputConfiguration(previewSurface));
    ExtensionSessionConfiguration extensionConfiguration = new ExtensionSessionConfiguration(
            CameraExtensionCharacteristics.EXTENSION_NIGHT,
            outputConfig,
            backgroundExecutor,
            extensionSessionStateCallback
    );
}

अन्य संसाधन

ज़्यादा जानकारी के लिए, CameraExtensionCharacteristics देखें. साथ ही, ज़्यादा जानकारी के लिए सार्वजनिक Camera2 Extensions API के सैंपल देखें.