कैमरा एपीआई

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

ध्यान दें: इस पेज में Camera क्लास को हटा दिया गया है. हमारा सुझाव है कि आप CameraX Jetpack लाइब्रेरी या खास इस्तेमाल के लिए, camera2, क्लास. CameraX और Camera2, दोनों ही Android 5.0 (एपीआई लेवल 21) पर काम करते हैं और उच्च.

ज़रूरी बातें

Android डिवाइस पर कैमरे का उपयोग करने के लिए अपने ऐप्लिकेशन को सक्षम करने से पहले, आपको कुछ आपका ऐप्लिकेशन, हार्डवेयर की सुविधा का इस्तेमाल किस तरह करना चाहता है, इस बारे में सवाल.

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

बुनियादी बातें

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 (एपीआई लेवल 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() तरीके का इस्तेमाल करें, जैसा कि नीचे उदाहरण में दिए गए कोड में दिखाया गया है:

/** 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
    }
}

/** 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() तरीका इस्तेमाल करें और जैसा कि नीचे दिए गए कोड में दिखाया गया है, किसी अपवाद की जानकारी पाना न भूलें:

/** 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
    }
}

/** 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 को लागू करती है, ताकि कॉलबैक इवेंट कैप्चर किए जा सकें व्यू बनाने और बंद करने के लिए, जो कैमरा प्रीव्यू इनपुट को असाइन करने के लिए ज़रूरी हैं.

/** 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}")
            }
        }
    }
}

/** 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 एलिमेंट में अपनी झलक क्लास जोड़ें. कैमरे की गतिविधि से जुड़े डेटा को भी ध्यान में रखना ज़रूरी है पक्का करें कि कैमरे को रोकने या बंद करने पर यह उसे छोड़ दे. नीचे दिए गए उदाहरण में बताया गया है कि में दिखाई गई पूर्वावलोकन क्लास को अटैच करने के लिए कैमरा गतिविधि को संशोधित करने के लिए बनाया जा रहा है क्लास की झलक.

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

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 इंटरफ़ेस को बुनियादी तौर पर लागू करने का तरीका दिखाया गया है.

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

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.

val captureButton: Button = findViewById(R.id.button_capture)
captureButton.setOnClickListener {
    // get an image from the camera
    mCamera?.takePicture(null, null, picture)
}

// 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() कॉल अपने-आप मैनेज होते हैं.

किसी डिवाइस के कैमरे से फ़ोटो लेने के उलट, वीडियो कैप्चर करने के लिए खास तरह की कॉल की ज़रूरत होती है ऑर्डर. वीडियो बनाने और उसे कैप्चर करने के लिए, आपको एक्ज़ीक्यूशन के एक खास क्रम का पालन करना होगा आपके आवेदन के साथ, जैसा कि नीचे बताया गया है.

1. कैमरा खोलें - Camera.open() का इस्तेमाल करें का इस्तेमाल करें.
2. झलक कनेक्ट करें - Camera.setPreviewDisplay() का इस्तेमाल करके, कैमरे के साथ SurfaceView कनेक्ट करके, कैमरे की लाइव इमेज की झलक तैयार करें.
3. झलक देखें - कैमरे की लाइव इमेज दिखाने के लिए, Camera.startPreview() पर कॉल करें.
4. वीडियो रिकॉर्ड करना शुरू करें - नीचे दिए गए चरणों को वीडियो रिकॉर्ड करने के लिए क्रम:
   1. कैमरा अनलॉक करें - MediaRecorder तक Camera.unlock() पर कॉल करके इस्तेमाल करने के लिए कैमरा अनलॉक करें.
   2. MediaRecorder कॉन्फ़िगर करें - इस क्रम में नीचे दिए गए MediaRecorder तरीकों का इस्तेमाल करें. ज़्यादा जानकारी के लिए, MediaRecorder का रेफ़रंस दस्तावेज़ देखें.
      1. setCamera() - वीडियो कैप्चर करने के लिए कैमरे को सेट करें. इसके लिए, ऐप्लिकेशन के मौजूदा इंस्टेंस का इस्तेमाल करें कुल Camera.
      2. setAudioSource() - ऑडियो सोर्स, MediaRecorder.AudioSource.CAMCORDER इस्तेमाल करें.
      3. setVideoSource() - सेट वीडियो सोर्स, MediaRecorder.VideoSource.CAMERA का इस्तेमाल करें.
      4. वीडियो के आउटपुट का फ़ॉर्मैट और कोड में बदलने का तरीका सेट करें. Android 2.2 (एपीआई लेवल 8) और बड़ा करने के लिए, MediaRecorder.setProfile तरीके का इस्तेमाल करें और CamcorderProfile.get() का इस्तेमाल करके प्रोफ़ाइल इंस्टेंस पाएं. इससे पहले के Android वर्शन के लिए 2.2, आपको वीडियो आउटपुट फ़ॉर्मैट और एन्कोडिंग पैरामीटर सेट करने होंगे:
         1. setOutputFormat() - सेट आउटपुट फ़ॉर्मैट में, डिफ़ॉल्ट सेटिंग तय करें या MediaRecorder.OutputFormat.MPEG_4 तय करें.
         2. setAudioEncoder() - सेट साउंड एन्कोडिंग टाइप, डिफ़ॉल्ट सेटिंग तय करें या MediaRecorder.AudioEncoder.AMR_NB.
         3. setVideoEncoder() - सेट वीडियो एन्कोडिंग टाइप, डिफ़ॉल्ट सेटिंग तय करें या MediaRecorder.VideoEncoder.MPEG_4_SP.
      5. setOutputFile() से आउटपुट फ़ाइल सेट करें. इसके बाद, उदाहरण में बताए गए getOutputMediaFile(MEDIA_TYPE_VIDEO).toString() का इस्तेमाल करें तरीका चुनने के लिए, मीडिया फ़ाइलें सेव करना सेक्शन में जाना होगा.
      6. setPreviewDisplay() - इसके लिए SurfaceView झलक लेआउट एलिमेंट तय करें आपका ऐप्लिकेशन. उसी ऑब्जेक्ट का इस्तेमाल करें जिसे आपने झलक कनेक्ट करने के लिए तय किया था.

      चेतावनी: आपको MediaRecorder कॉन्फ़िगरेशन के इन तरीकों को इस क्रम में कॉल करना होगा, वरना आपके ऐप्लिकेशन में त्रुटियां होंगी और रिकॉर्डिंग विफल हो जाएगी.

   3. MediaRecorder तैयार करें - MediaRecorder तैयार करें MediaRecorder.prepare() को कॉल करके उपलब्ध कराई गई कॉन्फ़िगरेशन सेटिंग के साथ.
   4. MediaRecorder शुरू करें - MediaRecorder.start() को कॉल करके वीडियो रिकॉर्ड करना शुरू करें.
5. वीडियो रिकॉर्ड करना बंद करें - नीचे दिए गए तरीकों को क्रम में कॉल करें वीडियो रिकॉर्डिंग पूरी करें:
   1. MediaRecorder रोकें - MediaRecorder.stop() पर कॉल करके वीडियो रिकॉर्ड करना बंद करें.
   2. MediaRecorder को रीसेट करें - विकल्प के तौर पर, यहां से कॉन्फ़िगरेशन सेटिंग हटाएं MediaRecorder.reset() पर कॉल करके रिकॉर्डर को ऐक्सेस किया जा सकता है.
   3. MediaRecorder रिलीज़ करें - MediaRecorder को रिलीज़ करें MediaRecorder.release() पर कॉल करके.
   4. कैमरा लॉक करें - कैमरा लॉक करें, ताकि आने वाले समय में MediaRecorder सेशन में, Camera.lock() पर कॉल करके इसे इस्तेमाल किया जा सके. Android 4.0 (एपीआई लेवल 14) से शुरू होने वाले वर्शन के लिए, इस कॉल की ज़रूरत तब तक नहीं पड़ती, जब तक MediaRecorder.prepare() कॉल नहीं हुआ.
6. झलक देखना बंद करें - जब कैमरे का इस्तेमाल करके आपकी गतिविधि पूरी हो जाए, तो Camera.stopPreview() का इस्तेमाल करके झलक देखें.
7. कैमरा रिलीज़ करें - कैमरे को छोड़ दें, ताकि दूसरे ऐप्लिकेशन इस्तेमाल कर सकें Camera.release() पर कॉल करके इसे खोजें.

ध्यान दें: MediaRecorder का इस्तेमाल किया जा सकता है इसके लिए, उन्हें कैमरा प्रीव्यू बनाया जा सकता है और इस प्रोसेस के शुरुआती कुछ चरणों को छोड़ दिया जाता है. हालांकि, क्योंकि उपयोगकर्ता आम तौर पर रिकॉर्डिंग शुरू करने से पहले झलक देखना पसंद करते हैं, इसलिए यह प्रक्रिया यहां चर्चा की गई है.

सलाह: अगर आपके ऐप्लिकेशन का इस्तेमाल आम तौर पर वीडियो रिकॉर्ड करने के लिए किया जाता है, तो शुरू करने से पहले setRecordingHint(boolean) से true झलक देखें. इस सेटिंग की मदद से, वीडियो रिकॉर्ड होने में लगने वाले समय को कम किया जा सकता है.

MediaRecorder को कॉन्फ़िगर किया जा रहा है

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

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
}

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 का इस्तेमाल करने के बजाय सीधे पैरामीटर का इस्तेमाल करें. यह तरीका, इस कोड में दिखाया गया है:

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

    // 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 क्लास का इस्तेमाल करके, वीडियो रिकॉर्डिंग शुरू या बंद करते समय, आपको एक विशिष्ट आदेश का पालन करना होगा, जैसा कि नीचे सूचीबद्ध है.

1. Camera.unlock() की मदद से कैमरा अनलॉक करें
2. ऊपर दिए गए कोड के उदाहरण में दिखाए गए तरीके से MediaRecorder को कॉन्फ़िगर करें
3. MediaRecorder.start() का इस्तेमाल करके रिकॉर्ड करना शुरू करें
4. वीडियो रिकॉर्ड करें
5. MediaRecorder.stop() का इस्तेमाल करके रिकॉर्डिंग बंद करें
6. MediaRecorder.release() का इस्तेमाल करके मीडिया रिकॉर्डर रिलीज़ करें
7. Camera.lock() का इस्तेमाल करके कैमरा लॉक करें

नीचे दिए गए उदाहरण कोड में बताया गया है कि किसी बटन को ठीक से चालू और बंद करने के लिए, एक तार कैसे जोड़ें कैमरे और MediaRecorder क्लास का इस्तेमाल करके वीडियो रिकॉर्डिंग की सुविधा.

ध्यान दें: वीडियो रिकॉर्डिंग पूरी करते समय, कैमरे को न छोड़ें ऐसा न करने पर, झलक बंद हो जाएगी.

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

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() तरीके का इस्तेमाल करें, जैसा कि नीचे उदाहरण कोड में दिखाया गया है.

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

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 या कैमरा बनाने के लिए ऐप्लिकेशन.

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

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 एपीआई लेवल के हिसाब से क्रम में लगाया जाता है. पेश किए गए थे.

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

यह देखना कि कोई सुविधा उपलब्ध है या नहीं

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

कैमरे के पैरामीटर का इंस्टेंस देखकर, कैमरे की सुविधाओं की उपलब्धता देखी जा सकती है ऑब्जेक्ट की जांच करता है और प्रासंगिक तरीकों की जांच करता है. नीचे दिए गए कोड सैंपल में, आपको Camera.Parameters ऑब्जेक्ट और जांच करें कि कैमरे पर ऑटोफ़ोकस सुविधा काम करती है या नहीं सुविधा:

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
}

// 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() तरीके को कॉल करके, लौटाए गए पैरामीटर में बदलाव कर रहा है ऑब्जेक्ट मिलेगा और फिर उसे कैमरा ऑब्जेक्ट में वापस सेट करेगा, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है कोड:

val params: Camera.Parameters? = camera?.parameters
params?.focusMode = Camera.Parameters.FOCUS_MODE_AUTO
camera?.parameters = params

// 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:

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

// 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, -1000 कैमरा चित्र के ऊपरी बाएं कोने को निरूपित करते हैं, और निर्देशांक 1000, 1000 निरूपित होते हैं जैसा कि नीचे दिए गए इलस्ट्रेशन में दिखाया गया है.

पहला डायग्राम. लाल रेखाएं ग्राफ़ में किसी कैमरे की झलक में Camera.Area. नीले रंग का बॉक्स जगह की जानकारी और कैमरा एरिया का आकार, जिसकी Rect वैल्यू 33,33,33,667,667 है.

इस निर्देशांक सिस्टम का बाउंड, हमेशा इसमें दिखाई देने वाली इमेज के बाहरी किनारे के अनुरूप होता है साथ ही, कैमरा झलक देख सकता है. साथ ही, ज़ूम लेवल के साथ छोटा या बड़ा न करें. इसी तरह, इमेज का रोटेशन Camera.setDisplayOrientation() का इस्तेमाल करके झलक देखें निर्देशांक सिस्टम को फिर से मैप नहीं करता.

चेहरे की पहचान

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

ध्यान दें: चेहरे की पहचान करने की सुविधा चालू रहने के दौरान, setWhiteBalance(String), setFocusAreas(List<Camera.Area>) और setMeteringAreas(List<Camera.Area>) का कोई असर नहीं होता.

अपने कैमरा ऐप्लिकेशन में चेहरे की पहचान करने की सुविधा का इस्तेमाल करने के लिए कुछ सामान्य चरणों को पूरा करना ज़रूरी है:

• देख लें कि डिवाइस पर चेहरे की पहचान करने वाली सुविधा काम करती है या नहीं
• चेहरे की पहचान करने वाला लिसनर बनाएं
• अपने कैमरा ऑब्जेक्ट में, चेहरे की पहचान करने वाली सुविधा को जोड़ें
• झलक देखने के बाद (और हर झलक रीस्टार्ट होने के बाद) चेहरे की पहचान करना शुरू करें

चेहरे की पहचान करने की सुविधा सभी डिवाइसों पर काम नहीं करती. यह देखा जा सकता है कि यह सुविधा getMaxNumDetectedFaces() को कॉल करके समर्थित है. अगर आप इस तरह की जांच का उदाहरण नीचे दिए गए startFaceDetection() सैंपल तरीके में दिया गया है.

किसी चेहरे की पहचान होने पर सूचना पाने और जवाब देने के लिए, आपका कैमरा ऐप्लिकेशन सेट करना ज़रूरी है चेहरे की पहचान के इवेंट के लिए लिसनर. ऐसा करने के लिए, आपको एक ऐसी लिसनर क्लास बनानी होगी जो Camera.FaceDetectionListener इंटरफ़ेस को लागू करता है, जैसा कि उदाहरण के लिए, नीचे दिया गया कोड देखें.

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

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 ऑब्जेक्ट, जैसा कि नीचे उदाहरण में दिए गए कोड में दिखाया गया है:

camera?.setFaceDetectionListener(MyFaceDetectionListener())

camera.setFaceDetectionListener(new MyFaceDetectionListener());

आप जब भी कैमरे की झलक. चेहरे की पहचान करने की सुविधा शुरू करने का एक तरीका बनाएं, ताकि आप ज़रूरत के मुताबिक इस पर कॉल कर सकें .

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

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() तरीके हैं, जैसा कि नीचे नमूना कोड में दिखाया गया है.

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

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 के साथ टाइम लैप्स वीडियो रिकॉर्ड करने के लिए, आपको यह भी रिकॉर्डर ऑब्जेक्ट की तरह है, जैसे कि कोई सामान्य वीडियो रिकॉर्ड किया जा रहा हो. साथ ही, कैप्चर किए गए फ़्रेम प्रति सेकंड और टाइम लैप्स क्वालिटी सेटिंग में से किसी एक का इस्तेमाल करना होगा, जैसा कि नीचे दिए गए कोड उदाहरण में दिखाया गया है.

mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_TIME_LAPSE_HIGH))
mediaRecorder.setCaptureRate(0.1) // capture a frame every 10 seconds

// 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) या उसके बाद के वर्शन पर काम करने वाले ऐप्लिकेशन में CAMERA की अनुमति नीचे दिए गए फ़ील्ड की वैल्यू को ऐक्सेस करें, getCameraCharacteristics() तरीका रिटर्न:

• 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 सैंपल ऐप्लिकेशन.