मोबाइल डेवलपमेंट में कैमरा: यह क्या है, API प्रकार और कैसे उपयोग करें

मोबाइल एप्लिकेशन में कैमरा क्या है

मोबाइल कैमरा एक एकीकृत ऑप्टिकल मॉड्यूल है जिसमें एक लेंस, इमेज सेंसर और इमेज सिग्नल प्रोसेसर (ISP) शामिल होता है। डेवलपर विशेष फ्रेमवर्क का उपयोग करके ऑपरेटिंग सिस्टम के माध्यम से कैमरे तक पहुँच प्राप्त करता है। Android पर, ये Camera2 API (निम्न-स्तरीय) और CameraX (उच्च-स्तरीय, Camera2 पर आधारित) हैं, और iOS पर — AVFoundation और सरल परिदृश्यों के लिए UIKit। प्रत्येक प्लेटफ़ॉर्म अपने उपकरणों का सेट प्रदान करता है, लेकिन सामान्य अवधारणा समान है: एप्लिकेशन एक कैप्चर सत्र प्रारंभ करता है, पैरामीटर (रिज़ॉल्यूशन, फ़ोकस, एक्सपोज़र) कॉन्फ़िगर करता है, और फ्रेम स्ट्रीम या अलग-अलग इमेज प्राप्त करता है।

आधुनिक कैमरों की हार्डवेयर क्षमताएँ

आधुनिक मोबाइल कैमरे कई शूटिंग मोड का समर्थन करते हैं: HDR, नाइट मोड, बैकग्राउंड ब्लर के साथ पोर्ट्रेट, स्लो-मोशन वीडियो और RAW प्रारूप में रिकॉर्डिंग। डेवलपर के पास सॉफ़्टवेयर सेटिंग्स तक पहुँच है: ISO (सेंसर संवेदनशीलता), शटर स्पीड (एक्सपोज़र), व्हाइट बैलेंस, फ़ोकस (ऑटोमैटिक और मैनुअल) और इमेज स्टेबिलाइज़ेशन। फ्लैगशिप उपकरणों में विभिन्न फोकल लंबाई वाले 4 कैमरे तक हो सकते हैं, और एप्लिकेशन ID द्वारा एक विशिष्ट कैमरा चुन सकता है।

कैमरे के साथ काम करने के लिए API के प्रकार

मोबाइल प्लेटफ़ॉर्म कैमरे के साथ काम करने के लिए कई APIs प्रदान करते हैं, जो एब्स्ट्रक्शन स्तर और कार्यक्षमता में भिन्न होते हैं। किसी विशिष्ट API का चुनाव प्रोजेक्ट की आवश्यकताओं पर निर्भर करता है: सरल फ़ोटो कैप्चर के लिए, CameraX या UIImagePickerController पर्याप्त है; पेशेवर एप्लिकेशन के लिए, सीधे सेंसर नियंत्रण के साथ Camera2 या AVFoundation की आवश्यकता होती है। नीचे मुख्य APIs की तुलना दी गई है।

CameraX कब चुनें

CameraX अधिकांश Android एप्लिकेशन के लिए सबसे अच्छा विकल्प है जिन्हें गहन अनुकूलन के बिना कैमरे की आवश्यकता होती है। लाइब्रेरी स्वचालित रूप से Activity और Fragment जीवनचक्र को संभालती है, अनुमतियों का समर्थन करती है और विभिन्न Android संस्करणों में संगतता सुनिश्चित करती है। CameraX अपनी संगतता परत के कारण 95% Android उपकरणों पर सुसंगत व्यवहार की गारंटी देता है। यदि आपको कैमरा पूर्वावलोकन (Preview), फ़ोटो कैप्चर (ImageCapture) या फ्रेम विश्लेषण (ImageAnalysis) की आवश्यकता है — CameraX जटिल कोड लिखे बिना तीनों परिदृश्यों को संभालता है।

Camera2 कब चुनें

Camera2 पेशेवर परिदृश्यों के लिए एक निम्न-स्तरीय API है: RAW रिकॉर्डिंग, मैनुअल एक्सपोज़र समायोजन, बर्स्ट कैप्चर और एक साथ कई कैमरों का नियंत्रण। Camera2 के लिए डेवलपर को इमेज कैप्चर पाइपलाइन, StateMachine प्रबंधन और कॉलबैक हैंडलिंग की गहरी समझ की आवश्यकता होती है। Camera2 का उपयोग केवल तभी करें जब CameraX आवश्यकताओं को पूरा नहीं करता: उदाहरण के लिए, मैनुअल फ़ोकस वाले दस्तावेज़ स्कैनिंग एप्लिकेशन या गैर-मानक रिज़ॉल्यूशन वाले कस्टम कैमरे।

