इस पेज में CameraX के आर्किटेक्चर के बारे में बताया गया है. इसमें इसकी बनावट, एपीआई के साथ काम करने, लाइफ़साइकल के साथ काम करने, और इस्तेमाल के उदाहरणों को जोड़ने के बारे में जानकारी शामिल है.
CameraX स्ट्रक्चर
आप डिवाइस के कैमरे के साथ इंटरफ़ेस करने के लिए CameraX का इस्तेमाल कर सकते हैं. इसके लिए ऐब्स्ट्रैक्ट को इस्तेमाल का उदाहरण कहते हैं. इस्तेमाल के ये उदाहरण उपलब्ध हैं:
- झलक देखें: झलक दिखाने के लिए प्लैटफ़ॉर्म को स्वीकार करता है, जैसे कि
PreviewView
. - इमेज का विश्लेषण: यह विश्लेषण के लिए, सीपीयू से ऐक्सेस किए जा सकने वाले बफ़र उपलब्ध कराता है मशीन लर्निंग.
- फ़ोटो कैप्चर: फ़ोटो कैप्चर करके सेव की जाती है.
- वीडियो कैप्चर:
VideoCapture
की मदद से वीडियो और ऑडियो कैप्चर करें
इस्तेमाल के उदाहरणों को एक साथ जोड़ा जा सकता है और एक साथ चालू किया जा सकता है. उदाहरण के लिए, कोई ऐप्लिकेशन झलक के इस्तेमाल के उदाहरण का इस्तेमाल करके, उपयोगकर्ता उस इमेज को देखता है जिसे कैमरे में दिखता है. इमेज विश्लेषण के इस्तेमाल का उदाहरण, जिससे पता चलता है कि फ़ोटो में मौजूद लोग मुस्कुराएं और फ़ोटो लेने के लिए उनमें एक इमेज कैप्चर इस्तेमाल का उदाहरण शामिल करें.
एपीआई मॉडल
लाइब्रेरी का इस्तेमाल करने के लिए, ये चीज़ें तय की जाती हैं:
- कॉन्फ़िगरेशन के विकल्पों के साथ अपने हिसाब से इस्तेमाल का उदाहरण.
- लिसनर को अटैच करके, आउटपुट डेटा का क्या करें.
- तय किया गया फ़्लो, जैसे कि कैमरा कब चालू करना है और कब डेटा बनाना है, इस्तेमाल के उदाहरण को Android आर्किटेक्चर लाइफ़साइकल.
CameraX ऐप्लिकेशन में लिखने के दो तरीके हैं:
CameraController
(अगर यह सही है, तो
CameraX इस्तेमाल करने का सबसे आसान तरीका चाहिए) या
CameraProvider
(अगर आपके पास
ज़्यादा सुविधाओं की ज़रूरत है).
कैमरा कंट्रोलर
CameraController
से, CameraX के ज़्यादातर मुख्य फ़ंक्शन एक ही बार में मिलते हैं
क्लास. इसे एक छोटे से सेटअप कोड की ज़रूरत होती है और यह कैमरे को अपने-आप चालू कर लेता है
शुरू करना, केस मैनेजमेंट का इस्तेमाल करना, टारगेट को घुमाना, टैप-टू-फ़ोकस,
ज़ूम करने के लिए पिंच वगैरह. CameraController
को बढ़ाने वाली कंक्रीट क्लास
LifecycleCameraController
.
Kotlin
val previewView: PreviewView = viewBinding.previewView var cameraController = LifecycleCameraController(baseContext) cameraController.bindToLifecycle(this) cameraController.cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA previewView.controller = cameraController
Java
PreviewView previewView = viewBinding.previewView; LifecycleCameraController cameraController = new LifecycleCameraController(baseContext); cameraController.bindToLifecycle(this); cameraController.setCameraSelector(CameraSelector.DEFAULT_BACK_CAMERA); previewView.setController(cameraController);
CameraController
के लिए डिफ़ॉल्ट UseCase
s Preview
, ImageCapture
, और हैं
ImageAnalysis
. ImageCapture
या ImageAnalysis
को बंद या बंद करने के लिए
VideoCapture
चालू है, इसका इस्तेमाल करें
setEnabledUseCases()
तरीका.
CameraController
के और इस्तेमाल के बारे में जानने के लिए, देखें
क्यूआर कोड स्कैनर सैंपल
या
CameraController
के बारे में बुनियादी जानकारी वाला वीडियो.
कैमरा प्रोवाइडर
CameraProvider
का इस्तेमाल करना अब भी आसान है, लेकिन क्योंकि इसे ऐप्लिकेशन डेवलपर
कॉन्फ़िगरेशन को कस्टमाइज़ करने के कई अवसर हैं, तो ज़्यादा
जैसे, आउटपुट इमेज रोटेशन को चालू करना या आउटपुट इमेज फ़ॉर्मैट को
ImageAnalysis
. कैमरे की झलक देखने के लिए, अपनी पसंद के मुताबिक Surface
का भी इस्तेमाल किया जा सकता है
अधिक सुविधा के लिए, जबकि CameraController के साथ आपको
PreviewView
. अपने मौजूदा Surface
कोड का इस्तेमाल करना मददगार हो सकता है, अगर यह
आपके ऐप्लिकेशन के अन्य हिस्सों के लिए इनपुट पहले से ही मौजूद है.
set()
तरीकों का इस्तेमाल करके, इस्तेमाल के उदाहरण कॉन्फ़िगर किए जाते हैं और build()
की मदद से उन्हें पूरा किया जाता है
तरीका. इस्तेमाल के हर उदाहरण से, खास तौर पर इस्तेमाल के लिए एपीआई का सेट मिलता है. इसके लिए
उदाहरण के लिए, इमेज कैप्चर के इस्तेमाल का उदाहरण, takePicture()
तरीके से कॉल करने की सुविधा देता है.
कॉल को शुरू और रोकने के लिए, किसी ऐप्लिकेशन के बजाय
onResume()
और onPause()
, ऐप्लिकेशन असोसिएट करने के लिए लाइफ़साइकल तय करता है
की मदद से कैमरे को
cameraProvider.bindToLifecycle()
.
वह लाइफ़साइकल इसके बाद CameraX को यह सूचना देती है कि कैमरा कैप्चर सेशन को कब कॉन्फ़िगर करना है
साथ ही, यह पक्का करता है कि लाइफ़साइकल ट्रांज़िशन के हिसाब से, कैमरे की स्थिति ठीक से बदल रही हो.
इस्तेमाल के हर उदाहरण को लागू करने के चरणों के बारे में जानने के लिए, लागू करें झलक देखें, विश्लेषण करें इमेज, इमेज कैप्चर और वीडियो कैप्चर
प्रीव्यू के इस्तेमाल का उदाहरण
Surface
डिसप्ले के लिए. आवेदन
नीचे दिए गए कोड का इस्तेमाल करके, कॉन्फ़िगरेशन के विकल्पों के साथ इस्तेमाल का उदाहरण बनाएं:
Kotlin
val preview = Preview.Builder().build() val viewFinder: PreviewView = findViewById(R.id.previewView) // The use case is bound to an Android Lifecycle with the following code val camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview) // PreviewView creates a surface provider and is the recommended provider preview.setSurfaceProvider(viewFinder.getSurfaceProvider())
Java
Preview preview = new Preview.Builder().build(); PreviewView viewFinder = findViewById(R.id.view_finder); // The use case is bound to an Android Lifecycle with the following code Camera camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview); // PreviewView creates a surface provider, using a Surface from a different // kind of view will require you to implement your own surface provider. preview.previewSurfaceProvider = viewFinder.getSurfaceProvider();
कोड के ज़्यादा उदाहरण के लिए, आधिकारिक CameraX सैंपल देखें ऐप्लिकेशन है.
CameraX लाइफ़साइकल
CameraX, लाइफ़साइकल की निगरानी करके यह तय करता है कि कैमरा कब और कब खोलना है एक कैप्चर सेशन तैयार करें. साथ ही, आपको यह भी बता दें कि इसे कब बंद और शट डाउन करना है. इस्तेमाल के उदाहरण वाले एपीआई मेथड कॉल और कॉलबैक का भी इस्तेमाल किया जा सकता है.
जैसा कि इस्तेमाल के उदाहरणों को मिलाएं में बताया गया है, आप इन चीज़ों के कुछ मिक्स को बाइंड कर सकते हैं एक लाइफ़साइकल के लिए इस्तेमाल के उदाहरणों का इस्तेमाल करें. जब आपके ऐप्लिकेशन को ऐसे इस्तेमाल के मामलों की ज़रूरत हो जिनमें नहीं जोड़ा जा सकता, तो इनमें से कोई एक काम किया जा सकता है:
- इस्तेमाल के उदाहरण को एक साथ एक से ज़्यादा ग्रुप में बांटें फ़्रैगमेंट और फिर इनके बीच स्विच करें फ़्रैगमेंट
- अपनी पसंद के मुताबिक लाइफ़साइकल कॉम्पोनेंट बनाएं और मैन्युअल तरीके से कैमरे को कंट्रोल करने के लिए, इसका इस्तेमाल करें लाइफ़साइकल
अगर व्यू और कैमरे के इस्तेमाल के उदाहरण अलग किए जाएं, लाइफ़साइकल के मालिक (उदाहरण के लिए,
अगर कस्टम लाइफ़साइकल या निजी डेटा के रखरखाव की शर्तें पूरी करने के लिए,
फ़्रैगमेंट) हो, तो आपको
को यह पक्का करना होगा कि इस्तेमाल के सभी उदाहरण,
ProcessCameraProvider.unbindAll()
इस्तेमाल के हर उदाहरण को अलग से अनबाइंड करके भी ऐसा किया जा सकता है. इसके अलावा, जब इस्तेमाल को बाइंड किया जाता है
केस बनाते हैं, तो आप CameraX को
कैप्चर सेशन को खोलने और बंद करने और इस्तेमाल के उदाहरणों को अनबाइंड करने को मैनेज करता है.
अगर आपके कैमरे की सभी सुविधाएं, किसी एक कैमरे के लाइफ़साइकल से जुड़ी हैं
लाइफ़साइकल के बारे में जानकारी वाला कॉम्पोनेंट, जैसे कि
AppCompatActivity
या
AppCompat
फ़्रैगमेंट, फिर बाइंडिंग के दौरान उस कॉम्पोनेंट के लाइफ़साइकल का इस्तेमाल करना
अगर ज़रूरत के हिसाब से किसी तरह का इस्तेमाल किया जाता है, तो कैमरे की सुविधाएं इस्तेमाल के लिए तैयार हैं
जब लाइफ़साइकल की जानकारी वाला कॉम्पोनेंट चालू हो और उसे सुरक्षित तरीके से नष्ट किया गया हो, तो
नहीं लिया है.
कस्टम लाइफ़साइकल के मालिक
बेहतर केस के लिए, आप एक कस्टम
LifecycleOwner
चालू करके देखें
ऐप्लिकेशन, CameraX सेशन की लाइफ़साइकल को कंट्रोल करने के लिए
स्टैंडर्ड Android LifecycleOwner
.
नीचे दिया गया कोड सैंपल, एक सामान्य कस्टम LifecycleOwner बनाने का तरीका दिखाता है:
Kotlin
class CustomLifecycle : LifecycleOwner { private val lifecycleRegistry: LifecycleRegistry init { lifecycleRegistry = LifecycleRegistry(this); lifecycleRegistry.markState(Lifecycle.State.CREATED) } ... fun doOnResume() { lifecycleRegistry.markState(State.RESUMED) } ... override fun getLifecycle(): Lifecycle { return lifecycleRegistry } }
Java
public class CustomLifecycle implements LifecycleOwner { private LifecycleRegistry lifecycleRegistry; public CustomLifecycle() { lifecycleRegistry = new LifecycleRegistry(this); lifecycleRegistry.markState(Lifecycle.State.CREATED); } ... public void doOnResume() { lifecycleRegistry.markState(State.RESUMED); } ... public Lifecycle getLifecycle() { return lifecycleRegistry; } }
इस LifecycleOwner
का इस्तेमाल करके, आपका ऐप्लिकेशन अपनी ज़रूरत के हिसाब से स्टेटस में बदलाव कर सकता है
पॉइंट शामिल करते हैं. अपने ऐप्लिकेशन में इस सुविधा को लागू करने के बारे में ज़्यादा जानने के लिए,
देखें कि किसी कस्टम
लाइफ़साइकल मालिक.
एक साथ इस्तेमाल के उदाहरण
इस्तेमाल के उदाहरण एक साथ चल सकते हैं. हालांकि, इस्तेमाल के उदाहरण क्रम में
लाइफ़साइकल, इसलिए बेहतर होगा कि इस्तेमाल के सभी उदाहरणों को
CameraProcessProvider.bindToLifecycle()
. सबसे अच्छे
कॉन्फ़िगरेशन में बदलाव करने के तरीके, कॉन्फ़िगरेशन देखें
बदलाव के बारे में ज़्यादा जानें.
नीचे दिए गए कोड सैंपल में, ऐप्लिकेशन में इस्तेमाल के दो उदाहरण दिए गए हैं. और साथ-साथ चलाएं. यह दोनों इस्तेमाल में इस्तेमाल होने वाली लाइफ़साइकल के बारे में भी बताता है मामले, ताकि वे दोनों लाइफ़साइकल के हिसाब से शुरू और बंद हो जाएं.
Kotlin
private lateinit var imageCapture: ImageCapture override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) val cameraProviderFuture = ProcessCameraProvider.getInstance(this) cameraProviderFuture.addListener(Runnable { // Camera provider is now guaranteed to be available val cameraProvider = cameraProviderFuture.get() // Set up the preview use case to display camera preview. val preview = Preview.Builder().build() // Set up the capture use case to allow users to take photos. imageCapture = ImageCapture.Builder() .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY) .build() // Choose the camera by requiring a lens facing val cameraSelector = CameraSelector.Builder() .requireLensFacing(CameraSelector.LENS_FACING_FRONT) .build() // Attach use cases to the camera with the same lifecycle owner val camera = cameraProvider.bindToLifecycle( this as LifecycleOwner, cameraSelector, preview, imageCapture) // Connect the preview use case to the previewView preview.setSurfaceProvider( previewView.getSurfaceProvider()) }, ContextCompat.getMainExecutor(this)) }
Java
private ImageCapture imageCapture; @Override public void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); PreviewView previewView = findViewById(R.id.previewView); ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(this); cameraProviderFuture.addListener(() -> { try { // Camera provider is now guaranteed to be available ProcessCameraProvider cameraProvider = cameraProviderFuture.get(); // Set up the view finder use case to display camera preview Preview preview = new Preview.Builder().build(); // Set up the capture use case to allow users to take photos imageCapture = new ImageCapture.Builder() .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY) .build(); // Choose the camera by requiring a lens facing CameraSelector cameraSelector = new CameraSelector.Builder() .requireLensFacing(lensFacing) .build(); // Attach use cases to the camera with the same lifecycle owner Camera camera = cameraProvider.bindToLifecycle( ((LifecycleOwner) this), cameraSelector, preview, imageCapture); // Connect the preview use case to the previewView preview.setSurfaceProvider( previewView.getSurfaceProvider()); } catch (InterruptedException | ExecutionException e) { // Currently no exceptions thrown. cameraProviderFuture.get() // shouldn't block since the listener is being called, so no need to // handle InterruptedException. } }, ContextCompat.getMainExecutor(this)); }
नीचे दिए गए कॉन्फ़िगरेशन के कॉम्बिनेशन के साथ काम करने की गारंटी है (जब झलक देखना या वीडियो कैप्चर करना ज़रूरी है, लेकिन दोनों एक साथ नहीं:
प्रीव्यू या Videoकैप्चर | इमेज कैप्चर करना | विश्लेषण | ब्यौरे |
---|---|---|---|
उपयोगकर्ता को झलक दिखाएं या वीडियो रिकॉर्ड करें, फ़ोटो लें, और विश्लेषण करें इमेज स्ट्रीम में दिखाई देता है. | |||
फ़ोटो खींचें और इमेज स्ट्रीम का विश्लेषण करें. | |||
उपयोगकर्ता को झलक उपलब्ध कराएं या वीडियो रिकॉर्ड करें, और फ़ोटो लें. | |||
उपयोगकर्ता को झलक दें या वीडियो रिकॉर्ड करें और इमेज का विश्लेषण करें स्ट्रीम. |
जब झलक और वीडियो कैप्चर करना ज़रूरी हो, तब इस्तेमाल के ये उदाहरण दिए गए हैं संयोजन शर्तों के साथ समर्थित हैं:
झलक | वीडियो कैप्चर | इमेज कैप्चर करना | विश्लेषण | खास ज़रूरतें |
---|---|---|---|---|
सभी कैमरों के लिए गारंटी | ||||
सीमित (या बेहतर) कैमरा डिवाइस. | ||||
LEVEL_3 (या बेहतर) कैमरा डिवाइस. |
इसके अलावा,
- इस्तेमाल का हर उदाहरण अपने-आप काम कर सकता है. उदाहरण के लिए, कोई ऐप्लिकेशन वीडियो रिकॉर्ड कर सकता है और बिना झलक के अपने-आप जनरेट होते हैं.
- एक्सटेंशन के चालू होने पर, सिर्फ़
ImageCapture
औरPreview
संयोजन के रूप में काम करने की गारंटी है. OEM के इस्तेमाल के हिसाब से, शायदImageAnalysis
को जोड़ा न जा सके; एक्सटेंशनVideoCapture
के इस्तेमाल के उदाहरण के लिए चालू की जाएगी. सेटअप के निर्देश देखें एक्सटेंशन रेफ़रंस दस्तावेज़ देखें. - कैमरे की क्षमता के आधार पर, कुछ कैमरे कम रिज़ॉल्यूशन मोड, लेकिन कुछ डिवाइसों पर एक जैसे कॉम्बिनेशन काम नहीं कर सकते में हाई रिज़ॉल्यूशन का विकल्प मिलता है.
यह सुविधा देने वाले हार्डवेयर का लेवल
Camera2CameraInfo
से वापस लाया जा सकता है. उदाहरण के लिए, यह कोड
यह जांचता है कि पीछे वाला डिफ़ॉल्ट कैमरा LEVEL_3
डिवाइस है या नहीं:
Kotlin
@androidx.annotation.OptIn(ExperimentalCamera2Interop::class) fun isBackCameraLevel3Device(cameraProvider: ProcessCameraProvider) : Boolean { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { return CameraSelector.DEFAULT_BACK_CAMERA .filter(cameraProvider.availableCameraInfos) .firstOrNull() ?.let { Camera2CameraInfo.from(it) } ?.getCameraCharacteristic(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3 } return false }
Java
@androidx.annotation.OptIn(markerClass = ExperimentalCamera2Interop.class) Boolean isBackCameraLevel3Device(ProcessCameraProvider cameraProvider) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { List\<CameraInfo\> filteredCameraInfos = CameraSelector.DEFAULT_BACK_CAMERA .filter(cameraProvider.getAvailableCameraInfos()); if (!filteredCameraInfos.isEmpty()) { return Objects.equals( Camera2CameraInfo.from(filteredCameraInfos.get(0)).getCameraCharacteristic( CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL), CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3); } } return false; }
अनुमतियां
आपके ऐप्लिकेशन को इनकी ज़रूरत होगी
CAMERA
की अनुमति. यहां की यात्रा पर हूं
फ़ाइलों में इमेज सेव करें, तो इसके लिए यह भी ज़रूरी है कि
WRITE_EXTERNAL_STORAGE
अनुमति नहीं है. हालांकि, Android 10 या इसके बाद के वर्शन वाले डिवाइसों पर ऐसा किया जा सकता है.
अपने ऐप्लिकेशन के लिए अनुमतियां कॉन्फ़िगर करने के बारे में ज़्यादा जानकारी के लिए, अनुरोध करें ऐप्लिकेशन अनुमतियां.
ज़रूरी शर्तें
CameraX के लिए ज़रूरी कम से कम ये वर्शन ज़रूरी हैं:
- Android एपीआई लेवल 21
- Android आर्किटेक्चर के कॉम्पोनेंट 1.1.1
लाइफ़साइकल के बारे में जानकारी देने वाली गतिविधियों के लिए, इसका इस्तेमाल करें
FragmentActivity
या
AppCompatActivity
.
डिपेंडेंसी बताएं
CameraX पर डिपेंडेंसी जोड़ने के लिए, आपको Google Maven जोड़ना होगा डेटा स्टोर करने की जगह को भी अपने प्रोजेक्ट में सेव करें.
अपने प्रोजेक्ट की settings.gradle
फ़ाइल खोलें और google()
डेटा स्टोर करने की जगह जोड़ें
जैसा कि नीचे दिखाया गया है:
ग्रूवी
dependencyResolutionManagement { repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) repositories { google() mavenCentral() } }
Kotlin
dependencyResolutionManagement { repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) repositories { google() mavenCentral() } }
Android ब्लॉक के अंत में निम्न जोड़ें:
ग्रूवी
android { compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } // For Kotlin projects kotlinOptions { jvmTarget = "1.8" } }
Kotlin
android { compileOptions { sourceCompatibility = JavaVersion.VERSION_1_8 targetCompatibility = JavaVersion.VERSION_1_8 } // For Kotlin projects kotlinOptions { jvmTarget = "1.8" } }
किसी ऐप्लिकेशन के लिए, हर मॉड्यूल की build.gradle
फ़ाइल में ये चीज़ें जोड़ें:
ग्रूवी
dependencies { // CameraX core library using the camera2 implementation def camerax_version = "1.4.0-rc01" // The following line is optional, as the core library is included indirectly by camera-camera2 implementation "androidx.camera:camera-core:${camerax_version}" implementation "androidx.camera:camera-camera2:${camerax_version}" // If you want to additionally use the CameraX Lifecycle library implementation "androidx.camera:camera-lifecycle:${camerax_version}" // If you want to additionally use the CameraX VideoCapture library implementation "androidx.camera:camera-video:${camerax_version}" // If you want to additionally use the CameraX View class implementation "androidx.camera:camera-view:${camerax_version}" // If you want to additionally add CameraX ML Kit Vision Integration implementation "androidx.camera:camera-mlkit-vision:${camerax_version}" // If you want to additionally use the CameraX Extensions library implementation "androidx.camera:camera-extensions:${camerax_version}" }
Kotlin
dependencies { // CameraX core library using the camera2 implementation val camerax_version = "1.4.0-rc01" // The following line is optional, as the core library is included indirectly by camera-camera2 implementation("androidx.camera:camera-core:${camerax_version}") implementation("androidx.camera:camera-camera2:${camerax_version}") // If you want to additionally use the CameraX Lifecycle library implementation("androidx.camera:camera-lifecycle:${camerax_version}") // If you want to additionally use the CameraX VideoCapture library implementation("androidx.camera:camera-video:${camerax_version}") // If you want to additionally use the CameraX View class implementation("androidx.camera:camera-view:${camerax_version}") // If you want to additionally add CameraX ML Kit Vision Integration implementation("androidx.camera:camera-mlkit-vision:${camerax_version}") // If you want to additionally use the CameraX Extensions library implementation("androidx.camera:camera-extensions:${camerax_version}") }
अपने ऐप्लिकेशन को इन ज़रूरी शर्तों के मुताबिक कॉन्फ़िगर करने के बारे में ज़्यादा जानकारी के लिए, देखें एलान किया जा रहा है डिपेंडेंसी.
Camera2 के साथ CameraX की इंटरऑपरेबिलिटी (दूसरे सिस्टम के साथ काम करना)
CameraX, Camera2 पर बना होता है. CameraX, पढ़ने और लिखने में मदद करता है प्रॉपर्टी शामिल हैं. पूरी जानकारी के लिए, यह देखें इंटरऑप पैकेज.
CameraX ने Camera2 प्रॉपर्टी को कैसे कॉन्फ़िगर किया है, इस बारे में ज़्यादा जानकारी के लिए, इसका इस्तेमाल करें
Camera2CameraInfo
दिए गए CameraCharacteristics
फ़ंक्शन को पढ़ने के लिए. आपके पास पहले से मौजूद Camera2 को लिखने का विकल्प भी है
प्रॉपर्टी नीचे दी गई दो में से किसी एक पाथवे में मौजूद हैं:
Camera2CameraControl
का इस्तेमाल करें, इससे आपको प्रॉपर्टी को बुनियादी तौर परCaptureRequest
, जैसे कि ऑटो-फ़ोकस मोड.CameraX
UseCase
कोCamera2Interop.Extender
. इससे आप CaptureRequest पर प्रॉपर्टी सेट कर सकते हैं, जैसेCamera2CameraControl
. इससे आपको कुछ और कंट्रोल भी मिलते हैं. जैसे, स्ट्रीम के इस्तेमाल का उदाहरण सेट करना कैमरे को अपने इस्तेमाल के उदाहरण के हिसाब से ऑप्टिमाइज़ करें. जानकारी के लिए, स्ट्रीम के इस्तेमाल के उदाहरण देखना परफ़ॉर्मेंस.
नीचे दिया गया कोड सैंपल, वीडियो कॉल के लिए ऑप्टिमाइज़ करने के लिए, स्ट्रीम के इस्तेमाल के उदाहरणों का इस्तेमाल करता है.
Camera2CameraInfo
का इस्तेमाल करें
का इस्तेमाल करके यह पता लगाया जा सकता है कि वीडियो कॉल स्ट्रीम के इस्तेमाल का उदाहरण उपलब्ध है या नहीं. इसके बाद, किसी
Camera2Interop.Extender
का इस्तेमाल करें.
Kotlin
// Set underlying Camera2 stream use case to optimize for video calls. val videoCallStreamId = CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong() // Check available CameraInfos to find the first one that supports // the video call stream use case. val frontCameraInfo = cameraProvider.getAvailableCameraInfos() .first { cameraInfo -> val isVideoCallStreamingSupported = Camera2CameraInfo.from(cameraInfo) .getCameraCharacteristic( CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES )?.contains(videoCallStreamId) val isFrontFacing = (cameraInfo.getLensFacing() == CameraSelector.LENS_FACING_FRONT) (isVideoCallStreamingSupported == true) && isFrontFacing } val cameraSelector = frontCameraInfo.cameraSelector // Start with a Preview Builder. val previewBuilder = Preview.Builder() .setTargetAspectRatio(screenAspectRatio) .setTargetRotation(rotation) // Use Camera2Interop.Extender to set the video call stream use case. Camera2Interop.Extender(previewBuilder).setStreamUseCase(videoCallStreamId) // Bind the Preview UseCase and the corresponding CameraSelector. val preview = previewBuilder.build() camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)
Java
// Set underlying Camera2 stream use case to optimize for video calls. Long videoCallStreamId = CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong(); // Check available CameraInfos to find the first one that supports // the video call stream use case. List<CameraInfo> cameraInfos = cameraProvider.getAvailableCameraInfos(); CameraInfo frontCameraInfo = null; for (cameraInfo in cameraInfos) { Long[] availableStreamUseCases = Camera2CameraInfo.from(cameraInfo) .getCameraCharacteristic( CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES ); boolean isVideoCallStreamingSupported = Arrays.List(availableStreamUseCases) .contains(videoCallStreamId); boolean isFrontFacing = (cameraInfo.getLensFacing() == CameraSelector.LENS_FACING_FRONT); if (isVideoCallStreamingSupported && isFrontFacing) { frontCameraInfo = cameraInfo; } } if (frontCameraInfo == null) { // Handle case where video call streaming is not supported. } CameraSelector cameraSelector = frontCameraInfo.getCameraSelector(); // Start with a Preview Builder. Preview.Builder previewBuilder = Preview.Builder() .setTargetAspectRatio(screenAspectRatio) .setTargetRotation(rotation); // Use Camera2Interop.Extender to set the video call stream use case. Camera2Interop.Extender(previewBuilder).setStreamUseCase(videoCallStreamId); // Bind the Preview UseCase and the corresponding CameraSelector. Preview preview = previewBuilder.build() Camera camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)
अन्य संसाधन
CameraX के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें.
कोडलैब (कोड बनाना सीखना)
कोड सैंपल