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

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

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

एक्सटेंशन का इस्तेमाल करने वाले डिवाइसों की सूची के लिए, काम करने वाले डिवाइस देखें.

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

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

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

Camera2 एक्सटेंशन एपीआई की सुविधा को ऐक्सेस करने के लिए, कैमरा डिवाइस की जांच करना

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

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()

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 एक्सटेंशन एपीआई की मदद से CameraExtensionसेशन बनाने का तरीका

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

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)
}

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 एक्सटेंशन एपीआई के सार्वजनिक सैंपल देखें देखें.