कैमरा अनुमतियों का अनुरोध

कैमरे तक पहुँच के लिए दोनों प्लेटफ़ॉर्म पर उपयोगकर्ता की स्पष्ट अनुमति आवश्यक है। Android पर, CAMERA अनुमति मेनिफेस्ट में जोड़ा जाता है, और Android 6.0 से शुरू होकर, रनटाइम पर ActivityCompat.requestPermissions के माध्यम से भी अनुमति का अनुरोध किया जाना चाहिए। iOS पर, कैमरे के उपयोग के कारण के विवरण के साथ Info.plist में NSCameraUsageDescription कुंजी जोड़ी जाती है। इस विवरण के बिना, कैमरे तक पहुँचने का प्रयास करते समय एप्लिकेशन क्रैश हो जाएगा। iOS 14 से शुरू होकर, अनुमति डायलॉग न केवल एप्लिकेशन का नाम बल्कि निर्दिष्ट कारण भी प्रदर्शित करता है — शब्दांकन उपयोगकर्ता के लिए स्पष्ट होना चाहिए।

CameraX के साथ Android पर कार्यान्वयन

CameraX कोड की कुछ पंक्तियों में कैमरे के साथ काम को सरल बनाता है। पूर्वावलोकन शुरू करने के लिए, आपको Preview का एक इंस्टेंस बनाना होगा, इसे LifecycleOwner से बाँधना होगा और प्रदर्शन के लिए SurfaceProvider प्राप्त करना होगा। फ़ोटो कैप्चर के लिए, सेव टार्गेट के साथ ImageCapture का उपयोग किया जाता है। नीचे Kotlin में CameraX का उपयोग करके कैमरा शुरू करने और फ़ोटो लेने का पूर्ण उदाहरण दिया गया है।

Preview और ImageCapture की स्थापना

val preview = Preview.Builder()
    .build()
    .also {
        it.surfaceProvider = viewFinder.surfaceProvider
    }

val imageCapture = ImageCapture.Builder()
    .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
    .build()

val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
cameraProviderFuture.addListener(Runnable {
    val cameraProvider = cameraProviderFuture.get()
    val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

    try {
        cameraProvider.unbindAll()
        cameraProvider.bindToLifecycle(
            this, cameraSelector, preview, imageCapture
        )
    } catch (e: Exception) {
        Log.e("CameraX", "बाइंड विफल", e)
    }
}, ContextCompact.getMainExecutor(this))

bindToLifecycle विधि कैमरे को Activity के जीवनचक्र से बाँधती है — जब स्क्रीन घूमती है या एप्लिकेशन बैकग्राउंड में जाता है, तो कैमरा स्वचालित रूप से रिलीज़ हो जाता है। CameraSelector.DEFAULT_BACK_CAMERA रियर कैमरा चुनता है; फ्रंट कैमरे के लिए DEFAULT_FRONT_CAMERA का उपयोग किया जाता है। बाइंडिंग के बाद, Preview PreviewView में कैमरा फ़ीड प्रदर्शित करना शुरू करता है, और उपयोगकर्ता स्क्रीन पर कैमरा इमेज देखता है।

फ़ोटो कैप्चर करना

val photoFile = File(
    externalMediaDirs.firstOrNull(),
    "IMG_${System.currentTimeMillis()}.jpg"
)
val outputOptions = ImageCapture.OutputFileOptions
    .Builder(photoFile)
    .build()

imageCapture.takePicture(
    outputOptions,
    ContextCompact.getMainExecutor(this),
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(output: ImageCapture.OutputFileResults) {
            Log.d("CameraX", "Photo saved: ${photoFile.absolutePath}")
        }
        override fun onError(exception: ImageCaptureException) {
            Log.e("CameraX", "कैप्चर त्रुटि", exception)
        }
    }
)

takePicture विधि कैमरे से एक फ्रेम कैप्चर करती है और इसे फ़ाइल में सहेजती है। OutputFileOptions File, ContentResolver और MediaStore में लेखन का समर्थन करता है। onImageSaved कॉलबैक में, एप्लिकेशन सफल सेविंग की सूचना प्राप्त करता है और UI को अपडेट कर सकता है। CAPTURE_MODE_MINIMIZE_LATENCY पोस्ट-प्रोसेसिंग को कम करके अधिकतम शटर गति सुनिश्चित करता है।

