Android फ़्रेमवर्क में, डिवाइसों पर उपलब्ध अलग-अलग कैमरों और कैमरे की सुविधाओं के लिए सहायता शामिल होती है. इससे, आपको अपने ऐप्लिकेशन में फ़ोटो और वीडियो कैप्चर करने की सुविधा मिलती है. इस दस्तावेज़ में, इमेज और वीडियो कैप्चर करने के तेज़ और आसान तरीके के बारे में बताया गया है. साथ ही, उपयोगकर्ताओं के लिए कैमरे के कस्टम अनुभव बनाने के बेहतर तरीके के बारे में भी बताया गया है.
ध्यान दें:
इस पेज पर, Camera
क्लास के बारे में बताया गया है. इसे अब इस्तेमाल नहीं किया जा सकता. हमारा सुझाव है कि आप
CameraX Jetpack लाइब्रेरी का इस्तेमाल करें. इसके अलावा, इस्तेमाल के कुछ उदाहरणों के लिए,
camera2
,
क्लास का इस्तेमाल करें. CameraX और Camera2, दोनों ही Android 5.0 (एपीआई लेवल 21) और उसके बाद के वर्शन पर काम करते हैं.
इस बारे में ज़्यादा जानने के लिए, यहां दिए गए लेख पढ़ें:
ज़रूरी बातें
Android डिवाइस पर कैमरे का उपयोग करने के लिए अपने ऐप्लिकेशन को सक्षम करने से पहले, आपको कुछ आपका ऐप्लिकेशन, हार्डवेयर की सुविधा का इस्तेमाल किस तरह करना चाहता है, इस बारे में सवाल.
- कैमरे की ज़रूरत - क्या आपके ऐप्लिकेशन के लिए कैमरे का इस्तेमाल करना इतना ज़रूरी है कि आपको अपने ऐप्लिकेशन को ऐसे डिवाइस पर इंस्टॉल नहीं करना है जिसमें कैमरा नहीं है? अगर ऐसा है, तो आपको अपने मेनिफ़ेस्ट में कैमरे की ज़रूरत के बारे में बताना चाहिए.
- क्विक तस्वीर या पसंद के मुताबिक बनाया गया कैमरा - आपका ऐप्लिकेशन इसका इस्तेमाल कैसे करेगा कैमरा? क्या आपको सिर्फ़ एक फ़ोटो या वीडियो क्लिप लेनी है या आपका ऐप्लिकेशन, कैमरे इस्तेमाल करने का नया तरीका उपलब्ध कराएगा? तुरंत एक स्नैप या क्लिप पाने के लिए, इन बातों पर ध्यान दें मौजूदा कैमरा ऐप्लिकेशन इस्तेमाल करना. कैमरे से जुड़ी सुविधा को अपनी पसंद के मुताबिक बनाने के लिए, कैमरा ऐप्लिकेशन बनाना सेक्शन से बाहर निकलें.
- फ़ोरग्राउंड सेवाओं की ज़रूरी शर्त - आपका ऐप्लिकेशन, कैमरे के साथ कब इंटरैक्ट करता है? Android 9 (एपीआई लेवल 28) और इसके बाद के वर्शन पर, बैकग्राउंड, कैमरे को ऐक्सेस नहीं कर सकता. इसलिए, आपको कैमरे का इस्तेमाल तब करना चाहिए, जब आपका ऐप्लिकेशन फ़ोरग्राउंड में हो या फ़ोरग्राउंड सेवा के हिस्से के तौर पर हो.
- स्टोरेज - क्या आपके ऐप्लिकेशन से जनरेट होने वाली इमेज या वीडियो सिर्फ़ आपके ऐप्लिकेशन को दिखें या उन्हें शेयर किया जाए, ताकि Gallery या अन्य मीडिया और सोशल ऐप्लिकेशन उनका इस्तेमाल कर सकें? क्या आपको तस्वीरें और वीडियो उपलब्ध होने चाहिए, भले ही ऐप्लिकेशन अनइंस्टॉल है? इन विकल्पों को लागू करने का तरीका जानने के लिए, मीडिया फ़ाइलें सेव करना सेक्शन देखें.
बुनियादी बातें
Android फ़्रेमवर्क,
android.hardware.camera2
एपीआई या कैमरा Intent
. ये रहे काम के नतीजे
क्लास:
android.hardware.camera2
- यह पैकेज, डिवाइस के कैमरों को कंट्रोल करने के लिए मुख्य एपीआई है. इसकी मदद से, किसी भी समय फ़ोटो या वीडियो.
Camera
- यह क्लास, डिवाइस के कैमरों को कंट्रोल करने के लिए इस्तेमाल किया जाने वाला पुराना और अब काम न करने वाला एपीआई है.
SurfaceView
- इस क्लास का इस्तेमाल, उपयोगकर्ता को लाइव कैमरे की झलक दिखाने के लिए किया जाता है.
MediaRecorder
- इस क्लास का इस्तेमाल कैमरे से वीडियो रिकॉर्ड करने के लिए किया जाता है.
Intent
MediaStore.ACTION_IMAGE_CAPTURE
याMediaStore.ACTION_VIDEO_CAPTURE
के इंटेंट ऐक्शन टाइप का इस्तेमाल, सीधे तौर पर इमेज या वीडियो को कैप्चर करने के लिए किया जा सकता हैCamera
ऑब्जेक्ट का इस्तेमाल करके.
मेनिफ़ेस्ट फ़ाइल
Camera API के साथ अपने ऐप्लिकेशन पर डेवलपमेंट शुरू करने से पहले, आपको यह पक्का करना चाहिए कि आपके मेनिफ़ेस्ट में कैमरा हार्डवेयर और दूसरी चीज़ों मिलते-जुलते फ़ीचर.
- कैमरे का ऐक्सेस - आपके ऐप्लिकेशन को डिवाइस के कैमरे का इस्तेमाल करने के लिए अनुमति का अनुरोध करना होगा.
<uses-permission android:name="android.permission.CAMERA" />
ध्यान दें: यदि आप कैमरे का उपयोग इसके अनुसार कर रहे हैं हम किसी मौजूदा कैमरा ऐप्लिकेशन को शुरू करते हैं, आपके ऐप्लिकेशन को इस अनुमति के लिए अनुरोध करने की ज़रूरत नहीं है.
- कैमरे की सुविधाएं - आपके ऐप्लिकेशन में कैमरे की सुविधाओं के इस्तेमाल के बारे में भी जानकारी होनी चाहिए. उदाहरण के लिए:
<uses-feature android:name="android.hardware.camera" />
कैमरे की सुविधाओं की सूची के लिए, मेनिफ़ेस्ट देखें सुविधाएं रेफ़रंस.
मेनिफ़ेस्ट में कैमरे की सुविधाएं जोड़ने पर, Google Play आपके ऐप्लिकेशन को उन डिवाइस पर इंस्टॉल किया जा रहा है जिनमें कैमरा शामिल नहीं है या जिनमें वे सुविधाएं काम नहीं करतीं तय करें. Google Play पर, सुविधा के हिसाब से फ़िल्टर करने की सुविधा के इस्तेमाल के बारे में ज़्यादा जानने के लिए, Google Play और सुविधा के हिसाब से फ़िल्टर करने की सुविधा लेख पढ़ें.
अगर आपका ऐप्लिकेशन सही तरीके से काम करने के लिए, कैमरे या कैमरे की सुविधा का इस्तेमाल कर सकता है, लेकिन उसे इसकी ज़रूरत नहीं है, तो आपको मेनिफ़ेस्ट में इसकी जानकारी देनी चाहिए. इसके लिए,
android:required
एट्रिब्यूट को शामिल करें और उसेfalse
पर सेट करें:<uses-feature android:name="android.hardware.camera" android:required="false" />
- स्टोरेज की अनुमति - आपका ऐप्लिकेशन, डिवाइस के बाहरी स्टोरेज (एसडी कार्ड) में इमेज या वीडियो सेव कर सकता है. इसके लिए ज़रूरी है कि आपका ऐप्लिकेशन, Android 10 (SDK टूल लेवल 29) या उससे पहले के वर्शन को टारगेट करता हो. साथ ही, मेनिफ़ेस्ट में यह जानकारी दी गई हो.
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
- ऑडियो रिकॉर्ड करने की अनुमति - वीडियो कैप्चर के साथ ऑडियो रिकॉर्ड करने के लिए, आपका
ऐप्लिकेशन को ऑडियो कैप्चर करने की अनुमति के लिए अनुरोध करना होगा.
<uses-permission android:name="android.permission.RECORD_AUDIO" />
-
जगह की जानकारी की अनुमति - अगर आपका ऐप्लिकेशन इमेज को टैग करता है अगर आपको जीपीएस से जगह की जानकारी मिल रही है, तो आपको
ACCESS_FINE_LOCATION
का अनुरोध करना होगा अनुमति. ध्यान दें कि अगर आपका ऐप्लिकेशन Android 5.0 (एपीआई लेवल 21) को टारगेट करता है या उससे ज़्यादा है, तो आपको यह एलान भी करना होगा कि आपका ऐप्लिकेशन डिवाइस के जीपीएस का इस्तेमाल करता है:<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> ... <!-- Needed only if your app targets Android 5.0 (API level 21) or higher. --> <uses-feature android:name="android.hardware.location.gps" />
उपयोगकर्ता की जगह की जानकारी पाने के बारे में ज़्यादा जानने के लिए, यहां देखें जगह की जानकारी से जुड़ी रणनीतियां.
मौजूदा कैमरा ऐप्लिकेशन का इस्तेमाल करना
बहुत ज़्यादा कोड के बिना अपने ऐप्लिकेशन में फ़ोटो या वीडियो लेने की सुविधा चालू करने का तेज़ तरीका
किसी मौजूदा Android कैमरा ऐप्लिकेशन को शुरू करने के लिए, Intent
का इस्तेमाल करना है.
यह जानकारी ट्रेनिंग लेसन में दी गई है
फ़ोटो खींचना और
सिर्फ़ वीडियो रिकॉर्ड करने की सुविधा.
कैमरा ऐप्लिकेशन बनाना
कुछ डेवलपर को कैमरे का ऐसा यूज़र इंटरफ़ेस चाहिए जो उनके ऐप्लिकेशन के लुक के हिसाब से बनाया गया हो या खास सुविधाएं उपलब्ध कराता हो. फ़ोटो लेने के लिए खुद कोड लिखने से, आपके उपयोगकर्ताओं को बेहतर अनुभव मिल सकता है.
ध्यान दें: नीचे दी गई गाइड, पुरानी, अब काम नहीं करने वाली Camera
के लिए है
एपीआई. नए या बेहतर कैमरा ऐप्लिकेशन के लिए, नया android.hardware.camera2
API
सुझाया गया है.
आपके ऐप्लिकेशन के लिए कस्टम कैमरा इंटरफ़ेस बनाने के सामान्य चरण नीचे दिए गए हैं:
- कैमरे का पता लगाएं और उसे ऐक्सेस करें - इसकी मौजूदगी की जांच करने के लिए कोड बनाएं कैमरे ऐक्सेस करें और ऐक्सेस का अनुरोध करें.
- झलक वाली क्लास बनाना - कैमरे की झलक वाली ऐसी क्लास बनाएं जो
SurfaceView
को बढ़ाती हो औरSurfaceHolder
इंटरफ़ेस को लागू करती हो. यह क्लास, कैमरे से ली गई लाइव इमेज की झलक दिखाती है. - झलक दिखाने वाला लेआउट बनाएं - कैमरे की झलक दिखाने वाली क्लास शुरू करने के बाद, व्यू लेआउट, जिसमें झलक और आपकी पसंद के यूज़र इंटरफ़ेस के कंट्रोल शामिल हैं.
- कैप्चर करने के लिए लिसनर सेटअप करें - अपने इंटरफ़ेस के लिए लिसनर कनेक्ट करें उपयोगकर्ता की कार्रवाइयों की प्रतिक्रिया में चित्र या वीडियो कैप्चर शुरू करने के लिए नियंत्रण, जैसे कि बटन.
- फ़ाइलों को कैप्चर करें और सेव करें - फ़ोटो कैप्चर करने के लिए कोड सेटअप करें या वीडियो और आउटपुट को सेव करना.
- कैमरे को रिलीज़ करना - कैमरे का इस्तेमाल करने के बाद, आपके ऐप्लिकेशन को उसे ठीक से रिलीज़ करना होगा, ताकि अन्य ऐप्लिकेशन उसका इस्तेमाल कर सकें.
कैमरा हार्डवेयर एक शेयर किया गया संसाधन है. इसे ध्यान से मैनेज करना ज़रूरी है, ताकि आपका ऐप्लिकेशन उन अन्य ऐप्लिकेशन से न टकराए जो इसका इस्तेमाल करना चाहते हैं. इन सेक्शन में, कैमरा हार्डवेयर का पता लगाने का तरीका, कैमरे के ऐक्सेस के लिए अनुरोध करने का तरीका, तस्वीरें या वीडियो कैप्चर करने का तरीका और जब आपके ऐप्लिकेशन में कैमरे का इस्तेमाल पूरा हो जाए, तो उसे कैसे रिलीज़ करें.
चेतावनी: Camera
को रिलीज़ करना न भूलें
तो Camera.release()
पर कॉल करके आपत्ति जताएं.
ऐप्लिकेशन में उसका उपयोग कर लिया जाता है! अगर आपका ऐप्लिकेशन कैमरे को सही तरीके से रिलीज़ नहीं करता है, तो कैमरे को ऐक्सेस करने की सभी कोशिशें विफल हो जाएंगी. इनमें आपके ऐप्लिकेशन की कोशिशें भी शामिल हैं. साथ ही, आपके या अन्य ऐप्लिकेशन बंद हो सकते हैं.
कैमरे के हार्डवेयर का पता लगाना
अगर आपके ऐप्लिकेशन को मेनिफ़ेस्ट एलान में बताए गए कैमरे की ज़रूरत नहीं है, तो आपको यह देखना चाहिए कि रनटाइम के दौरान कैमरा उपलब्ध है या नहीं. यह जांच करने के लिए, PackageManager.hasSystemFeature()
तरीके का इस्तेमाल करें, जैसा कि नीचे उदाहरण में दिए गए कोड में दिखाया गया है:
Kotlin
/** Check if this device has a camera */ private fun checkCameraHardware(context: Context): Boolean { if (context.packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)) { // this device has a camera return true } else { // no camera on this device return false } }
Java
/** Check if this device has a camera */ private boolean checkCameraHardware(Context context) { if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){ // this device has a camera return true; } else { // no camera on this device return false; } }
Android डिवाइसों में एक से ज़्यादा कैमरे हो सकते हैं. उदाहरण के लिए, फ़ोटोग्राफ़ी के लिए पीछे वाला कैमरा और
वीडियो कॉल के लिए सामने वाला कैमरा इस्तेमाल किया जा सकता है. Android 2.3 (एपीआई लेवल 9) और इसके बाद के वर्शन में आपको
Camera.getNumberOfCameras()
तरीके का इस्तेमाल करके, किसी डिवाइस में उपलब्ध कैमरों की संख्या.
कैमरे ऐक्सेस करना
यदि आपने पाया है कि जिस डिवाइस पर आपका ऐप्लिकेशन चल रहा है उसमें कैमरा है, तो
को Camera
का इंस्टेंस पाकर उसे ऐक्सेस करने का अनुरोध करना होगा (जब तक कि आप
कैमरे को ऐक्सेस करने के इंटेंट का इस्तेमाल कर रहे हों).
मुख्य कैमरा ऐक्सेस करने के लिए, Camera.open()
तरीका इस्तेमाल करें
और जैसा कि नीचे दिए गए कोड में दिखाया गया है, किसी अपवाद की जानकारी पाना न भूलें:
Kotlin
/** A safe way to get an instance of the Camera object. */ fun getCameraInstance(): Camera? { return try { Camera.open() // attempt to get a Camera instance } catch (e: Exception) { // Camera is not available (in use or does not exist) null // returns null if camera is unavailable } }
Java
/** A safe way to get an instance of the Camera object. */ public static Camera getCameraInstance(){ Camera c = null; try { c = Camera.open(); // attempt to get a Camera instance } catch (Exception e){ // Camera is not available (in use or does not exist) } return c; // returns null if camera is unavailable }
चेतावनी: Camera.open()
का इस्तेमाल करते समय हमेशा अपवादों की जांच करें. अगर कैमरे का इस्तेमाल किया जा रहा है या वह मौजूद नहीं है, तो अपवादों की जांच न करने पर, सिस्टम आपके ऐप्लिकेशन को बंद कर देगा.
Android 2.3 (एपीआई लेवल 9) या इसके बाद के वर्शन वाले डिवाइसों पर, Camera.open(int)
का इस्तेमाल करके कुछ कैमरों को ऐक्सेस किया जा सकता है. ऊपर दिया गया उदाहरण कोड, एक से ज़्यादा कैमरे वाले डिवाइस पर, पहला और पीछे वाला कैमरा ऐक्सेस करेगा.
कैमरे की सुविधाओं की जांच करना
कैमरे का ऐक्सेस मिलने के बाद, उसकी सुविधाओं के बारे में ज़्यादा जानकारी हासिल की जा सकती है
Camera.getParameters()
तरीका चुना जा सकता है और
काम करने वाली सुविधाओं के लिए, Camera.Parameters
ऑब्जेक्ट मिला. इसका इस्तेमाल करते समय
एपीआई लेवल 9 या उसके बाद का लेवल, Camera.getCameraInfo()
का इस्तेमाल करके यह पता करें कि कैमरा सामने की तरफ़ है या नहीं
और इमेज का ओरिएंटेशन.
टीज़र के तौर पर शॉर्ट वीडियो बनाने की क्लास बनाना
उपयोगकर्ताओं को बेहतर फ़ोटो या वीडियो लेने के लिए, यह ज़रूरी है कि वे डिवाइस के कैमरे से दिखने वाली चीज़ें देख पाएं. कैमरे की झलक दिखाने वाली क्लास एक SurfaceView
होती है, जो लाइव इमेज दिखा सकती है
डेटा इकट्ठा करना होता है, ताकि उपयोगकर्ता किसी तस्वीर या वीडियो को फ़्रेम और कैप्चर कर सकें.
नीचे दिए गए उदाहरण कोड में एक बेसिक कैमरा प्रीव्यू क्लास बनाने का तरीका बताया गया है. यह क्लास
View
लेआउट में शामिल है. यह क्लास, SurfaceHolder.Callback
को लागू करती है, ताकि कॉलबैक इवेंट कैप्चर किए जा सकें
व्यू बनाने और बंद करने के लिए, जो कैमरा प्रीव्यू इनपुट को असाइन करने के लिए ज़रूरी हैं.
Kotlin
/** A basic Camera preview class */ class CameraPreview( context: Context, private val mCamera: Camera ) : SurfaceView(context), SurfaceHolder.Callback { private val mHolder: SurfaceHolder = holder.apply { // Install a SurfaceHolder.Callback so we get notified when the // underlying surface is created and destroyed. addCallback(this@CameraPreview) // deprecated setting, but required on Android versions prior to 3.0 setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS) } override fun surfaceCreated(holder: SurfaceHolder) { // The Surface has been created, now tell the camera where to draw the preview. mCamera.apply { try { setPreviewDisplay(holder) startPreview() } catch (e: IOException) { Log.d(TAG, "Error setting camera preview: ${e.message}") } } } override fun surfaceDestroyed(holder: SurfaceHolder) { // empty. Take care of releasing the Camera preview in your activity. } override fun surfaceChanged(holder: SurfaceHolder, format: Int, w: Int, h: Int) { // If your preview can change or rotate, take care of those events here. // Make sure to stop the preview before resizing or reformatting it. if (mHolder.surface == null) { // preview surface does not exist return } // stop preview before making changes try { mCamera.stopPreview() } catch (e: Exception) { // ignore: tried to stop a non-existent preview } // set preview size and make any resize, rotate or // reformatting changes here // start preview with new settings mCamera.apply { try { setPreviewDisplay(mHolder) startPreview() } catch (e: Exception) { Log.d(TAG, "Error starting camera preview: ${e.message}") } } } }
Java
/** A basic Camera preview class */ public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback { private SurfaceHolder mHolder; private Camera mCamera; public CameraPreview(Context context, Camera camera) { super(context); mCamera = camera; // Install a SurfaceHolder.Callback so we get notified when the // underlying surface is created and destroyed. mHolder = getHolder(); mHolder.addCallback(this); // deprecated setting, but required on Android versions prior to 3.0 mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); } public void surfaceCreated(SurfaceHolder holder) { // The Surface has been created, now tell the camera where to draw the preview. try { mCamera.setPreviewDisplay(holder); mCamera.startPreview(); } catch (IOException e) { Log.d(TAG, "Error setting camera preview: " + e.getMessage()); } } public void surfaceDestroyed(SurfaceHolder holder) { // empty. Take care of releasing the Camera preview in your activity. } public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { // If your preview can change or rotate, take care of those events here. // Make sure to stop the preview before resizing or reformatting it. if (mHolder.getSurface() == null){ // preview surface does not exist return; } // stop preview before making changes try { mCamera.stopPreview(); } catch (Exception e){ // ignore: tried to stop a non-existent preview } // set preview size and make any resize, rotate or // reformatting changes here // start preview with new settings try { mCamera.setPreviewDisplay(mHolder); mCamera.startPreview(); } catch (Exception e){ Log.d(TAG, "Error starting camera preview: " + e.getMessage()); } } }
अगर आपको कैमरे की झलक के लिए कोई खास साइज़ सेट करना है, तो ऊपर दी गई टिप्पणियों में बताए गए surfaceChanged()
तरीके से ऐसा करें. झलक का साइज़ सेट करते समय,
getSupportedPreviewSizes()
के मानों का इस्तेमाल करना चाहिए.
setPreviewSize()
तरीके में आर्बिट्रेरी वैल्यू सेट न करें.
ध्यान दें:
Android 7.0 (एपीआई लेवल 24) और इसके बाद के वर्शन में,
मल्टी-विंडो सुविधा के लॉन्च होने के बाद, setDisplayOrientation()
को कॉल करने के बाद भी, यह नहीं माना जा सकता कि झलक का आसपेक्ट रेशियो, आपकी गतिविधि के आसपेक्ट रेशियो जैसा ही है.
विंडो के साइज़ और आसपेक्ट रेशियो के आधार पर, आपको वाइड कैमरे की झलक को पोर्ट्रेट लेआउट में फ़िट करना पड़ सकता है. इसके अलावा, लेटरबॉक्स लेआउट का इस्तेमाल करके, पोर्ट्रेट लेआउट को वाइड कैमरे की झलक में फ़िट किया जा सकता है.
लेआउट में झलक डालना
पिछले सेक्शन में दिए गए उदाहरण की तरह, कैमरे की झलक दिखाने वाली क्लास को किसी गतिविधि का लेआउट और तस्वीर या वीडियो लेने के लिए, अन्य यूज़र इंटरफ़ेस कंट्रोल. यह सेक्शन में झलक के लिए बुनियादी लेआउट और गतिविधि बनाने का तरीका बताया गया है.
नीचे दिया गया लेआउट कोड एक बुनियादी व्यू देता है. इसका इस्तेमाल कैमरा दिखाने के लिए किया जा सकता है
झलक देखें. इस उदाहरण में, FrameLayout
एलिमेंट का मतलब कैमरे की झलक दिखाने वाली क्लास के लिए कंटेनर है. इस तरह के लेआउट का इस्तेमाल इसलिए किया जाता है, ताकि लाइव कैमरे की झलक दिखाने वाली इमेज पर, फ़ोटो की अतिरिक्त जानकारी या कंट्रोल ओवरले किए जा सकें.
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="fill_parent" > <FrameLayout android:id="@+id/camera_preview" android:layout_width="fill_parent" android:layout_height="fill_parent" android:layout_weight="1" /> <Button android:id="@+id/button_capture" android:text="Capture" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" /> </LinearLayout>
ज़्यादातर डिवाइसों पर, कैमरे की झलक का डिफ़ॉल्ट ओरिएंटेशन लैंडस्केप होता है. उदाहरण के तौर पर यह लेआउट हॉरिज़ॉन्टल (लैंडस्केप) लेआउट तय करता है और नीचे दिया गया कोड, को लैंडस्केप मोड में सेट करने की सुविधा मिलती है. कैमरा प्रीव्यू को आसानी से रेंडर करने के लिए, आपको अपने मेनिफ़ेस्ट.
<activity android:name=".CameraActivity" android:label="@string/app_name" android:screenOrientation="landscape"> <!-- configure this activity to use landscape orientation --> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity>
ध्यान दें: कैमरे की झलक, लैंडस्केप मोड में होनी ज़रूरी नहीं है.
Android 2.2 (एपीआई लेवल 8) से शुरू होने वाले, setDisplayOrientation()
तरीके का इस्तेमाल करके,
झलक वाली इमेज का रोटेशन. उपयोगकर्ता के ओरिएंटेशन में बदलाव करने के लिए,
फ़ोन पर, अपनी प्रीव्यू क्लास की surfaceChanged()
विधि में, Camera.stopPreview()
का ओरिएंटेशन बदलकर पहले पूर्वावलोकन को रोकें और फिर
Camera.startPreview()
के साथ झलक देखना फिर से शुरू करें.
अपने कैमरे व्यू की गतिविधि में, ऊपर दिए गए उदाहरण में दिखाए गए FrameLayout
एलिमेंट में अपनी झलक वाली क्लास जोड़ें. कैमरे की गतिविधि से जुड़े डेटा को भी ध्यान में रखना ज़रूरी है
पक्का करें कि कैमरे को रोकने या बंद करने पर यह उसे छोड़ दे. नीचे दिए गए उदाहरण में बताया गया है कि
का इस्तेमाल करके, कैमरा गतिविधि में बदलाव किया जा सकता है, ताकि बनाई जा रही
क्लास की झलक.
Kotlin
class CameraActivity : Activity() { private var mCamera: Camera? = null private var mPreview: CameraPreview? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // Create an instance of Camera mCamera = getCameraInstance() mPreview = mCamera?.let { // Create our Preview view CameraPreview(this, it) } // Set the Preview view as the content of our activity. mPreview?.also { val preview: FrameLayout = findViewById(R.id.camera_preview) preview.addView(it) } } }
Java
public class CameraActivity extends Activity { private Camera mCamera; private CameraPreview mPreview; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Create an instance of Camera mCamera = getCameraInstance(); // Create our Preview view and set it as the content of our activity. mPreview = new CameraPreview(this, mCamera); FrameLayout preview = (FrameLayout) findViewById(R.id.camera_preview); preview.addView(mPreview); } }
ध्यान दें: ऊपर दिए गए उदाहरण में getCameraInstance()
का तरीका, कैमरे ऐक्सेस करना में दिए गए उदाहरण के तरीके से मेल खाता है.
तस्वीरें खींची जा रही हैं
झलक दिखाने के लिए, झलक वाली क्लास और व्यू लेआउट बनाने के बाद, अपने ऐप्लिकेशन से इमेज कैप्चर करना शुरू किया जा सकता है. अपने ऐप्लिकेशन कोड में, आपको लिसनर सेट अप करने होंगे का इस्तेमाल, उपयोगकर्ता की कार्रवाई पर प्रतिक्रिया देने के लिए किया जा सकता है.
किसी तस्वीर को वापस पाने के लिए, Camera.takePicture()
तरीके का इस्तेमाल करें. इस तरीके में तीन पैरामीटर होते हैं, जिन्हें कैमरे से डेटा मिलता है.
डेटा को JPEG फ़ॉर्मैट में पाने के लिए, आपको इमेज डेटा पाने और उसे फ़ाइल में लिखने के लिए, Camera.PictureCallback
इंटरफ़ेस लागू करना होगा. यहां दिया गया कोड, कैमरे से मिली इमेज को सेव करने के लिए, Camera.PictureCallback
इंटरफ़ेस को बुनियादी तौर पर लागू करने का तरीका दिखाता है.
Kotlin
private val mPicture = Camera.PictureCallback { data, _ -> val pictureFile: File = getOutputMediaFile(MEDIA_TYPE_IMAGE) ?: run { Log.d(TAG, ("Error creating media file, check storage permissions")) return@PictureCallback } try { val fos = FileOutputStream(pictureFile) fos.write(data) fos.close() } catch (e: FileNotFoundException) { Log.d(TAG, "File not found: ${e.message}") } catch (e: IOException) { Log.d(TAG, "Error accessing file: ${e.message}") } }
Java
private PictureCallback mPicture = new PictureCallback() { @Override public void onPictureTaken(byte[] data, Camera camera) { File pictureFile = getOutputMediaFile(MEDIA_TYPE_IMAGE); if (pictureFile == null){ Log.d(TAG, "Error creating media file, check storage permissions"); return; } try { FileOutputStream fos = new FileOutputStream(pictureFile); fos.write(data); fos.close(); } catch (FileNotFoundException e) { Log.d(TAG, "File not found: " + e.getMessage()); } catch (IOException e) { Log.d(TAG, "Error accessing file: " + e.getMessage()); } } };
Camera.takePicture()
तरीके को कॉल करके इमेज कैप्चर करने वाला ट्रिगर. यहां दिए गए उदाहरण में, बटन View.OnClickListener
से इस तरीके को कॉल करने का तरीका बताया गया है.
Kotlin
val captureButton: Button = findViewById(R.id.button_capture) captureButton.setOnClickListener { // get an image from the camera mCamera?.takePicture(null, null, picture) }
Java
// Add a listener to the Capture button Button captureButton = (Button) findViewById(R.id.button_capture); captureButton.setOnClickListener( new View.OnClickListener() { @Override public void onClick(View v) { // get an image from the camera mCamera.takePicture(null, null, picture); } } );
ध्यान दें: इस उदाहरण में, mPicture
सदस्य के बारे में बताया गया है
ऊपर दिए गए उदाहरण कोड में.
चेतावनी: जब आपका ऐप्लिकेशन Camera
ऑब्जेक्ट का इस्तेमाल कर ले, तो Camera.release()
को कॉल करके उसे रिलीज़ करना न भूलें! कैमरे को रिलीज़ करने के तरीके के बारे में जानकारी के लिए, कैमरा छोड़ना देखें.
वीडियो रिकॉर्ड करना
Android फ़्रेमवर्क का इस्तेमाल करके वीडियो कैप्चर करने के लिए, Camera
ऑब्जेक्ट को सावधानी से मैनेज करने और MediaRecorder
के साथ तालमेल बिठाने की ज़रूरत होती है
क्लास. Camera
के साथ वीडियो रिकॉर्ड करते समय, आपको Camera.lock()
और Camera.unlock()
कॉल को मैनेज करना होगा, ताकि MediaRecorder
को कैमरा हार्डवेयर का ऐक्सेस दिया जा सके.
ये कॉल, Camera.open()
और Camera.release()
कॉल के अलावा दिखेंगे.
ध्यान दें: Android 4.0 (एपीआई लेवल 14) और इसके बाद के वर्शन में, Camera.lock()
और Camera.unlock()
कॉल अपने-आप मैनेज होते हैं.
किसी डिवाइस के कैमरे से फ़ोटो लेने के उलट, वीडियो कैप्चर करने के लिए एक खास तरह की कॉल की ज़रूरत होती है ऑर्डर. अपने ऐप्लिकेशन के साथ वीडियो रिकॉर्ड करने और उसे तैयार करने के लिए, आपको नीचे बताए गए क्रम का पालन करना होगा.
- कैमरा खोलें -
Camera.open()
का इस्तेमाल करें का इस्तेमाल करें. - झलक दिखाने वाला कनेक्शन -
Camera.setPreviewDisplay()
का इस्तेमाल करके,SurfaceView
को कैमरे से कनेक्ट करके, लाइव कैमरे की इमेज की झलक तैयार करें. - झलक देखें - कैमरे की लाइव इमेज दिखाने के लिए,
Camera.startPreview()
पर कॉल करें. - वीडियो रिकॉर्ड करना शुरू करना - वीडियो रिकॉर्ड करने के लिए, यह तरीका इसी क्रम में अपनाएं:
- कैमरे को अनलॉक करना -
Camera.unlock()
बोलकर,MediaRecorder
के लिए कैमरे को अनलॉक करें. - MediaRecorder को कॉन्फ़िगर करना -
MediaRecorder
इन तरीकों को इस क्रम में कॉल करें. ज़्यादा जानकारी के लिए,MediaRecorder
का रेफ़रंस दस्तावेज़ देखें.setCamera()
- वीडियो कैप्चर करने के लिए कैमरा सेट करें. इसके लिए, अपने ऐप्लिकेशन केCamera
के मौजूदा इंस्टेंस का इस्तेमाल करें.setAudioSource()
- ऑडियो सोर्स सेट करने के लिए,MediaRecorder.AudioSource.CAMCORDER
का इस्तेमाल करें.setVideoSource()
- सेट वीडियो सोर्स,MediaRecorder.VideoSource.CAMERA
का इस्तेमाल करें.- वीडियो के आउटपुट का फ़ॉर्मैट और कोड में बदलने का तरीका सेट करें. Android 2.2 (एपीआई लेवल 8) और
बड़ा करने के लिए,
MediaRecorder.setProfile
तरीके का इस्तेमाल करें औरCamcorderProfile.get()
का इस्तेमाल करके प्रोफ़ाइल इंस्टेंस पाएं. Android के 2.2 से पहले के वर्शन के लिए, आपको वीडियो आउटपुट फ़ॉर्मैट और एन्कोडिंग पैरामीटर सेट करने होंगे:setOutputFormat()
- आउटपुट फ़ॉर्मैट सेट करें, डिफ़ॉल्ट सेटिंग याMediaRecorder.OutputFormat.MPEG_4
तय करें.setAudioEncoder()
- सेट साउंड एन्कोडिंग टाइप, डिफ़ॉल्ट सेटिंग तय करें याMediaRecorder.AudioEncoder.AMR_NB
.setVideoEncoder()
- सेट वीडियो एन्कोडिंग टाइप, डिफ़ॉल्ट सेटिंग तय करें याMediaRecorder.VideoEncoder.MPEG_4_SP
.
setOutputFile()
से आउटपुट फ़ाइल सेट करें. इसके बाद, उदाहरण में बताए गएgetOutputMediaFile(MEDIA_TYPE_VIDEO).toString()
का इस्तेमाल करें तरीका चुनने के लिए, मीडिया फ़ाइलें सेव करना सेक्शन में जाना होगा.setPreviewDisplay()
- अपने ऐप्लिकेशन के लिए,SurfaceView
झलक वाला लेआउट एलिमेंट तय करें. उसी ऑब्जेक्ट का इस्तेमाल करें जिसे आपने Connect की झलक के लिए बताया था.
चेतावनी: आपको
MediaRecorder
कॉन्फ़िगरेशन के इन तरीकों को इस क्रम में कॉल करना होगा. ऐसा न करने पर, आपके ऐप्लिकेशन में गड़बड़ियां होंगी और रिकॉर्डिंग नहीं हो पाएगी. - MediaRecorder को तैयार करना -
MediaRecorder.prepare()
को कॉल करके, दी गई कॉन्फ़िगरेशन सेटिंग के साथMediaRecorder
को तैयार करें. - MediaRecorder शुरू करें -
MediaRecorder.start()
को कॉल करके वीडियो रिकॉर्ड करना शुरू करें.
- कैमरे को अनलॉक करना -
- वीडियो रिकॉर्ड करना बंद करें - नीचे दिए गए तरीकों को क्रम में कॉल करें
वीडियो रिकॉर्डिंग पूरी करें:
- MediaRecorder बंद करना -
MediaRecorder.stop()
को कॉल करके वीडियो रिकॉर्डिंग बंद करें. - MediaRecorder को रीसेट करें - विकल्प के तौर पर, यहां से कॉन्फ़िगरेशन सेटिंग हटाएं
MediaRecorder.reset()
पर कॉल करके रिकॉर्डर को ऐक्सेस किया जा सकता है. - MediaRecorder को रिलीज़ करना -
MediaRecorder.release()
को कॉल करकेMediaRecorder
को रिलीज़ करें. - कैमरा लॉक करें - कैमरा लॉक करें, ताकि आने वाले समय में
MediaRecorder
सेशन में,Camera.lock()
पर कॉल करके इसे इस्तेमाल किया जा सके. Android 4.0 (एपीआई लेवल 14) से शुरू होने वाले वर्शन के लिए, इस कॉल की ज़रूरत तब तक नहीं पड़ती, जब तकMediaRecorder.prepare()
कॉल नहीं हुआ.
- MediaRecorder बंद करना -
- झलक देखना बंद करें - जब कैमरे का इस्तेमाल करके आपकी गतिविधि पूरी हो जाए, तो
Camera.stopPreview()
का इस्तेमाल करके झलक देखें. - कैमरा रिलीज़ करें - कैमरे को छोड़ दें, ताकि दूसरे ऐप्लिकेशन इस्तेमाल कर सकें
Camera.release()
पर कॉल करके इसे खोजें.
ध्यान दें: MediaRecorder
का इस्तेमाल किया जा सकता है
इसके लिए, उन्हें कैमरा प्रीव्यू बनाया जा सकता है और इस प्रोसेस के शुरुआती कुछ चरणों को छोड़ दिया जाता है. हालांकि,
क्योंकि उपयोगकर्ता आम तौर पर रिकॉर्डिंग शुरू करने से पहले झलक देखना पसंद करते हैं, इसलिए यह प्रक्रिया
यहां चर्चा की गई है.
सलाह: अगर आपके ऐप्लिकेशन का इस्तेमाल आम तौर पर वीडियो रिकॉर्ड करने के लिए किया जाता है, तो झलक देखने से पहले setRecordingHint(boolean)
को true
पर सेट करें. इस सेटिंग की मदद से, रिकॉर्डिंग शुरू होने में लगने वाला समय कम किया जा सकता है.
MediaRecorder को कॉन्फ़िगर करना
वीडियो रिकॉर्ड करने के लिए MediaRecorder
क्लास का इस्तेमाल करते समय, आपको कॉन्फ़िगरेशन के चरणों को किसी खास क्रम में पूरा करना होगा. इसके बाद, कॉन्फ़िगरेशन की जांच करने और उसे लागू करने के लिए, MediaRecorder.prepare()
तरीके को कॉल करें. उदाहरण के तौर पर दिया गया यह कोड, रिपोर्ट को सही तरीके से कॉन्फ़िगर और तैयार करने का तरीका बताता है
वीडियो रिकॉर्डिंग के लिए MediaRecorder
क्लास.
Kotlin
private fun prepareVideoRecorder(): Boolean { mediaRecorder = MediaRecorder() mCamera?.let { camera -> // Step 1: Unlock and set camera to MediaRecorder camera?.unlock() mediaRecorder?.run { setCamera(camera) // Step 2: Set sources setAudioSource(MediaRecorder.AudioSource.CAMCORDER) setVideoSource(MediaRecorder.VideoSource.CAMERA) // Step 3: Set a CamcorderProfile (requires API Level 8 or higher) setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH)) // Step 4: Set output file setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString()) // Step 5: Set the preview output setPreviewDisplay(mPreview?.holder?.surface) setOutputFormat(MediaRecorder.OutputFormat.MPEG_4) setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT) setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT) // Step 6: Prepare configured MediaRecorder return try { prepare() true } catch (e: IllegalStateException) { Log.d(TAG, "IllegalStateException preparing MediaRecorder: ${e.message}") releaseMediaRecorder() false } catch (e: IOException) { Log.d(TAG, "IOException preparing MediaRecorder: ${e.message}") releaseMediaRecorder() false } } } return false }
Java
private boolean prepareVideoRecorder(){ mCamera = getCameraInstance(); mediaRecorder = new MediaRecorder(); // Step 1: Unlock and set camera to MediaRecorder mCamera.unlock(); mediaRecorder.setCamera(mCamera); // Step 2: Set sources mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER); mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); // Step 3: Set a CamcorderProfile (requires API Level 8 or higher) mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH)); // Step 4: Set output file mediaRecorder.setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString()); // Step 5: Set the preview output mediaRecorder.setPreviewDisplay(mPreview.getHolder().getSurface()); // Step 6: Prepare configured MediaRecorder try { mediaRecorder.prepare(); } catch (IllegalStateException e) { Log.d(TAG, "IllegalStateException preparing MediaRecorder: " + e.getMessage()); releaseMediaRecorder(); return false; } catch (IOException e) { Log.d(TAG, "IOException preparing MediaRecorder: " + e.getMessage()); releaseMediaRecorder(); return false; } return true; }
Android 2.2 (एपीआई लेवल 8) से पहले के वर्शन में, आपको आउटपुट फ़ॉर्मैट और कोड में बदलने के फ़ॉर्मैट सेट करने होंगे
CamcorderProfile
का इस्तेमाल करने के बजाय सीधे पैरामीटर का इस्तेमाल करें. यह तरीका,
इस कोड में दिखाया गया है:
Kotlin
// Step 3: Set output format and encoding (for versions prior to API Level 8) mediaRecorder?.apply { setOutputFormat(MediaRecorder.OutputFormat.MPEG_4) setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT) setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT) }
Java
// Step 3: Set output format and encoding (for versions prior to API Level 8) mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT); mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT);
MediaRecorder
के लिए, वीडियो रिकॉर्डिंग के ये पैरामीटर डिफ़ॉल्ट सेटिंग के तौर पर दिए गए हैं. हालांकि, अपने ऐप्लिकेशन के लिए इन सेटिंग में बदलाव किया जा सकता है:
setVideoEncodingBitRate()
setVideoSize()
setVideoFrameRate()
setAudioEncodingBitRate()
setAudioChannels()
setAudioSamplingRate()
MediaRecorder को चालू और बंद करना
MediaRecorder
क्लास का इस्तेमाल करके वीडियो रिकॉर्डिंग शुरू और बंद करते समय, आपको नीचे दिए गए क्रम का पालन करना होगा.
Camera.unlock()
से कैमरे को अनलॉक करना- ऊपर दिए गए कोड के उदाहरण में दिखाए गए तरीके से
MediaRecorder
को कॉन्फ़िगर करें MediaRecorder.start()
का इस्तेमाल करके रिकॉर्डिंग शुरू करना- वीडियो रिकॉर्ड करें
MediaRecorder.stop()
का इस्तेमाल करके रिकॉर्डिंग बंद करनाMediaRecorder.release()
का इस्तेमाल करके मीडिया रिकॉर्डर रिलीज़ करेंCamera.lock()
का इस्तेमाल करके कैमरा लॉक करें
नीचे दिए गए उदाहरण में, कैमरे और MediaRecorder
क्लास का इस्तेमाल करके, वीडियो रिकॉर्डिंग को सही तरीके से शुरू और बंद करने के लिए, बटन को जोड़ने का तरीका बताया गया है.
ध्यान दें: वीडियो रिकॉर्डिंग पूरी करते समय, कैमरे को न छोड़ें ऐसा न करने पर, झलक बंद हो जाएगी.
Kotlin
var isRecording = false val captureButton: Button = findViewById(R.id.button_capture) captureButton.setOnClickListener { if (isRecording) { // stop recording and release camera mediaRecorder?.stop() // stop the recording releaseMediaRecorder() // release the MediaRecorder object mCamera?.lock() // take camera access back from MediaRecorder // inform the user that recording has stopped setCaptureButtonText("Capture") isRecording = false } else { // initialize video camera if (prepareVideoRecorder()) { // Camera is available and unlocked, MediaRecorder is prepared, // now you can start recording mediaRecorder?.start() // inform the user that recording has started setCaptureButtonText("Stop") isRecording = true } else { // prepare didn't work, release the camera releaseMediaRecorder() // inform user } } }
Java
private boolean isRecording = false; // Add a listener to the Capture button Button captureButton = (Button) findViewById(id.button_capture); captureButton.setOnClickListener( new View.OnClickListener() { @Override public void onClick(View v) { if (isRecording) { // stop recording and release camera mediaRecorder.stop(); // stop the recording releaseMediaRecorder(); // release the MediaRecorder object mCamera.lock(); // take camera access back from MediaRecorder // inform the user that recording has stopped setCaptureButtonText("Capture"); isRecording = false; } else { // initialize video camera if (prepareVideoRecorder()) { // Camera is available and unlocked, MediaRecorder is prepared, // now you can start recording mediaRecorder.start(); // inform the user that recording has started setCaptureButtonText("Stop"); isRecording = true; } else { // prepare didn't work, release the camera releaseMediaRecorder(); // inform user } } } } );
ध्यान दें: ऊपर दिए गए उदाहरण में, prepareVideoRecorder()
तरीका का मतलब MediaRecorder को कॉन्फ़िगर करने में दिखाए गए उदाहरण कोड से है. इस तरीके से
MediaRecorder
इंस्टेंस को कॉन्फ़िगर और तैयार करते हुए कैमरा.
कैमरे को रिलीज़ करना
कैमरा एक ऐसा संसाधन है जिसे डिवाइस पर मौजूद ऐप्लिकेशन की मदद से शेयर किया जाता है. आपका ऐप्लिकेशन ये काम कर सकता है:
Camera
का इंस्टेंस मिलने के बाद कैमरे का इस्तेमाल करना होगा. आपको यह मुमकिन है कि आपको
खास तौर पर, कैमरा ऑब्जेक्ट को उस समय रिलीज़ करने से बचें, जब ऐप्लिकेशन इसका इस्तेमाल बंद कर दे. साथ ही,
ध्यान दें कि आपका ऐप्लिकेशन रोका गया है (Activity.onPause()
). अगर आपने
आपका ऐप्लिकेशन सही तरीके से कैमरे को रिलीज़ नहीं करता है, कैमरे को ऐक्सेस करने की सभी कोशिशें की जाती हैं,
उनके आवेदन को प्रोसेस नहीं किया जा सकेगा और आपके या दूसरे ऐप्लिकेशन के
शट डाउन करें.
Camera
ऑब्जेक्ट के किसी इंस्टेंस को रिलीज़ करने के लिए, Camera.release()
तरीके का इस्तेमाल करें, जैसा कि नीचे उदाहरण कोड में दिखाया गया है.
Kotlin
class CameraActivity : Activity() { private var mCamera: Camera? private var preview: SurfaceView? private var mediaRecorder: MediaRecorder? override fun onPause() { super.onPause() releaseMediaRecorder() // if you are using MediaRecorder, release it first releaseCamera() // release the camera immediately on pause event } private fun releaseMediaRecorder() { mediaRecorder?.reset() // clear recorder configuration mediaRecorder?.release() // release the recorder object mediaRecorder = null mCamera?.lock() // lock camera for later use } private fun releaseCamera() { mCamera?.release() // release the camera for other applications mCamera = null } }
Java
public class CameraActivity extends Activity { private Camera mCamera; private SurfaceView preview; private MediaRecorder mediaRecorder; ... @Override protected void onPause() { super.onPause(); releaseMediaRecorder(); // if you are using MediaRecorder, release it first releaseCamera(); // release the camera immediately on pause event } private void releaseMediaRecorder(){ if (mediaRecorder != null) { mediaRecorder.reset(); // clear recorder configuration mediaRecorder.release(); // release the recorder object mediaRecorder = null; mCamera.lock(); // lock camera for later use } } private void releaseCamera(){ if (mCamera != null){ mCamera.release(); // release the camera for other applications mCamera = null; } } }
चेतावनी: अगर आपका ऐप्लिकेशन कैमरे को सही तरीके से रिलीज़ नहीं करता है, तो कैमरे को ऐक्सेस करने की सभी कोशिशें विफल हो जाएंगी. इनमें आपके ऐप्लिकेशन की कोशिशें भी शामिल हैं. इससे आपका या अन्य ऐप्लिकेशन बंद हो सकता है.
मीडिया फ़ाइलें सेव करना
उपयोगकर्ताओं की बनाई गई फ़ोटो और वीडियो जैसी मीडिया फ़ाइलों को डिवाइस के स्टोरेज में सेव किया जाना चाहिए स्टोरेज डायरेक्ट्री (एसडी कार्ड) का इस्तेमाल, सिस्टम में जगह बचाने और उपयोगकर्ताओं को इन फ़ाइलों को ऐक्सेस करने की अनुमति देने के लिए किया जाता है जा सकता है. किसी डिवाइस पर मीडिया फ़ाइलों को सेव करने के लिए, कई डायरेक्ट्री लोकेशन हो सकती हैं, हालांकि, डेवलपर के तौर पर आपको सिर्फ़ दो स्टैंडर्ड जगहों पर ध्यान देना चाहिए:
Environment.getExternalStoragePublicDirectory
(Environment.DIRECTORY_PICTURES
) - यह तरीका, शेयर किए गए, सुझाए गए, और स्टैंडर्ड फ़ॉर्मैट वाले नतीजे दिखाता है तस्वीरें और वीडियो सेव करने के लिए जगह. यह डायरेक्ट्री शेयर की जाती है (सार्वजनिक), ताकि अन्य ऐप्लिकेशन इस जगह पर सेव की गई फ़ाइलों को आसानी से ढूंढ सकें, पढ़ सकें, उनमें बदलाव कर सकें, और उन्हें मिटा सकें. अगर उपयोगकर्ता आपके ऐप्लिकेशन को डिइंस्टॉल कर देता है, तो इस जगह पर सेव की गई मीडिया फ़ाइलें नहीं हटाई जाएंगी. इससे बचने के लिए उपयोगकर्ताओं की मौजूदा तस्वीरों और वीडियो के काम में रुकावट डालने के लिए, आपको अपने ऐप्लिकेशन की मीडिया फ़ाइलें इस निर्देशिका में मौजूद होती हैं, जैसा कि नीचे कोड नमूने में दिखाया गया है. यह तरीका, Android 2.2 (एपीआई लेवल 8) में उपलब्ध है. एपीआई के पुराने वर्शन में मिलते-जुलते कॉल के लिए, शेयर की गई फ़ाइलें सेव करना देखें.Context.getExternalFilesDir
(Environment.DIRECTORY_PICTURES
) - यह तरीका, आपके ऐप्लिकेशन से जुड़ी तस्वीरों और वीडियो को सेव करने के लिए, स्टैंडर्ड लोकेशन दिखाता है. अगर आपका ऐप्लिकेशन अनइंस्टॉल किया जाता है, तो इस जगह पर सेव की गई सभी फ़ाइलें हटा दी जाती हैं. इस जगह पर मौजूद फ़ाइलों को सुरक्षित नहीं किया जाता. साथ ही, अन्य ऐप्लिकेशन उन्हें पढ़ सकते हैं, उनमें बदलाव कर सकते हैं, और उन्हें मिटा सकते हैं.
नीचे दिया गया उदाहरण कोड उस मीडिया फ़ाइल के लिए File
या Uri
की जगह की जानकारी बनाने का तरीका बताता है जिसका इस्तेमाल डिवाइस के कैमरे को चालू करते समय किया जा सकता है
Intent
या कैमरा बनाने के लिए
ऐप्लिकेशन.
Kotlin
val MEDIA_TYPE_IMAGE = 1 val MEDIA_TYPE_VIDEO = 2 /** Create a file Uri for saving an image or video */ private fun getOutputMediaFileUri(type: Int): Uri { return Uri.fromFile(getOutputMediaFile(type)) } /** Create a File for saving an image or video */ private fun getOutputMediaFile(type: Int): File? { // To be safe, you should check that the SDCard is mounted // using Environment.getExternalStorageState() before doing this. val mediaStorageDir = File( Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "MyCameraApp" ) // This location works best if you want the created images to be shared // between applications and persist after your app has been uninstalled. // Create the storage directory if it does not exist mediaStorageDir.apply { if (!exists()) { if (!mkdirs()) { Log.d("MyCameraApp", "failed to create directory") return null } } } // Create a media file name val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date()) return when (type) { MEDIA_TYPE_IMAGE -> { File("${mediaStorageDir.path}${File.separator}IMG_$timeStamp.jpg") } MEDIA_TYPE_VIDEO -> { File("${mediaStorageDir.path}${File.separator}VID_$timeStamp.mp4") } else -> null } }
Java
public static final int MEDIA_TYPE_IMAGE = 1; public static final int MEDIA_TYPE_VIDEO = 2; /** Create a file Uri for saving an image or video */ private static Uri getOutputMediaFileUri(int type){ return Uri.fromFile(getOutputMediaFile(type)); } /** Create a File for saving an image or video */ private static File getOutputMediaFile(int type){ // To be safe, you should check that the SDCard is mounted // using Environment.getExternalStorageState() before doing this. File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory( Environment.DIRECTORY_PICTURES), "MyCameraApp"); // This location works best if you want the created images to be shared // between applications and persist after your app has been uninstalled. // Create the storage directory if it does not exist if (! mediaStorageDir.exists()){ if (! mediaStorageDir.mkdirs()){ Log.d("MyCameraApp", "failed to create directory"); return null; } } // Create a media file name String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); File mediaFile; if (type == MEDIA_TYPE_IMAGE){ mediaFile = new File(mediaStorageDir.getPath() + File.separator + "IMG_"+ timeStamp + ".jpg"); } else if(type == MEDIA_TYPE_VIDEO) { mediaFile = new File(mediaStorageDir.getPath() + File.separator + "VID_"+ timeStamp + ".mp4"); } else { return null; } return mediaFile; }
ध्यान दें: Environment.getExternalStoragePublicDirectory()
, Android 2.2 (एपीआई लेवल 8) या इसके बाद के वर्शन में उपलब्ध है. अगर Android के पुराने वर्शन वाले डिवाइसों को टारगेट किया जा रहा है, तो इसके बजाय Environment.getExternalStorageDirectory()
का इस्तेमाल करें. ज़्यादा जानकारी के लिए, शेयर की गई फ़ाइलें सेव करना देखें.
यूआरआई को वर्क प्रोफ़ाइल के साथ काम करने लायक बनाने के लिए, पहले
फ़ाइल यूआरआई को कॉन्टेंट यूआरआई में बदलें. इसके बाद, कॉन्टेंट यूआरआई को इसमें जोड़ें
EXTRA_OUTPUT
Intent
में से.
किसी Android डिवाइस पर फ़ाइलें सेव करने के बारे में ज़्यादा जानकारी के लिए, डेटा स्टोरेज देखें.
कैमरे की सुविधाएं
Android, कैमरे की कई सुविधाओं के साथ काम करता है. इन्हें कैमरा ऐप्लिकेशन से कंट्रोल किया जा सकता है. जैसे, फ़ोटो फ़ॉर्मैट, फ़्लैश मोड, फ़ोकस सेटिंग वगैरह. इस सेक्शन में
और उन्हें इस्तेमाल करने के तरीक़े के बारे में संक्षेप में चर्चा करता है. कैमरे की ज़्यादातर सुविधाओं को ऐक्सेस और सेट किया जा सकता है
Camera.Parameters
ऑब्जेक्ट का इस्तेमाल करके. हालांकि, ऐसे कई तरीके हैं
अहम सुविधाएं शामिल हैं, जिनके लिए Camera.Parameters
में सामान्य सेटिंग से ज़्यादा की ज़रूरत होती है. इन सुविधाओं के बारे में नीचे दिए गए सेक्शन में बताया गया है:
Camera.Parameters
से कंट्रोल की जाने वाली सुविधाओं को इस्तेमाल करने के तरीके के बारे में सामान्य जानकारी के लिए, कैमरे की सुविधाओं का इस्तेमाल करना सेक्शन देखें. कैमरा पैरामीटर ऑब्जेक्ट की मदद से कंट्रोल की जाने वाली सुविधाओं को इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, सुविधाओं की सूची में दिए गए लिंक पर क्लिक करके, एपीआई के रेफ़रंस दस्तावेज़ पर जाएं.
टेबल 1. कैमरे की सामान्य सुविधाओं को Android एपीआई लेवल के हिसाब से क्रम में लगाया जाता है. पेश किए गए थे.
सुविधा | एपीआई लेवल | ब्यौरा |
---|---|---|
चेहरे की पहचान | 14 | किसी फ़ोटो में मौजूद लोगों के चेहरों की पहचान करना और फ़ोकस, मेज़रमेंट, और व्हाइट बैलेंस के लिए उनका इस्तेमाल करना |
मीटरिंग के इलाके | 14 | श्वेत संतुलन की गणना करने के लिए चित्र में एक या उससे ज़्यादा क्षेत्र बताएं |
ध्यान देने वाली बातें | 14 | फ़ोकस के लिए इस्तेमाल करने के लिए, इमेज में एक या उससे ज़्यादा हिस्से सेट करना |
White Balance Lock |
14 | व्हाइट बैलेंस में अपने-आप होने वाले बदलावों को रोकना या चालू करना |
Exposure Lock |
14 | एक्सपोज़र में अपने-आप होने वाले बदलावों को रोकना या शुरू करना |
Video Snapshot |
14 | वीडियो शूट करते समय एक तस्वीर लें (फ़्रेम ग्रैब) |
टाइम लैप्स वीडियो | 11 | टाइम लैप्स वाले वीडियो को रिकॉर्ड करने के लिए, तय समय के साथ फ़्रेम रिकॉर्ड करें |
Multiple Cameras |
9 | डिवाइस में एक से ज़्यादा कैमरे होने चाहिए. इनमें सामने और पीछे के कैमरे भी शामिल हैं |
Focus Distance |
9 | इससे कैमरे और फ़ोकस में दिख रहे ऑब्जेक्ट के बीच की दूरी की जानकारी मिलती है |
Zoom |
8 | इमेज को ज़ूम करने की सुविधा सेट करें |
Exposure
Compensation |
8 | लाइट एक्सपोज़र का लेवल बढ़ाएं या घटाएं |
GPS Data |
5 | इमेज के साथ भौगोलिक जगह का डेटा शामिल करें या हटाएं |
White Balance |
5 | व्हाइट बैलेंस मोड सेट करें. इससे कैप्चर की गई इमेज की कलर वैल्यू पर असर पड़ता है |
Focus Mode |
5 | सेट करें कि कैमरा किसी ऑब्जेक्ट पर कैसे फ़ोकस करे. जैसे, ऑटोमैटिक, फ़िक्स, मैक्रो या अनफ़ाइनाइट |
Scene Mode |
5 | रात, समुद्र तट, बर्फ़ जैसी खास तरह की फ़ोटोग्राफ़ी के लिए, प्रीसेट मोड इस्तेमाल करें या कैंडललाइट सीन |
JPEG Quality |
5 | JPEG इमेज के लिए कंप्रेस करने का लेवल सेट करें. इससे इमेज की आउटपुट फ़ाइल बढ़ या घटेगी क्वालिटी और साइज़ |
Flash Mode |
5 | फ़्लैश को चालू या बंद करना या ऑटोमैटिक सेटिंग का इस्तेमाल करना |
Color Effects |
5 | कैप्चर की गई इमेज पर कोई कलर इफ़ेक्ट लागू करें. जैसे, ब्लैक ऐंड व्हाइट, सेपिया टोन या नेगेटिव. |
Anti-Banding |
5 | JPEG कंप्रेशन की वजह से कलर ग्रेडिएंट में बैंडिंग के असर को कम करता है |
Picture Format |
1 | चित्र के लिए फ़ाइल प्रारूप निर्दिष्ट करें |
Picture Size |
1 | सेव की गई तस्वीर के पिक्सल डाइमेंशन के बारे में बताएं |
ध्यान दें: ये सुविधाएँ सभी डिवाइसों पर काम नहीं करती हैं. ऐसा इसलिए हुआ है, क्योंकि हार्डवेयर में अंतर और सॉफ़्टवेयर को लागू करने के तरीके. आपका ऐप्लिकेशन जिस डिवाइस पर चल रहा है उस पर सुविधाओं की उपलब्धता की जानकारी पाने के लिए, सुविधा की उपलब्धता की जांच करना लेख पढ़ें.
सुविधा की उपलब्धता की जांच करना
Android डिवाइसों पर कैमरे की सुविधाओं का इस्तेमाल करने से पहले, यह समझ लें कि सभी डिवाइसों पर कैमरे की सभी सुविधाएं काम नहीं करती हैं. इसके अलावा, वे डिवाइस जो किसी खास टेक्नोलॉजी सुविधा, उन्हें अलग-अलग लेवल पर या अलग-अलग विकल्पों के साथ इस्तेमाल कर सकती है. इसलिए, कैमरा ऐप्लिकेशन बनाते समय यह तय करना ज़रूरी है कि आपको कैमरे की किन सुविधाओं का इस्तेमाल करना है और किस लेवल पर. यह फ़ैसला लेने के बाद, आपको अपने कैमरा ऐप्लिकेशन में ऐसा कोड शामिल करना चाहिए जो यह जांच करता हो कि डिवाइस का हार्डवेयर उन सुविधाओं के साथ काम करता है या नहीं. साथ ही, अगर कोई सुविधा उपलब्ध नहीं है, तो ऐप्लिकेशन को इस तरह से डिज़ाइन किया गया हो कि वह बिना किसी रुकावट के काम करता रहे.
कैमरे की सुविधाओं की उपलब्धता की जांच करने के लिए, कैमरे के पैरामीटर ऑब्जेक्ट का कोई इंस्टेंस पाएं और काम के तरीके देखें. यहां दिए गए कोड सैंपल में, Camera.Parameters
ऑब्जेक्ट पाने और यह जांचने का तरीका बताया गया है कि कैमरे में ऑटोफ़ोकस की सुविधा काम करती है या नहीं:
Kotlin
val params: Camera.Parameters? = camera?.parameters val focusModes: List<String>? = params?.supportedFocusModes if (focusModes?.contains(Camera.Parameters.FOCUS_MODE_AUTO) == true) { // Autofocus mode is supported }
Java
// get Camera parameters Camera.Parameters params = camera.getParameters(); List<String> focusModes = params.getSupportedFocusModes(); if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) { // Autofocus mode is supported }
कैमरे की ज़्यादातर सुविधाओं के लिए, ऊपर बताई गई तकनीक का इस्तेमाल किया जा सकता है. कॉन्टेंट बनाने
Camera.Parameters
ऑब्जेक्ट, getSupported...()
, is...Supported()
या getMax...()
तरीके से यह पता लगाता है कि कोई सुविधा
समर्थित हैं.
अगर आपके ऐप्लिकेशन को ठीक से काम करने के लिए कुछ कैमरे की सुविधाओं की ज़रूरत है, तो आप को आपके ऐप्लिकेशन मेनिफ़ेस्ट में कुछ जोड़ने के लिए कहा जा सकता है. जब आप किसी खास चीज़ का इस्तेमाल करने का एलान करते हैं फ़्लैश और ऑटो-फ़ोकस जैसी कैमरा सुविधाएं, Google Play आपके ऐप्लिकेशन को को उन डिवाइस पर इंस्टॉल किया जा रहा है जिनमें ये सुविधाएँ काम नहीं करती हैं. आपके ऐप्लिकेशन मेनिफ़ेस्ट में बताई जा सकने वाली कैमरे की सुविधाओं की सूची के लिए, मेनिफ़ेस्ट का सुविधाओं का रेफ़रंस देखें.
कैमरे की सुविधाओं का इस्तेमाल करना
ज़्यादातर कैमरा सुविधाओं को चालू और कंट्रोल करने के लिए, Camera.Parameters
ऑब्जेक्ट का इस्तेमाल किया जाता है. आपको यह ऑब्जेक्ट, पहले का इंस्टेंस मिलने पर मिलता है
Camera
ऑब्जेक्ट, getParameters()
तरीके को कॉल करके, लौटाए गए पैरामीटर में बदलाव कर रहा है
ऑब्जेक्ट मिलेगा और फिर उसे कैमरा ऑब्जेक्ट में वापस सेट करेगा, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है
कोड:
Kotlin
val params: Camera.Parameters? = camera?.parameters params?.focusMode = Camera.Parameters.FOCUS_MODE_AUTO camera?.parameters = params
Java
// get Camera parameters Camera.Parameters params = camera.getParameters(); // set the focus mode params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO); // set Camera parameters camera.setParameters(params);
यह तकनीक कैमरे की करीब-करीब सभी सुविधाओं के लिए काम करती है. साथ ही, ज़्यादातर पैरामीटर किसी भी समय बदले जा सकते हैं
Camera
ऑब्जेक्ट का इंस्टेंस मिलने के बाद, कितने समय बाद. आम तौर पर, पैरामीटर में किए गए बदलाव, उपयोगकर्ता को ऐप्लिकेशन के कैमरे की झलक में तुरंत दिखते हैं.
सॉफ़्टवेयर की तरफ़, पैरामीटर में किए गए बदलावों को लागू होने में कई फ़्रेम लग सकते हैं, क्योंकि
कैमरा हार्डवेयर नए निर्देशों को प्रोसेस करता है और फिर अपडेट किया गया इमेज डेटा भेजता है.
अहम जानकारी: कैमरे से जुड़ी कुछ सुविधाओं में अपनी मर्ज़ी से बदलाव नहीं किया जा सकता. खास तौर पर, कैमरे की झलक का साइज़ या ओरिएंटेशन बदलने के लिए, आपको पहले झलक को रोकना होगा, फिर झलक का साइज़ बदलना होगा, और फिर झलक को फिर से शुरू करना होगा. Android 4.0 (एपीआई लेवल 14) से, झलक को फिर से शुरू किए बिना ही उसके ओरिएंटेशन को बदला जा सकता है.
कैमरे की अन्य सुविधाओं को लागू करने के लिए, ज़्यादा कोड की ज़रूरत होती है. इनमें ये सुविधाएं शामिल हैं:
- मेज़रमेंट और फ़ोकस करने के लिए चुने गए हिस्से
- चेहरे की पहचान करने की सुविधा
- टाइम लैप्स वाला वीडियो
इन सुविधाओं को लागू करने के तरीके के बारे में खास जानकारी, नीचे दिए गए सेक्शन में दी गई है.
मीटरिंग और फ़ोकस एरिया
फ़ोटोग्राफ़ी के कुछ मामलों में, अपने-आप फ़ोकस होने और लाइट मेज़र करने की सुविधा से शायद मनमुताबिक नतीजे न मिलें. Android 4.0 (एपीआई लेवल 14) से, आपका कैमरा ऐप्लिकेशन कुछ और कंट्रोल उपलब्ध करा सकता है. इनकी मदद से, आपके ऐप्लिकेशन या उपयोगकर्ता किसी इमेज में उन हिस्सों को चुन सकते हैं जिनका इस्तेमाल फ़ोकस या लाइट लेवल की सेटिंग तय करने के लिए किया जाना है. साथ ही, इन वैल्यू को कैमरा हार्डवेयर को भेजा जा सकता है, ताकि इमेज या वीडियो कैप्चर करने के लिए उनका इस्तेमाल किया जा सके.
मीटरिंग और फ़ोकस की सुविधा, कैमरे की अन्य सुविधाओं की तरह ही काम करती है. इनमें ये सुविधाएं मिलती हैं
Camera.Parameters
ऑब्जेक्ट में उन्हें अलग-अलग तरीकों से इस्तेमाल करते हैं. यहां दिए गए कोड में, Camera
के किसी इंस्टेंस के लिए, लाइट मेज़रमेंट के दो एरिया सेट करने का तरीका बताया गया है:
Kotlin
// Create an instance of Camera camera = getCameraInstance() // set Camera parameters val params: Camera.Parameters? = camera?.parameters params?.apply { if (maxNumMeteringAreas > 0) { // check that metering areas are supported meteringAreas = ArrayList<Camera.Area>().apply { val areaRect1 = Rect(-100, -100, 100, 100) // specify an area in center of image add(Camera.Area(areaRect1, 600)) // set weight to 60% val areaRect2 = Rect(800, -1000, 1000, -800) // specify an area in upper right of image add(Camera.Area(areaRect2, 400)) // set weight to 40% } } camera?.parameters = this }
Java
// Create an instance of Camera camera = getCameraInstance(); // set Camera parameters Camera.Parameters params = camera.getParameters(); if (params.getMaxNumMeteringAreas() > 0){ // check that metering areas are supported List<Camera.Area> meteringAreas = new ArrayList<Camera.Area>(); Rect areaRect1 = new Rect(-100, -100, 100, 100); // specify an area in center of image meteringAreas.add(new Camera.Area(areaRect1, 600)); // set weight to 60% Rect areaRect2 = new Rect(800, -1000, 1000, -800); // specify an area in upper right of image meteringAreas.add(new Camera.Area(areaRect2, 400)); // set weight to 40% params.setMeteringAreas(meteringAreas); } camera.setParameters(params);
Camera.Area
ऑब्जेक्ट में दो डेटा पैरामीटर होते हैं: कैमरे के फ़ील्ड ऑफ़ व्यू (कैमरे से दिख रहा व्यू) में कोई हिस्सा और वज़न तय करने के लिए, Rect
ऑब्जेक्ट
वह वैल्यू जिससे कैमरे को यह पता चलता है कि लाइट मीटरिंग में इस इलाके को किस हद तक प्राथमिकता दी जानी चाहिए
या फ़ोकस कैलकुलेशन.
Camera.Area
ऑब्जेक्ट में, Rect
फ़ील्ड
2000 x 2000 यूनिट ग्रिड पर मैप किए गए आयताकार आकार का वर्णन करता है. निर्देशांक -1,000, -1,000
कैमरा चित्र के ऊपरी बाएं कोने को निरूपित करते हैं, और निर्देशांक 1000, 1000 निरूपित होते हैं
जैसा कि नीचे दिए गए इलस्ट्रेशन में दिखाया गया है.
पहला डायग्राम. लाल रेखाएं ग्राफ़ में किसी
कैमरे की झलक में Camera.Area
. नीला बॉक्स, कैमरे के उस हिस्से की जगह और आकार दिखाता है जिसकी Rect
वैल्यू 333,333,667,667 है.
इस निर्देशांक सिस्टम के बाउंड, हमेशा इसमें दिखाई देने वाली इमेज के बाहरी किनारे के होते हैं
साथ ही, कैमरा झलक देख सकता है. साथ ही, ज़ूम लेवल के साथ छोटा या बड़ा न करें. इसी तरह, Camera.setDisplayOrientation()
का इस्तेमाल करके इमेज की झलक को घुमाने पर, कोऑर्डिनेट सिस्टम को फिर से मैप नहीं किया जाता.
चेहरे की पहचान
जिन तस्वीरों में लोग शामिल होते हैं उनमें चेहरे आम तौर पर सबसे अहम हिस्सा होते हैं. का इस्तेमाल इमेज कैप्चर करते समय फ़ोकस और व्हाइट बैलेंस, दोनों तय करने के लिए किया जाना चाहिए. Android 4.0 (एपीआई लेवल 14) फ़्रेमवर्क, चेहरों की पहचान करने और इमेज की सेटिंग कैलकुलेट करने के लिए एपीआई उपलब्ध कराता है. इसके लिए, चेहरा पहचानने की टेक्नोलॉजी पर काम करता है.
ध्यान दें: चेहरे की पहचान करने की सुविधा चालू होने पर,
setWhiteBalance(String)
,
setFocusAreas(List<Camera.Area>)
, और
setMeteringAreas(List<Camera.Area>)
का कोई असर नहीं पड़ता.
अपने कैमरा ऐप्लिकेशन में चेहरे की पहचान करने की सुविधा का इस्तेमाल करने के लिए कुछ सामान्य चरणों को पूरा करना ज़रूरी है:
- देखें कि डिवाइस पर चेहरे की पहचान करने की सुविधा काम करती है या नहीं
- चेहरे की पहचान करने वाला लिसनर बनाना
- अपने कैमरा ऑब्जेक्ट में चेहरे की पहचान करने वाला लिसनर जोड़ना
- झलक देखने के बाद (और हर झलक फिर से शुरू होने के बाद) चेहरे की पहचान करना शुरू करें
चेहरे की पहचान करने की सुविधा, सभी डिवाइसों पर काम नहीं करती. यह देखा जा सकता है कि यह सुविधा
getMaxNumDetectedFaces()
को कॉल करके समर्थित है. इस जांच का उदाहरण, नीचे दिए गए startFaceDetection()
सैंपल तरीके में दिया गया है.
किसी चेहरे की पहचान होने पर सूचना पाने और जवाब देने के लिए, आपका कैमरा ऐप्लिकेशन सेट करना ज़रूरी है
चेहरे की पहचान के इवेंट के लिए लिसनर. ऐसा करने के लिए, आपको एक ऐसी लिसनर क्लास बनानी होगी जो
Camera.FaceDetectionListener
इंटरफ़ेस को लागू करता है, जैसा कि
उदाहरण के तौर पर यहां दिया गया कोड देखें.
Kotlin
internal class MyFaceDetectionListener : Camera.FaceDetectionListener { override fun onFaceDetection(faces: Array<Camera.Face>, camera: Camera) { if (faces.isNotEmpty()) { Log.d("FaceDetection", ("face detected: ${faces.size}" + " Face 1 Location X: ${faces[0].rect.centerX()}" + "Y: ${faces[0].rect.centerY()}")) } } }
Java
class MyFaceDetectionListener implements Camera.FaceDetectionListener { @Override public void onFaceDetection(Face[] faces, Camera camera) { if (faces.length > 0){ Log.d("FaceDetection", "face detected: "+ faces.length + " Face 1 Location X: " + faces[0].rect.centerX() + "Y: " + faces[0].rect.centerY() ); } } }
इस क्लास को बनाने के बाद, आप इसे अपने ऐप्लिकेशन के
Camera
ऑब्जेक्ट, जैसा कि नीचे उदाहरण कोड में दिखाया गया है:
Kotlin
camera?.setFaceDetectionListener(MyFaceDetectionListener())
Java
camera.setFaceDetectionListener(new MyFaceDetectionListener());
आप जब भी कैमरे की झलक. चेहरे की पहचान करने की सुविधा शुरू करने के लिए कोई तरीका बनाएं, ताकि ज़रूरत पड़ने पर उसे कॉल किया जा सके. इसका उदाहरण, नीचे दिए गए कोड में दिया गया है.
Kotlin
fun startFaceDetection() { // Try starting Face Detection val params = mCamera?.parameters // start face detection only *after* preview has started params?.apply { if (maxNumDetectedFaces > 0) { // camera supports face detection, so can start it: mCamera?.startFaceDetection() } } }
Java
public void startFaceDetection(){ // Try starting Face Detection Camera.Parameters params = mCamera.getParameters(); // start face detection only *after* preview has started if (params.getMaxNumDetectedFaces() > 0){ // camera supports face detection, so can start it: mCamera.startFaceDetection(); } }
हर बार जब आप कैमरे की झलक शुरू करें या रीस्टार्ट करें, तब आपको चेहरे की पहचान करने की सुविधा चालू करनी होगी. अगर आपने
आप झलक दिखाने वाली क्लास बनाना में दिखाई गई झलक क्लास का इस्तेमाल करते हैं, तो
startFaceDetection()
तरीका
झलक दिखाने वाली क्लास में, surfaceCreated()
और surfaceChanged()
तरीके शामिल होंगे,
जैसा कि नीचे नमूना कोड में दिखाया गया है.
Kotlin
override fun surfaceCreated(holder: SurfaceHolder) { try { mCamera.setPreviewDisplay(holder) mCamera.startPreview() startFaceDetection() // start face detection feature } catch (e: IOException) { Log.d(TAG, "Error setting camera preview: ${e.message}") } } override fun surfaceChanged(holder: SurfaceHolder, format: Int, w: Int, h: Int) { if (holder.surface == null) { // preview surface does not exist Log.d(TAG, "holder.getSurface() == null") return } try { mCamera.stopPreview() } catch (e: Exception) { // ignore: tried to stop a non-existent preview Log.d(TAG, "Error stopping camera preview: ${e.message}") } try { mCamera.setPreviewDisplay(holder) mCamera.startPreview() startFaceDetection() // re-start face detection feature } catch (e: Exception) { // ignore: tried to stop a non-existent preview Log.d(TAG, "Error starting camera preview: ${e.message}") } }
Java
public void surfaceCreated(SurfaceHolder holder) { try { mCamera.setPreviewDisplay(holder); mCamera.startPreview(); startFaceDetection(); // start face detection feature } catch (IOException e) { Log.d(TAG, "Error setting camera preview: " + e.getMessage()); } } public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { if (holder.getSurface() == null){ // preview surface does not exist Log.d(TAG, "holder.getSurface() == null"); return; } try { mCamera.stopPreview(); } catch (Exception e){ // ignore: tried to stop a non-existent preview Log.d(TAG, "Error stopping camera preview: " + e.getMessage()); } try { mCamera.setPreviewDisplay(holder); mCamera.startPreview(); startFaceDetection(); // re-start face detection feature } catch (Exception e){ // ignore: tried to stop a non-existent preview Log.d(TAG, "Error starting camera preview: " + e.getMessage()); } }
ध्यान दें: startPreview()
को कॉल करने के बाद, इस तरीके को कॉल करना न भूलें. अपने कैमरा ऐप्लिकेशन की मुख्य गतिविधि के onCreate()
तरीके में, चेहरे की पहचान करने की सुविधा शुरू करने की कोशिश न करें. ऐसा इसलिए, क्योंकि ऐप्लिकेशन के चालू होने के इस समय तक, झलक उपलब्ध नहीं होती.
टाइम लैप्स वाला वीडियो
टाइम लैप्स वीडियो की मदद से, उपयोगकर्ता ऐसी वीडियो क्लिप बना सकते हैं जिनमें कुछ सेकंड या मिनट के अंतराल पर ली गई तस्वीरें शामिल होती हैं. यह सुविधा कुछ समय तक इमेज रिकॉर्ड करने के लिए, MediaRecorder
का इस्तेमाल करती है
लैप्स का क्रम.
MediaRecorder
के साथ टाइम लैप्स वीडियो रिकॉर्ड करने के लिए, आपको
यह भी रिकॉर्डर ऑब्जेक्ट की तरह है, जैसे कि कोई सामान्य वीडियो रिकॉर्ड किया जा रहा हो. साथ ही, कैप्चर किए गए फ़्रेम प्रति सेकंड
और टाइम लैप्स क्वालिटी सेटिंग में से किसी एक का इस्तेमाल करना होगा, जैसा कि नीचे दिए गए कोड उदाहरण में दिखाया गया है.
Kotlin
mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_TIME_LAPSE_HIGH)) mediaRecorder.setCaptureRate(0.1) // capture a frame every 10 seconds
Java
// Step 3: Set a CamcorderProfile (requires API Level 8 or higher) mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_TIME_LAPSE_HIGH)); ... // Step 5.5: Set the video capture rate to a low number mediaRecorder.setCaptureRate(0.1); // capture a frame every 10 seconds
MediaRecorder
के लिए, कॉन्फ़िगरेशन की पूरी प्रोसेस के तहत ये सेटिंग की जानी चाहिए. कॉन्फ़िगरेशन कोड का पूरा उदाहरण देखने के लिए, MediaRecorder को कॉन्फ़िगर करना देखें. कॉन्फ़िगरेशन पूरा हो जाने पर,
आप वीडियो रिकॉर्डिंग शुरू कर सकते हैं, जैसे कि आप किसी सामान्य वीडियो क्लिप को रिकॉर्ड कर रहे हों. Reader Revenue Manager को सेट अप करने के बारे में
MediaRecorder
को कॉन्फ़िगर करने और चलाने के बारे में जानने के लिए, वीडियो कैप्चर करना देखें.
Camera2Video और HdrViewfinder इन सैंपल से, इस पेज पर बताए गए एपीआई के इस्तेमाल के बारे में जानकारी मिलती है.
कैमरे के ऐसे फ़ील्ड जिनके लिए अनुमति की ज़रूरत होती है
Android 10 (एपीआई लेवल 29) या उसके बाद के वर्शन पर काम करने वाले ऐप्लिकेशन के पास, getCameraCharacteristics()
तरीका से मिलने वाली इन फ़ील्ड की वैल्यू ऐक्सेस करने के लिए, CAMERA
अनुमति होनी चाहिए:
LENS_POSE_ROTATION
LENS_POSE_TRANSLATION
LENS_INTRINSIC_CALIBRATION
LENS_RADIAL_DISTORTION
LENS_POSE_REFERENCE
LENS_DISTORTION
LENS_INFO_HYPERFOCAL_DISTANCE
LENS_INFO_MINIMUM_FOCUS_DISTANCE
SENSOR_REFERENCE_ILLUMINANT1
SENSOR_REFERENCE_ILLUMINANT2
SENSOR_CALIBRATION_TRANSFORM1
SENSOR_CALIBRATION_TRANSFORM2
SENSOR_COLOR_TRANSFORM1
SENSOR_COLOR_TRANSFORM2
SENSOR_FORWARD_MATRIX1
SENSOR_FORWARD_MATRIX2
अन्य सैंपल कोड
सैंपल ऐप्लिकेशन डाउनलोड करने के लिए, Camera2Basic सैंपल और CameraX का आधिकारिक सैंपल ऐप्लिकेशन देखें.