ज़रूरी अनुमतियों का अनुरोध करने और उन्हें पाने के बाद, आपका ऐप्लिकेशन ऑडियो ग्लास या डिसप्ले ग्लास के हार्डवेयर को ऐक्सेस कर सकता है. फ़ोन के हार्डवेयर के बजाय, स्मार्ट ग्लास के हार्डवेयर को ऐक्सेस करने के लिए, प्रोजेक्ट किए गए कॉन्टेक्स्ट का इस्तेमाल करना ज़रूरी है.
प्रोजेक्ट किया गया कॉन्टेक्स्ट पाने के दो मुख्य तरीके हैं. यह इस बात पर निर्भर करता है कि आपका कोड कहां लागू हो रहा है:
अगर आपका कोड किसी प्रोजेक्ट की गई गतिविधि में चल रहा है, तो प्रोजेक्ट किया गया कॉन्टेक्स्ट पाएं
अगर आपके ऐप्लिकेशन का कोड, प्रोजेक्ट की गई गतिविधि से चल रहा है, तो उसकी गतिविधि का कॉन्टेक्स्ट पहले से ही प्रोजेक्ट किया गया कॉन्टेक्स्ट होता है. इस स्थिति में, उस गतिविधि के दौरान किए गए कॉल, स्मार्ट ग्लास के हार्डवेयर को पहले से ही ऐक्सेस कर सकते हैं.
फ़ोन ऐप्लिकेशन के कॉम्पोनेंट में चल रहे कोड के लिए, प्रोजेक्ट किया गया कॉन्टेक्स्ट पाना
अगर आपके ऐप्लिकेशन के किसी ऐसे हिस्से को स्मार्ट ग्लास के हार्डवेयर को ऐक्सेस करना है जो प्रोजेक्ट की गई गतिविधि से बाहर है, तो उसे साफ़ तौर पर प्रोजेक्ट किया गया कॉन्टेक्स्ट हासिल करना होगा. जैसे, फ़ोन की कोई गतिविधि या कोई सेवा. इसके लिए, createProjectedDeviceContext तरीके का इस्तेमाल करें:
@RequiresApi(Build.VERSION_CODES.BAKLAVA) @OptIn(ExperimentalProjectedApi::class, ExperimentalCoroutinesApi::class) private fun monitorProjectedConnectivity(activity: ComponentActivity) { activity.lifecycleScope.launch { // Before creating a projected context, check to see if the projected device is connected. // While this method returns true, the projected context remains valid. ProjectedContext.isProjectedDeviceConnected(activity, coroutineContext) .collectLatest { isConnected -> if (isConnected) { // From a phone Activity or Service, get a context for the audio and display glasses. // Re-initialize on reconnect: Obtain another context instance. val projectedContext = try { ProjectedContext.createProjectedDeviceContext(activity) } catch (e: IllegalStateException) { Log.e(TAG, "Failed to create projected context", e) return@collectLatest } // Use the projectedContext to initialize system services (e.g., CameraManager). Log.i(TAG, "Projected device connected. Initializing hardware...") } else { // The projected context is destroyed when the device disconnects. // Clean up on disconnect: Listen for 'false' and release resources. Log.i(TAG, "Projected device disconnected. Cleaning up hardware resources...") } } } }
मान्य है या नहीं, इसकी जांच करें
createProjectedDeviceContext कॉल को ProjectedContext.isProjectedDeviceConnected में रैप करें. यह तरीका true दिखाता है, लेकिन प्रोजेक्ट किया गया कॉन्टेक्स्ट, कनेक्ट किए गए डिवाइस के लिए मान्य रहता है. साथ ही, आपके फ़ोन ऐप्लिकेशन की गतिविधि या सेवा (जैसे, CameraManager), स्मार्ट ग्लास के हार्डवेयर को ऐक्सेस कर सकती है.
डिसकनेक्ट होने पर क्लीन अप करना
प्रोजेक्ट किया गया कॉन्टेक्स्ट, कनेक्ट किए गए डिवाइस की लाइफ़साइकल से जुड़ा होता है. इसलिए, डिवाइस के डिसकनेक्ट होने पर यह खत्म हो जाता है. डिवाइस के डिसकनेक्ट होने पर,
ProjectedContext.isProjectedDeviceConnected, false दिखाता है. आपके ऐप्लिकेशन को इस बदलाव पर नज़र रखनी चाहिए. साथ ही, सिस्टम की उन सभी सेवाओं (जैसे, CameraManager) या संसाधनों को हटा देना चाहिए जिन्हें आपके ऐप्लिकेशन ने उस प्रोजेक्ट किए गए कॉन्टेक्स्ट का इस्तेमाल करके बनाया है.
दोबारा कनेक्ट करने पर, फिर से शुरू करें
जब स्मार्ट ग्लास फिर से कनेक्ट हो जाता है, तो आपका ऐप्लिकेशन createProjectedDeviceContext का इस्तेमाल करके, प्रोजेक्ट किए गए कॉन्टेक्स्ट का दूसरा इंस्टेंस हासिल कर सकता है. इसके बाद, प्रोजेक्ट किए गए नए कॉन्टेक्स्ट का इस्तेमाल करके, सिस्टम की किसी भी सेवा या संसाधन को फिर से शुरू किया जा सकता है.
स्मार्ट ग्लास के माइक्रोफ़ोन से ऑडियो रिकॉर्ड करना
ब्लूटूथ हैंड्स-फ़्री प्रोफ़ाइल (एचएफ़पी) का इस्तेमाल करके, स्मार्ट ग्लास से ऑडियो रिकॉर्ड किया जा सकता है. इस मोड में, स्मार्ट ग्लास स्टैंडर्ड हेडसेट और ऐडवांस्ड ऑडियो डिस्ट्रिब्यूशन प्रोफ़ाइल (A2DP) प्रोफ़ाइल का इस्तेमाल करके, फ़ोन से कनेक्ट होते हैं. ये सामान्य ब्लूटूथ डिवाइस की तरह काम करते हैं. अगर आपका ऐप्लिकेशन पहले से ही स्टैंडर्ड ब्लूटूथ रिकॉर्डिंग के लिए डिज़ाइन किया गया है, तो इस तरीके का इस्तेमाल करके स्मार्ट ग्लास से ऑडियो रिकॉर्ड किया जा सकता है. इसके लिए, आपको कोई अतिरिक्त डेवलपमेंट करने की ज़रूरत नहीं है.
ब्लूटूथ एचएफ़पी का इस्तेमाल करके ऑडियो रिकॉर्ड करना
ब्लूटूथ एचएफ़पी का इस्तेमाल करके ऑडियो रिकॉर्ड करने के लिए, पहले रनटाइम की ज़रूरी अनुमतियों का अनुरोध करें. इसके बाद, AudioManager एपीआई का इस्तेमाल करके ऑडियो रिकॉर्ड करें. इसके बारे में यहां बताया गया है.
अनुमतियों का अनुरोध करें
किसी भी स्टैंडर्ड ब्लूटूथ ऑडियो डिवाइस की तरह, RECORD_AUDIO, BLUETOOTH_CONNECT, और अन्य ज़रूरी अनुमतियों को फ़ोन से कंट्रोल किया जाता है, न कि कनेक्ट किए गए डिवाइस (जैसे, ऑडियो ग्लास या डिसप्ले ग्लास) से.
अनुमतियों का अनुरोध करने के लिए, यह तरीका अपनाएं:
अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल में, इन अनुमतियों का एलान करें:
Android की अनुमति के स्टैंडर्ड फ़्लो का इस्तेमाल करके, रनटाइम के दौरान
RECORD_AUDIOऔरBLUETOOTH_CONNECT, दोनों अनुमतियों का अनुरोध करें.
ऑडियो रूट करने के लिए AudioManager का इस्तेमाल करना
जब उपयोगकर्ता आपके ऐप्लिकेशन को रनटाइम की ज़रूरी अनुमतियां दे दे, तब ब्लूटूथ एचएफ़पी के ज़रिए ऑडियो रूट करने के लिए, AudioManager एपीआई का इस्तेमाल करके, कम्यूनिकेशन डिवाइस को TYPE_BLUETOOTH_SCO पर सेट करें. इससे सिस्टम को ब्लूटूथ पेरिफ़ेरल से ऑडियो पाने का निर्देश मिलता है.
val audioManager = context.getSystemService(AudioManager::class.java) ?: return val hfpDevice = audioManager.availableCommunicationDevices .firstOrNull { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO } ?: return // HFP input is limited to 16 kHz, with mono or stereo channel configurations. val sampleRate = 16_000 val channelMask = AudioFormat.CHANNEL_IN_MONO val encoding = AudioFormat.ENCODING_PCM_16BIT // Use a small multiple of the minimum buffer size to keep chunks short for low latency. val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelMask, encoding) if (minBufferSize <= 0) return val audioRecord = AudioRecord.Builder() .setAudioSource(MediaRecorder.AudioSource.VOICE_COMMUNICATION) .setAudioFormat( AudioFormat.Builder() .setSampleRate(sampleRate) .setChannelMask(channelMask) .setEncoding(encoding) .build() ) .setBufferSizeInBytes(minBufferSize * 2) .build() try { // Route voice communication audio through the Bluetooth device. if (!audioManager.setCommunicationDevice(hfpDevice)) return audioRecord.startRecording() // Read audio with audioRecord.read() on a background thread. } finally { // Stop and release when done. if (audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING) audioRecord.stop() audioRecord.release() audioManager.clearCommunicationDevice() }
स्मार्ट ग्लास के कैमरे से कोई इमेज कैप्चर करना
स्मार्ट ग्लास के कैमरे से इमेज कैप्चर करने के लिए, CameraX के ImageCapture इस्तेमाल के उदाहरण को सेट अप करें और उसे स्मार्ट ग्लास के कैमरे से बाइंड करें. इसके लिए, अपने ऐप्लिकेशन के लिए सही कॉन्टेक्स्ट का इस्तेमाल करें:
private fun setUpGlassesCamera(activity: ComponentActivity) { activity.lifecycleScope.launch { // Before creating a projected context, check to see if the projected device is connected. ProjectedContext.isProjectedDeviceConnected(activity, coroutineContext) .collectLatest { isConnected -> if (isConnected) { // 1. Get the CameraProvider using the projected context. // When using the projected context, DEFAULT_BACK_CAMERA maps to the audio and display glasses' camera. val projectedContext = try { ProjectedContext.createProjectedDeviceContext(activity) } catch (e: IllegalStateException) { Log.e(TAG, "Projected context could not be created", e) return@collectLatest } 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 dynamically using Camera2 Interop. val cameraInfo = cameraProvider.getCameraInfo(cameraSelector) val map = Camera2CameraInfo.from(cameraInfo).getCameraCharacteristic( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP ) val supportedResolutions = map?.getOutputSizes(ImageFormat.JPEG)?.toList() ?: emptyList() Log.i(TAG, "Supported resolutions for JPEG: ${supportedResolutions.joinToString()}") // 4. Dynamically select the best target resolution from the queried list. val preferredResolution = Size(1920, 1080) val dynamicTargetResolution = when { // Case A: The preferred resolution is explicitly supported by the glasses. supportedResolutions.contains(preferredResolution) -> preferredResolution // Case B: Find the highest supported 16:9 resolution as a fallback. else -> { val targetAspectRatio = 16.0 / 9.0 val tolerance = 0.01 supportedResolutions .filter { abs((it.width.toDouble() / it.height) - targetAspectRatio) < tolerance } .maxByOrNull { it.width * it.height } // Case C: Absolute fallback if no 16:9 resolutions are found. ?: supportedResolutions.firstOrNull() ?: preferredResolution } } Log.i(TAG, "Selected target resolution: $dynamicTargetResolution") val resolutionStrategy = ResolutionStrategy( dynamicTargetResolution, ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER ) val resolutionSelector = ResolutionSelector.Builder() .setResolutionStrategy(resolutionStrategy) .build() // 5. 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)) } } } }
कोड के बारे में अहम बातें
- प्रोजेक्ट किए गए डिवाइस के कॉन्टेक्स्ट का इस्तेमाल करके,
ProcessCameraProviderका इंस्टेंस हासिल करता है. - प्रोजेक्ट किए गए कॉन्टेक्स्ट के स्कोप में, स्मार्ट ग्लास का प्राइमरी और बाहर की ओर दिखने वाला कैमरा, कैमरा चुनते समय
DEFAULT_BACK_CAMERAपर मैप होता है. - प्री-बाइंडिंग जांच में
cameraProvider.hasCamera(cameraSelector)का इस्तेमाल किया जाता है, ताकि आगे बढ़ने से पहले यह पुष्टि की जा सके कि चुना गया कैमरा डिवाइस पर उपलब्ध है या नहीं. - यह
Camera2CameraInfoके साथ Camera2 Interop का इस्तेमाल करके,CameraCharacteristics#SCALER_STREAM_CONFIGURATION_MAPको पढ़ता है. इससे, काम करने वाले रिज़ॉल्यूशन की बेहतर जांच करने में मदद मिल सकती है. ImageCaptureके लिए, आउटपुट इमेज के रिज़ॉल्यूशन को सटीक तरीके से कंट्रोल करने के लिए, एक कस्टमResolutionSelectorबनाया गया है.- यह
ImageCaptureके इस्तेमाल का ऐसा उदाहरण बनाता है जिसे कस्टमResolutionSelectorके साथ कॉन्फ़िगर किया गया है. - यह
ImageCaptureके इस्तेमाल के उदाहरण को गतिविधि की लाइफ़साइकल से बाइंड करता है. यह गतिविधि की स्थिति के आधार पर, कैमरे के चालू और बंद होने की प्रोसेस को अपने-आप मैनेज करता है. उदाहरण के लिए, गतिविधि के रोके जाने पर कैमरे को बंद करना. - सिंगल-स्ट्रीम हार्डवेयर के लिए कॉन्फ़िगर करना: स्मार्ट ग्लास के कैमरे की पाइपलाइन, एक समय में सिर्फ़ एक ऐक्टिव स्ट्रीम तक सीमित होती है. जब
ImageCaptureको अकेले बाउंड किया जाता है, तो CameraX डिफ़ॉल्ट रूप से फ़ोकस और मीटरिंग के लिए, इंटरनल रिपीटिंग स्ट्रीम (MeteringRepeating) अटैच करता है. इससे सिंगल-स्ट्रीम पाइपलाइन रुक जाती है.ImageCaptureको बिना किसी झलक वाली स्ट्रीम के बाइंड करने के लिए,CameraXConfig.BuilderपरsetRepeatingStreamForced(false)सेट करके, बार-बार दोहराई जाने वाली स्ट्रीम को बंद करें. उदाहरण के लिए, अपनीApplicationक्लास मेंCameraXConfig.Providerको लागू करके या शुरू करने से पहलेProcessCameraProviderको कॉन्फ़िगर करके.
स्मार्ट ग्लास का कैमरा सेट अप करने के बाद, CameraX की ImageCapture क्लास की मदद से इमेज कैप्चर की जा सकती है. इमेज कैप्चर करने के लिए, takePicture का इस्तेमाल करने के बारे में जानने के लिए, CameraX का दस्तावेज़ देखें.
स्मार्ट ग्लास के कैमरे से स्ट्रीम कैप्चर करना
इमेज के बजाय स्ट्रीम कैप्चर करने के लिए, इमेज कैप्चर करने के उदाहरण में मौजूद ImageCapture कॉम्पोनेंट को VideoCapture या ImageAnalysis कॉम्पोनेंट से बदलें. साथ ही, कैप्चर करने का लॉजिक बदलें.
इन एपीआई और इनके इस्तेमाल के बारे में ज़्यादा जानने के लिए, CameraX वीडियो कैप्चर और CameraX इमेज ऐनलिसिस दस्तावेज़ देखें.
रिज़ॉल्यूशन और फ़्रेम रेट चुनना
आपको डिवाइस से क्वेरी करके, यह पता करना चाहिए कि वह किन रिज़ॉल्यूशन और उनके हिसाब से ज़्यादा से ज़्यादा कितने फ़्रेम रेट के साथ काम करता है. यहां दी गई टेबल में, वैल्यू के ऐसे उदाहरण दिए गए हैं जो आपके ऐप्लिकेशन के इस्तेमाल के हिसाब से दिख सकते हैं. बैटरी बचाने और स्मार्ट ग्लास को गर्म होने से बचाने के लिए, सबसे कम रिज़ॉल्यूशन और फ़्रेम रेट चुनें.
| इस्तेमाल का उदाहरण | रिज़ॉल्यूशन | फ़्रेम दर |
|---|---|---|
| टेक्स्ट की पहचान करने की सुविधा (ओसीआर) या आस-पास की चीज़ों को पहचानने की सुविधा | 1920 x 1080 | 1 एफ़पीएस |
| एआई वीडियो स्ट्रीमिंग (मल्टीमॉडल असिस्टेंट) | 1024 x 768 | 1 एफ़पीएस |
| जगह की जानकारी और विज़ुअल पोज़िशनिंग (वीपीएस) | 640 x 360 या 640 x 480 | 10 एफ़पीएस |
| वीडियो कॉलिंग | 640 x 360 या 640 x 480 | 24 FPS (फ़्रेम प्रति सेकंड) |
हर रिज़ॉल्यूशन के लिए, ज़्यादा से ज़्यादा फ़्रेम रेट के बारे में क्वेरी करना
CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, डिवाइस के फ़्रेम रेट की कुल सीमा की जानकारी देता है. यह सीमा, किसी रिज़ॉल्यूशन के लिए तय की गई स्ट्रीमिंग रेट से ज़्यादा हो सकती है. ऑडियो और डिसप्ले ग्लास पर हर रिज़ॉल्यूशन के लिए, ज़्यादा से ज़्यादा फ़्रेम रेट पाने के लिए, फ़्रेम की कम से कम अवधि पढ़ें. इसके बाद, StreamConfigurationMap.getOutputMinFrameDuration(format, size) का इस्तेमाल करके, इसे एफ़पीएस में बदलें:
@androidx.annotation.OptIn(ExperimentalCamera2Interop::class) fun getMaxFpsBySize(cameraInfo: CameraInfo, format: Int): Map<Size, Int> { val map = Camera2CameraInfo.from(cameraInfo).getCameraCharacteristic( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP ) ?: return emptyMap() return map.getOutputSizes(format).associateWith { size -> val minFrameDurationNs = map.getOutputMinFrameDuration(format, size) if (minFrameDurationNs > 0) (1_000_000_000L / minFrameDurationNs).toInt() else 0 } }
इसके बाद, उस वैल्यू का इस्तेमाल करके, टारगेट फ़्रेम रेट की रेंज के लिए minFps और maxFps की सीमाएं कैलकुलेट करें. minFps को रिज़ॉल्यूशन के लिए, getOutputMinFrameDuration से कैलकुलेट किए गए ज़्यादा से ज़्यादा स्ट्रीमिंग फ़्रेम रेट पर सेट करें. साथ ही, maxFps को कैच-अप विंडो के तौर पर सेट करें:
val maxFpsBySize = getMaxFpsBySize(cameraInfo, ImageFormat.YUV_420_888) val maxSupportedFps = maxFpsBySize[Size(640, 480)] ?: return ImageAnalysis.Builder().build() // minFps is the target streaming frame rate and should be at most maxSupportedFps. val minFps = minOf(desiredFps, maxSupportedFps) // Set the upper bound to 2x minFps so the stream can catch up if frames are delayed. val maxFps = minFps * 2
कोड के बारे में अहम बातें
- अपने इस्तेमाल के हिसाब से फ़ॉर्मैट चुनें.
ImageAnalysisके लिए, यहYUV_420_888है. VideoCaptureके लिए, इसके बजायClassओवरलोड का इस्तेमाल करें:getOutputSizes(MediaRecorder::class.java)औरgetOutputMinFrameDuration(MediaRecorder::class.java, size).- ऐसी रेंज तय करें जहां
maxFps,minFpsसे ज़्यादा हो (जैसे,minFps*2). दोनों सीमाओं कोRange(minFps, minFps)जैसी एक ही वैल्यू पर सेट न करें. लोअर बाउंड (minFps), टारगेट स्ट्रीमिंग फ़्रेम रेट सेट करता है. यहgetOutputMinFrameDurationसे कैलकुलेट की गई वैल्यू से ज़्यादा नहीं होना चाहिए. वहीं, अपर बाउंड (maxFps), देरी से आने वाले फ़्रेम के लिए कैच-अप विंडो के तौर पर काम करता है, ताकि लगातार होने वाली देरी को रोका जा सके. उदाहरण के लिए, 1 FPS वाली स्ट्रीम के लिए [1,2] या [1,3] और 24 FPS वाली स्ट्रीम के लिए [24,30] या [24,48].
फ़्रेम रेट कॉन्फ़िगर करना
CameraX के इस्तेमाल के उदाहरण के आधार पर, फ़्रेम रेट की रेंज कॉन्फ़िगर करने के लिए:
// Configure Resolution Strategy for the stream val resolutionStrategy = ResolutionStrategy( size, ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER ) val resolutionSelector = ResolutionSelector.Builder() .setResolutionStrategy(resolutionStrategy) .build() // Create and return the ImageAnalysis builder with proper frame rate ranges // ImageAnalysis: OCR, AI streaming, and VPS val analysisBuilder = ImageAnalysis.Builder() .setResolutionSelector(resolutionSelector) Camera2Interop.Extender(analysisBuilder) .setCaptureRequestOption( CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, Range(minFps, maxFps) ) return analysisBuilder.build()
इस उदाहरण में, VideoCapture और ImageAnalysis, दोनों के लिए कॉन्फ़िगरेशन दिखाया गया है. हालांकि, आपके ऐप्लिकेशन में इस्तेमाल के जो भी उदाहरण काम करते हैं उन्हें लागू किया जा सकता है.
स्ट्रीम के काम करने का तरीका समझना
कैप्चर स्ट्रीम के साथ काम करते समय, सिस्टम के इन व्यवहारों का ध्यान रखें:
- इस्तेमाल न किए जा सकने वाले रिज़ॉल्यूशन अस्वीकार कर दिए जाते हैं: अगर आपने सूची में शामिल न किए गए किसी साइज़ का अनुरोध किया है, तो Camera2 स्ट्रीम खुलने से पहले ही कॉन्फ़िगरेशन को अस्वीकार कर देता है.
- ज़्यादा से ज़्यादा फ़्रेम रेट से ज़्यादा का अनुरोध करना: अगर आपने अपने रिज़ॉल्यूशन के लिए, ज़्यादा से ज़्यादा फ़्रेम रेट से ज़्यादा के कम से कम फ़्रेम रेट का अनुरोध किया है, तो भी सेशन खुलता है. हालांकि, स्मार्ट ग्लास से टारगेट किया गया फ़्रेम रेट, ज़्यादा से ज़्यादा फ़्रेम रेट पर सेट हो जाता है. वहीं, ऊपरी सीमा, कैच-अप रेट की सीमा के तौर पर काम करती रहती है. उदाहरण के लिए, 640 x 480 पर [30,60] का अनुरोध करने पर, टारगेट फ़्रेम रेट 24 FPS पर सेट हो जाता है. यह [24,60] की तरह काम करता है.
- थर्मल थ्रॉटलिंग: स्मार्ट ग्लास के गर्म होने पर, फ़्रेम रेट कम हो जाता है. हालांकि, रिज़ॉल्यूशन में कोई बदलाव नहीं होता. अपने ऐप्लिकेशन को कम या असमान फ़्रेम रेट को मैनेज करने के लिए बनाएं. उदाहरण के लिए, फ़्रेम रेट को तय मानने के बजाय, फ़्रेम के टाइमस्टैंप की जांच करें.
प्रोजेक्ट की गई गतिविधि से फ़ोन के हार्डवेयर को ऐक्सेस करना
प्रोजेक्ट की गई गतिविधि, फ़ोन के हार्डवेयर (जैसे, कैमरा या माइक्रोफ़ोन) को भी ऐक्सेस कर सकती है. इसके लिए, उसे createHostDeviceContext(context) का इस्तेमाल करके, होस्ट डिवाइस (फ़ोन) का कॉन्टेक्स्ट पाना होगा:
@OptIn(ExperimentalProjectedApi::class) private fun getPhoneContext(activity: ComponentActivity): Context? { return try { // From a projected Activity, get a context for the phone. ProjectedContext.createHostDeviceContext(activity) } catch (e: IllegalStateException) { Log.e(TAG, "Failed to create host device context", e) null } }
हाइब्रिड ऐप्लिकेशन (ऐसा ऐप्लिकेशन जिसमें मोबाइल और स्मार्ट ग्लास, दोनों के लिए अनुभव शामिल हों) में, होस्ट डिवाइस (फ़ोन) के लिए खास तौर पर उपलब्ध हार्डवेयर या संसाधनों को ऐक्सेस करते समय, आपको साफ़ तौर पर सही कॉन्टेक्स्ट चुनना होगा. इससे यह पक्का किया जा सकेगा कि आपका ऐप्लिकेशन सही हार्डवेयर को ऐक्सेस कर सके:
- फ़ोन
ActivityसेActivityकॉन्टेक्स्ट का इस्तेमाल करें या फ़ोन का कॉन्टेक्स्ट पाने के लिएProjectedContext.createHostDeviceContextका इस्तेमाल करें. getApplicationContextका इस्तेमाल न करें. ऐसा इसलिए, क्योंकि अगर प्रोजेक्ट की गई गतिविधि सबसे हाल ही में लॉन्च किया गया कॉम्पोनेंट है, तो ऐप्लिकेशन का कॉन्टेक्स्ट, स्मार्ट ग्लास के कॉन्टेक्स्ट को गलत तरीके से दिखा सकता है.