AVFoundation के साथ iOS पर कार्यान्वयन

iOS पर, कैमरे तक पहुँच AVFoundation फ्रेमवर्क द्वारा AVCaptureSession क्लास के माध्यम से प्रदान की जाती है। डेवलपर एक कैप्चर सत्र बनाता है, आवश्यक इनपुट (AVCaptureDeviceInput) और आउटपुट (AVCapturePhotoOutput, AVCaptureVideoDataOutput) जोड़ता है, और सत्र शुरू करता है। पूर्वावलोकन प्रदर्शित करने के लिए AVCaptureVideoPreviewLayer का उपयोग किया जाता है। नीचे Swift में फ़ोटो कैप्चर के लिए सत्र स्थापित करने का उदाहरण दिया गया है।

import AVFoundation

let captureSession = AVCaptureSession()
captureSession.sessionPreset = .photo

guard let camera = AVCaptureDevice.default(
    for: .video
) else { return }

guard let input = try? AVCaptureDeviceInput(device: camera)
else { return }

let output = AVCapturePhotoOutput()
captureSession.addInput(input)
captureSession.addOutput(output)

DispatchQueue.global(qos: .userInitiated).async {
    captureSession.startRunning()
}

AVCaptureSessionPreset.photo फ़ोटो के लिए इष्टतम रिज़ॉल्यूशन सेट करता है (आमतौर पर आधुनिक उपकरणों पर 12 MP)। इनपुट डिवाइस के कैमरे के लिए बनाया गया AVCaptureDeviceInput है। इनपुट और आउटपुट जोड़ने के बाद, सत्र startRunning के माध्यम से बैकग्राउंड थ्रेड पर शुरू किया जाता है — पुराने उपकरणों पर सत्र शुरू करने में 200 ms तक लग सकते हैं। फ़ोटो कैप्चर करने के लिए, capturePhoto(with:delegate:) कॉल किया जाता है, और परिणाम AVCapturePhotoCaptureDelegate के माध्यम से लौटाया जाता है।

विशेषताएँ और सीमाएँ

कैमरे के साथ मोबाइल उपकरणों पर काम करते समय, हार्डवेयर सीमाओं पर विचार किया जाना चाहिए: लंबे समय तक रिकॉर्डिंग के दौरान डिवाइस का गर्म होना, उच्च रिज़ॉल्यूशन के साथ काम करते समय बैटरी की खपत, और विभिन्न उपकरणों पर अलग-अलग कैमरा गुणवत्ता। Android पर, इकोसिस्टम विखंडन का मतलब है कि एक ही CameraX कॉन्फ़िगरेशन विभिन्न मॉडलों पर अलग-अलग व्यवहार कर सकता है। iOS पर, सीमाएँ मुख्य रूप से लाइसेंसिंग से संबंधित हैं: बैकग्राउंड में कैमरे का उपयोग करने के लिए Apple से विशेष अनुमति की आवश्यकता होती है। यह भी याद रखना महत्वपूर्ण है कि सिमुलेटर के पास वास्तविक कैमरे तक पहुँच नहीं है — परीक्षण केवल भौतिक उपकरण पर ही संभव है।

विभिन्न OS संस्करणों के साथ संगतता

CameraX CameraXConfig संगतता परत के माध्यम से Android विखंडन की समस्या को हल करता है — लाइब्रेरी ज्ञात निर्माता बग के लिए स्वचालित रूप से वर्कअराउंड लागू करती है। iOS पर, AVFoundation iOS 6 से शुरू होने वाले सभी उपकरणों पर समान रूप से काम करता है, लेकिन कुछ सुविधाएँ (जैसे पोर्ट्रेट मोड या LiDAR) केवल iPhone 12 और नए मॉडलों पर उपलब्ध हैं। क्रॉस-प्लेटफ़ॉर्म एप्लिकेशन विकसित करते समय, कैमरा प्लगइन्स के साथ Flutter या React Native का उपयोग करने की अनुशंसा की जाती है — वे प्लेटफ़ॉर्म अंतरों को एब्स्ट्रैक्ट करते हैं और दोनों ऑपरेटिंग सिस्टम के लिए एकीकृत API प्रदान करते हैं।