एआई ग्लास के हार्डवेयर को ऐक्सेस करने के लिए, प्रोजेक्ट किए गए कॉन्टेक्स्ट का इस्तेमाल करना

एक्सआर की सुविधा वाले डिवाइस

इस गाइड की मदद से, इन तरह के एक्सआर डिवाइसों के लिए अनुभव बनाए जा सकते हैं.

XR डिवाइसों के टाइप के बारे में जानें →

XR डिवाइसों के टाइप के बारे में जानें →

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

प्रोजेक्ट किए गए कॉन्टेक्स्ट को पाने के दो मुख्य तरीके हैं. ये तरीके इस बात पर निर्भर करते हैं कि आपका कोड कहां चल रहा है:

अगर आपका कोड, एआई चश्मे की गतिविधि में चल रहा है, तो अनुमानित कॉन्टेक्स्ट पाएं

अगर आपके ऐप्लिकेशन का कोड, एआई चश्मे पर की गई गतिविधि के डेटा से चल रहा है, तो उसकी गतिविधि का कॉन्टेक्स्ट पहले से ही प्रोजेक्ट किया गया कॉन्टेक्स्ट होता है. इस स्थिति में, उस गतिविधि के दौरान किए गए कॉल, चश्मे के हार्डवेयर को पहले से ही ऐक्सेस कर सकते हैं.

अगर आपका कोड, फ़ोन ऐप्लिकेशन कॉम्पोनेंट में चल रहा है, तो प्रोजेक्ट किया गया कॉन्टेक्स्ट पाएं

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

// From a phone Activity, get a context for the AI glasses
try {
    val glassesContext = ProjectedContext.createProjectedDeviceContext(this)
    // Now use glassesContext to access glasses' system services
} catch (e: IllegalStateException) {
    // Projected device was not found
}

मान्य है या नहीं, इसकी जांच करना

अनुमानित कॉन्टेक्स्ट बनाने के बाद, ProjectedContext.isProjectedDeviceConnected पर नज़र रखें. यह तरीका true दिखाता है. हालांकि, कनेक्ट किए गए डिवाइस के लिए प्रोजेक्ट किया गया कॉन्टेक्स्ट मान्य रहता है. साथ ही, आपके फ़ोन ऐप्लिकेशन की गतिविधि या सेवा (जैसे कि CameraManager) एआई चश्मे के हार्डवेयर को ऐक्सेस कर सकती है.

डिसकनेक्ट होने पर डेटा मिटाएं

प्रोजेक्ट किया गया कॉन्टेक्स्ट, कनेक्ट किए गए डिवाइस के लाइफ़साइकल से जुड़ा होता है. इसलिए, डिवाइस के डिसकनेक्ट होने पर यह मिट जाता है. डिवाइस के डिसकनेक्ट होने पर, ProjectedContext.isProjectedDeviceConnected false दिखाता है. आपके ऐप्लिकेशन को इस बदलाव के बारे में पता होना चाहिए. साथ ही, उसे उन सभी सिस्टम सेवाओं (जैसे कि CameraManager) या संसाधनों को बंद कर देना चाहिए जिन्हें आपके ऐप्लिकेशन ने प्रोजेक्ट किए गए कॉन्टेक्स्ट का इस्तेमाल करके बनाया था.

फिर से कनेक्ट करने पर, फिर से शुरू करें

जब एआई चश्मे का डिवाइस फिर से कनेक्ट होता है, तो आपका ऐप्लिकेशन createProjectedDeviceContext() का इस्तेमाल करके, प्रोजेक्ट किए गए कॉन्टेक्स्ट का दूसरा इंस्टेंस पा सकता है. इसके बाद, प्रोजेक्ट किए गए नए कॉन्टेक्स्ट का इस्तेमाल करके, सिस्टम की किसी भी सेवा या संसाधन को फिर से शुरू कर सकता है.

ब्लूटूथ का इस्तेमाल करके ऑडियो ऐक्सेस करना

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

किसी भी स्टैंडर्ड ब्लूटूथ ऑडियो डिवाइस की तरह, RECORD_AUDIO अनुमति देने का कंट्रोल फ़ोन के पास होता है, न कि चश्मे के पास.

एआई चश्मे के कैमरे से इमेज कैप्चर करना

एआई चश्मे के कैमरे से इमेज कैप्चर करने के लिए, CameraX के ImageCapture use case को चश्मे के कैमरे से सेट अप करें और बाइंड करें. इसके लिए, अपने ऐप्लिकेशन के लिए सही कॉन्टेक्स्ट का इस्तेमाल करें:

private fun startCamera() {
    // Get the CameraProvider using the projected context.

    val cameraProviderFuture = ProcessCameraProvider.getInstance(
        ProjectedContext.createProjectedDeviceContext(this)
    )

    cameraProviderFuture.addListener({
        // Used to bind the lifecycle of cameras to the lifecycle owner
        val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()

        // Select the camera. When using the projected context, DEFAULT_BACK_CAMERA maps to the AI glasses' camera.
        val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
    
        // Check for the presence of a camera before initializing the ImageCapture use case.
       if (!cameraProvider.hasCamera(cameraSelector)) {
            Log.w(TAG, "The selected camera is not available.")
            return@addListener
        }

        // Get supported streaming resolutions.
        val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)
        val camera2CameraInfo = Camera2CameraInfo.from(cameraInfo)
        val cameraCharacteristics = camera2CameraInfo.getCameraCharacteristic(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)

        // Define the resolution strategy.
        val targetResolution = Size(1920, 1080)
        val resolutionStrategy = ResolutionStrategy(
            targetResolution,
            ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER)

        val resolutionSelector = ResolutionSelector.Builder()
            .setResolutionStrategy(resolutionStrategy)
            .build()

        // If you have other continuous use cases bound, such as Preview or ImageAnalysis, you can use  Camera2 Interop's CaptureRequestOptions to set the FPS
        val fpsRange = Range(30, 30)
        val captureRequestOptions = CaptureRequestOptions.Builder()
                .setCaptureRequestOption(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,fpsRange)
                .build()

        // Initialize the ImageCapture use case.
        val imageCapture = ImageCapture.Builder()
            // Optional: Configure resolution, format, etc.
            .setResolutionSelector(resolutionSelector)
            .build()

        try {
            // Unbind use cases before rebinding
            cameraProvider.unbindAll()

            // 4. Bind use cases to camera
            cameraProvider.bindToLifecycle(this as LifecycleOwner, cameraSelector, imageCapture)

        } catch(exc: Exception) {
            // This catches exceptions like IllegalStateException if use case binding fails
            Log.e(TAG, "Use case binding failed", exc)
        }

    }, ContextCompat.getMainExecutor(this))
}

कोड के बारे में अहम जानकारी

• प्रोजेक्ट किए गए डिवाइस के कॉन्टेक्स्ट का इस्तेमाल करके, ProcessCameraProvider का इंस्टेंस पाता है.
• प्रोजेक्ट किए गए कॉन्टेक्स्ट के स्कोप में, एआई चश्मे का मुख्य कैमरा, बाहर की ओर पॉइंट करने वाला कैमरा होता है. यह कैमरा चुनने पर DEFAULT_BACK_CAMERA पर मैप होता है.
• प्री-बाइंडिंग चेक, cameraProvider.hasCamera(cameraSelector) का इस्तेमाल करके यह पुष्टि करता है कि चुना गया कैमरा, डिवाइस पर उपलब्ध है या नहीं. इसके बाद ही, आगे की प्रोसेस शुरू की जाती है.
• यह Camera2 Interop का इस्तेमाल करके Camera2CameraInfo को पढ़ता है. इससे CameraCharacteristics#SCALER_STREAM_CONFIGURATION_MAP की जानकारी मिलती है. यह सुविधा, काम करने वाले रिज़ॉल्यूशन की बेहतर तरीके से जांच करने के लिए फ़ायदेमंद हो सकती है.
• कस्टम ResolutionSelector को ImageCapture के लिए, आउटपुट इमेज के रिज़ॉल्यूशन को सटीक तरीके से कंट्रोल करने के लिए बनाया गया है.
• यह फ़ंक्शन, ImageCapture यूज़ केस बनाता है, जिसे कस्टम ResolutionSelector के साथ कॉन्फ़िगर किया जाता है.
• ImageCapture यूज़ केस को ऐक्टिविटी के लाइफ़साइकल से बाइंड करता है. यह कैमरे को अपने-आप चालू और बंद करता है. ऐसा गतिविधि की स्थिति के आधार पर किया जाता है. उदाहरण के लिए, गतिविधि के रुकने पर कैमरे को बंद कर दिया जाता है.

एआई चश्मे का कैमरा सेट अप करने के बाद, CameraX की ImageCapture क्लास की मदद से इमेज कैप्चर की जा सकती है. takePicture() का इस्तेमाल करके इमेज कैप्चर करने के बारे में जानने के लिए, CameraX का दस्तावेज़ देखें.

एआई चश्मे के कैमरे से वीडियो कैप्चर करना

एआई चश्मे के कैमरे से इमेज के बजाय वीडियो कैप्चर करने के लिए, ImageCapture कॉम्पोनेंट को VideoCapture कॉम्पोनेंट से बदलें. साथ ही, कैप्चर करने के लॉजिक में बदलाव करें.

मुख्य बदलावों में, इस्तेमाल के अलग-अलग उदाहरणों का इस्तेमाल करना, अलग आउटपुट फ़ाइल बनाना, और वीडियो रिकॉर्डिंग के सही तरीके का इस्तेमाल करके कैप्चर करना शामिल है. VideoCapture एपीआई और इसे इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, CameraX के वीडियो कैप्चर से जुड़े दस्तावेज़ देखें.

यहां दी गई टेबल में, आपके ऐप्लिकेशन के इस्तेमाल के उदाहरण के हिसाब से, सुझाया गया रिज़ॉल्यूशन और फ़्रेम रेट दिखाया गया है:

एआई ग्लास की गतिविधि से फ़ोन के हार्डवेयर को ऐक्सेस करना

एआई चश्मे की गतिविधि, फ़ोन के हार्डवेयर (जैसे कि कैमरा या माइक्रोफ़ोन) को भी ऐक्सेस कर सकती है. इसके लिए, वह createHostDeviceContext(context) का इस्तेमाल करके, होस्ट डिवाइस (फ़ोन) का कॉन्टेक्स्ट हासिल करती है:

// From an AI glasses Activity, get a context for the phone
val phoneContext = ProjectedContext.createHostDeviceContext(this)
// Now use phoneContext to access the phone's hardware

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

• फ़ोन Activity से Activity कॉन्टेक्स्ट या ProjectedContext.createHostDeviceContext() का इस्तेमाल करके, फ़ोन का कॉन्टेक्स्ट पाएं.
• getApplicationContext() का इस्तेमाल न करें, क्योंकि ऐप्लिकेशन कॉन्टेक्स्ट, एआई चश्मे के कॉन्टेक्स्ट को गलत तरीके से दिखा सकता है. ऐसा तब होता है, जब चश्मे से जुड़ी गतिविधि को हाल ही में लॉन्च किया गया हो.