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

इन XR डिवाइसों पर लागू होता है

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

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

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

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

आपके कोड के चलने की जगह के आधार पर, अनुमानित कॉन्टेक्स्ट पाने के दो मुख्य तरीके हैं:

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

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

किसी फ़ोन ऐप्लिकेशन कॉम्पोनेंट में चल रहे कोड के लिए, अनुमानित कॉन्टेक्स्ट पाना

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

@OptIn(ExperimentalProjectedApi::class)
private fun getGlassesContext(context: Context): Context? {
    return try {
        // From a phone Activity or Service, get a context for the AI glasses.
        ProjectedContext.createProjectedDeviceContext(context)
    } catch (e: IllegalStateException) {
        Log.e(TAG, "Failed to create projected device context", e)
        null
    }
}
ProjectedHardware.kt

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

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

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

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

दोबारा कनेक्ट करने पर, फिर से शुरू करें

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

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

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

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

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

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

private fun startCameraOnGlasses(activity: ComponentActivity) {
    // 1. Get the CameraProvider using the projected context.
    // When using the projected context, DEFAULT_BACK_CAMERA maps to the AI glasses' camera.
    val projectedContext = try {
        ProjectedContext.createProjectedDeviceContext(activity)
    } catch (e: IllegalStateException) {
        Log.e(TAG, "AI Glasses context could not be created", e)
        return
    }

    val cameraProviderFuture = ProcessCameraProvider.getInstance(projectedContext)

    cameraProviderFuture.addListener({
        val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
        val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

        // 2. Check for the presence of a camera.
        if (!cameraProvider.hasCamera(cameraSelector)) {
            Log.w(TAG, "The selected camera is not available.")
            return@addListener
        }

        // 3. Query supported streaming resolutions using Camera2 Interop.
        val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)
        val camera2CameraInfo = Camera2CameraInfo.from(cameraInfo)
        val cameraCharacteristics = camera2CameraInfo.getCameraCharacteristic(
            CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
        )

        // 4. 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()

        // 5. 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, 60)
        val captureRequestOptions = CaptureRequestOptions.Builder()
            .setCaptureRequestOption(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange)
            .build()

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

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

            // Bind use cases to camera using the Activity as the LifecycleOwner.
            cameraProvider.bindToLifecycle(
                activity,
                cameraSelector,
                imageCapture
            )
        } catch (exc: Exception) {
            Log.e(TAG, "Use case binding failed", exc)
        }
    }, ContextCompat.getMainExecutor(activity))
}
ProjectedHardware.kt

कोड के बारे में अहम बातें

• प्रोजेक्ट किए गए डिवाइस के कॉन्टेक्स्ट का इस्तेमाल करके, 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) का इस्तेमाल करके, होस्ट डिवाइस (फ़ोन) का कॉन्टेक्स्ट मिलता है:

@OptIn(ExperimentalProjectedApi::class)
private fun getPhoneContext(activity: ComponentActivity): Context? {
    return try {
        // From an AI glasses Activity, get a context for the phone.
        ProjectedContext.createHostDeviceContext(activity)
    } catch (e: IllegalStateException) {
        Log.e(TAG, "Failed to create host device context", e)
        null
    }
}
ProjectedHardware.kt

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

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