ध्यान दें: इस पेज पर Camera2 पैकेज के बारे में बताया गया है. अगर आपके ऐप्लिकेशन को Camera2 की खास और लो-लेवल सुविधाओं की ज़रूरत नहीं है, तो हमारा सुझाव है कि आप CameraX का इस्तेमाल करें. CameraX और Camera2, दोनों ही Android 5.0 (एपीआई लेवल 21) और इसके बाद के वर्शन पर काम करते हैं.
कई मॉडर्न Android डिवाइसों में सामने, पीछे या दोनों तरफ़ दो या इससे ज़्यादा कैमरे होते हैं. हर लेंस की अपनी अलग-अलग क्षमताएं हो सकती हैं. जैसे, बर्स्ट कैप्चर, मैन्युअल कंट्रोल या मोशन ट्रैकिंग. चेक जमा करने वाला कोई ऐप्लिकेशन, सिर्फ़ पीछे वाले पहले कैमरे का इस्तेमाल कर सकता है. वहीं, कोई सोशल मीडिया ऐप्लिकेशन, डिफ़ॉल्ट रूप से सामने वाले कैमरे का इस्तेमाल कर सकता है. हालांकि, वह उपयोगकर्ताओं को उपलब्ध सभी लेंस के बीच स्विच करने का विकल्प देता है. यह उनकी पसंद को भी याद रख सकता है.
इस पेज पर, कैमरा लेंस और उनकी क्षमताओं को लिस्ट करने का तरीका बताया गया है. इससे आपको अपने ऐप्लिकेशन में यह तय करने में मदद मिलती है कि किसी स्थिति में किस लेंस का इस्तेमाल करना है. नीचे दिया गया कोड स्निपेट, सभी कैमरों की सूची को वापस लाता है और उन्हें दोहराता है:
try { val cameraIdList = cameraManager.cameraIdList // may be empty // iterate over available camera devices. for (cameraId in cameraIdList) { val characteristics = cameraManager.getCameraCharacteristics(cameraId) val cameraLensFacing = characteristics.get(CameraCharacteristics.LENS_FACING) val cameraCapabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES) // check if the selected camera device supports basic features // ensures backward compatibility with the original Camera API. val isBackwardCompatible = cameraCapabilities?.contains( CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE ) ?: false // ... } } catch (e: CameraAccessException) { e.message?.let { Log.e(TAG, it) } // ... }
वैरिएबल cameraLensFacing से पता चलता है कि डिवाइस की स्क्रीन के हिसाब से कैमरे का रुख़ किस तरफ़ है. इसकी वैल्यू इनमें से कोई एक हो सकती है:
CameraMetadata.LENS_FACING_FRONTCameraMetadata.LENS_FACING_BACKCameraMetadata.LENS_FACING_EXTERNAL
लेंस-फ़ेसिंग कॉन्फ़िगरेशन के बारे में ज़्यादा जानने के लिए, CameraCharacteristics.LENS_FACING देखें.
पिछले कोड सैंपल के वैरिएबल cameraCapabilities में, अन्य सुविधाओं के बारे में जानकारी होती है. इसमें यह भी शामिल है कि कैमरा, आउटपुट के तौर पर स्टैंडर्ड फ़्रेम बना सकता है या नहीं. उदाहरण के लिए, सिर्फ़ डेप्थ सेंसर डेटा के बजाय. यह देखा जा सकता है कि कैमरे की सुविधाओं की सूची में
CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE
शामिल है या नहीं. इसे
isBackwardCompatible
में फ़्लैग के तौर पर सेव किया जाता है.
सही डिफ़ॉल्ट सेटिंग चुनें
ऐसा हो सकता है कि आपको अपने ऐप्लिकेशन में, डिफ़ॉल्ट रूप से कोई खास कैमरा खोलना हो (अगर वह उपलब्ध है). उदाहरण के लिए, सेल्फ़ी लेने वाला ऐप्लिकेशन, सामने वाला कैमरा खोल सकता है. वहीं, ऑगमेंटेड रिएलिटी (एआर) वाला ऐप्लिकेशन, पीछे वाला कैमरा खोल सकता है. यह फ़ंक्शन, किसी खास दिशा में मौजूद पहले कैमरे की जानकारी दिखाता है:
fun getFirstCameraIdFacing( cameraManager: CameraManager, facing: Int = CameraMetadata.LENS_FACING_BACK ): String? { try { // Get list of all compatible cameras. val cameraIds = cameraManager.cameraIdList.filter { val characteristics = cameraManager.getCameraCharacteristics(it) val capabilities = characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES) capabilities?.contains( CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE ) ?: false } // Iterate over the list of cameras and return the first one matching desired // lens-facing configuration. cameraIds.forEach { val characteristics = cameraManager.getCameraCharacteristics(it) if (characteristics.get(CameraCharacteristics.LENS_FACING) == facing) { return it } } // If no camera matched desired orientation, return the first one from the list. return cameraIds.firstOrNull() } catch (e: CameraAccessException) { e.message?.let { Log.e(TAG, it) } return null } }
कैमरा स्विच करने की सुविधा चालू करना
कैमरे वाले कई ऐप्लिकेशन, उपयोगकर्ताओं को कैमरों के बीच स्विच करने का विकल्प देते हैं:
कई डिवाइसों में एक ही दिशा में कई कैमरे होते हैं. कुछ में बाहरी यूएसबी कैमरे भी होते हैं. उपयोगकर्ताओं को ऐसा यूज़र इंटरफ़ेस (यूआई) उपलब्ध कराने के लिए जिससे वे अलग-अलग कैमरे के बीच स्विच कर सकें, हर संभावित लेंस-फ़ेसिंग कॉन्फ़िगरेशन के लिए उपलब्ध पहला कैमरा चुनें.
अगला कैमरा चुनने के लिए कोई यूनिवर्सल लॉजिक नहीं है. हालांकि, यह कोड ज़्यादातर मामलों में काम करता है:
fun filterCompatibleCameras( cameraIds: Array<String>, cameraManager: CameraManager ): List<String> { return cameraIds.filter { val characteristics = cameraManager.getCameraCharacteristics(it) characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)?.contains( CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE ) ?: false } } fun filterCameraIdsFacing( cameraIds: List<String>, cameraManager: CameraManager, facing: Int ): List<String> { return cameraIds.filter { val characteristics = cameraManager.getCameraCharacteristics(it) characteristics.get(CameraCharacteristics.LENS_FACING) == facing } } fun getNextCameraId(cameraManager: CameraManager, currCameraId: String? = null): String? { // Get all front, back and external cameras in 3 separate lists. val cameraIds = filterCompatibleCameras(cameraManager.cameraIdList, cameraManager) val backCameras = filterCameraIdsFacing( cameraIds, cameraManager, CameraMetadata.LENS_FACING_BACK ) val frontCameras = filterCameraIdsFacing( cameraIds, cameraManager, CameraMetadata.LENS_FACING_FRONT ) val externalCameras = filterCameraIdsFacing( cameraIds, cameraManager, CameraMetadata.LENS_FACING_EXTERNAL ) // The recommended order of iteration is: all external, first back, first front. val allCameras = ( externalCameras + listOf( backCameras.firstOrNull(), frontCameras.firstOrNull() ) ).filterNotNull() // Get the index of the currently selected camera in the list. val cameraIndex = allCameras.indexOf(currCameraId) // The selected camera may not be in the list, for example it could be an // external camera that has been removed by the user. return if (cameraIndex == -1) { // Return the first camera from the list. allCameras.getOrNull(0) } else { // Return the next camera from the list, wrap around if necessary. allCameras.getOrNull((cameraIndex + 1) % allCameras.size) } }
यह कोड, कई अलग-अलग कॉन्फ़िगरेशन वाले डिवाइसों के बड़े सेट के लिए काम करता है. एज केस को मैनेज करने के बारे में ज़्यादा जानने के लिए, CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA देखें.
इसके साथ काम करने वाले ऐप्लिकेशन बनाएं
अब इस्तेमाल नहीं किए जा रहे Camera API का इस्तेमाल करने वाले ऐप्लिकेशन के लिए, Camera.getNumberOfCameras() से मिलने वाले कैमरों की संख्या, ओईएम के लागू करने के तरीके पर निर्भर करती है. अगर सिस्टम में एक लॉजिकल मल्टी-कैमरा है, तो ऐप्लिकेशन के पुराने सिस्टम के साथ काम करने की सुविधा को बनाए रखने के लिए, यह तरीका हर लॉजिकल कैमरे और उसके साथ काम करने वाले फ़िज़िकल कैमरों के ग्रुप के लिए सिर्फ़ एक कैमरा दिखाएगा. सभी कैमरे देखने के लिए, Camera2 API का इस्तेमाल करें.
कैमरे के ओरिएंटेशन के बारे में ज़्यादा जानकारी के लिए, Camera.CameraInfo.orientation देखें.
आम तौर पर, सभी कैमरे की orientation के बारे में क्वेरी करने के लिए, Camera.getCameraInfo() एपीआई का इस्तेमाल करें. साथ ही, कैमरे के बीच स्विच करने वाले उपयोगकर्ताओं के लिए, हर उपलब्ध ओरिएंटेशन के लिए सिर्फ़ एक कैमरा दिखाएं.
सभी तरह के डिवाइसों के लिए सही है
यह न मान लें कि आपका ऐप्लिकेशन हमेशा एक या दो कैमरे वाले हैंडहेल्ड डिवाइस पर चलता है. इसके बजाय, ऐप्लिकेशन के लिए सबसे सही कैमरे चुनें. अगर आपको किसी खास कैमरे की ज़रूरत नहीं है, तो चुनी गई दिशा में मौजूद पहला कैमरा चुनें. अगर किसी खास दिशा में मौजूद कैमरा उपलब्ध नहीं है, तो देखें कि क्या उपयोगकर्ता किसी दूसरे कैमरे की मदद से अपनी यात्रा पूरी कर सकता है. कैमरा हार्डवेयर के आधार पर, कुछ डिवाइसों पर अपने ऐप्लिकेशन की उपलब्धता को सीमित न करें. अगर कोई बाहरी कैमरा कनेक्ट है, तो हो सकता है कि उपयोगकर्ता उसे डिफ़ॉल्ट के तौर पर इस्तेमाल करना चाहे.