אחרי שמבקשים ומקבלים את ההרשאות הנדרשות, האפליקציה יכולה לגשת לחומרה של המשקפיים עם הממשק הקולי או המשקפיים עם התצוגה הפנימית. כדי לגשת לחומרה של המשקפיים (במקום לחומרה של הטלפון), צריך להשתמש בהקשר מוצג.
יש שתי דרכים עיקריות לקבל הקשר מוקרן, בהתאם למקום שבו הקוד מופעל:
קבלת הקשר מוקרן אם הקוד פועל בפעילות מוקרנת
אם הקוד של האפליקציה פועל מתוך הפעילות המוקרנת, הקשר הפעילות שלה הוא כבר הקשר מוקרן. בתרחיש הזה, קריאות שמתבצעות במסגרת הפעילות הזו כבר יכולות לגשת לחומרה של המשקפיים.
קבלת הקשר משוער לקוד שפועל ברכיב של אפליקציית טלפון
אם חלק מהאפליקציה מחוץ לפעילות המוקרנת (כמו פעילות בטלפון או שירות) צריך לגשת לחומרה של המשקפיים, הוא חייב לקבל באופן מפורש הקשר מוקרן. כדי לעשות זאת, משתמשים ב-method createProjectedDeviceContext:
@RequiresApi(Build.VERSION_CODES.BAKLAVA) @OptIn(ExperimentalProjectedApi::class, ExperimentalCoroutinesApi::class) fun monitorProjectedDeviceConnectivity( context: Context, onConnected: suspend (projectedContext: Context) -> (() -> Unit)? ) { val lifecycleScope = (context as? LifecycleOwner)?.lifecycleScope ?: CoroutineScope(Dispatchers.Main + SupervisorJob()) lifecycleScope.launch { var cleanupAction: (() -> Unit)? = null try { // Before creating a projected context, verify that the projected device // is connected to the host device (phone). // While this flow collects true, the active projected context remains valid. ProjectedContext.isProjectedDeviceConnected(context, coroutineContext) .distinctUntilChanged() .collectLatest { isConnected -> // Clean up any previous session resources prior to state transitions. cleanupAction?.invoke() cleanupAction = null if (!isConnected) { Log.i(TAG, "Projected device disconnected. Cleaning up hardware resources...") return@collectLatest } // Inside a phone Activity or Service, create a projected context. // Note: If you are already inside a projected Activity, the default context // is already a projected context. val projectedContext = runCatching { ProjectedContext.createProjectedDeviceContext(context) }.onFailure { e -> Log.e(TAG, "Failed to create projected context", e) }.getOrNull() ?: return@collectLatest // Use the new, valid `projectedContext` to initialize system services (e.g., CameraManager). Log.i(TAG, "Projected device connected. Initializing hardware...") cleanupAction = onConnected(projectedContext) } } finally { // Guarantee final resource cleanup on Activity destruction or scope cancellation. cleanupAction?.invoke() cleanupAction = null } } }
בדיקת התקינות
עוטפים את הקריאה ל-createProjectedDeviceContext בתוך ProjectedContext.isProjectedDeviceConnected. השיטה הזו מחזירה את הערך true, אבל ההקשר המוקרן נשאר תקף למכשיר המחובר, והפעילות או השירות של האפליקציה בטלפון (כמו CameraManager) יכולים לגשת לחומרה של המשקפיים.
ניקוי בזמן הניתוק
ההקשר המוקרן קשור למחזור החיים של המכשיר המחובר, ולכן הוא נהרס כשהמכשיר מתנתק. כשהמכשיר מתנתק,
ProjectedContext.isProjectedDeviceConnected מחזיר את הערך false. האפליקציה צריכה להאזין לשינוי הזה ולנקות את כל שירותי המערכת (כמו CameraManager) או המשאבים שהאפליקציה יצרה באמצעות ההקשר המוקרן הזה.
הפעלה מחדש בזמן התחברות מחדש
כשהמשקפיים מתחברים מחדש, האפליקציה יכולה לקבל מופע נוסף של הקשר מוקרן באמצעות createProjectedDeviceContext, ואז להפעיל מחדש את כל שירותי המערכת או המשאבים באמצעות ההקשר המוקרן החדש.
להקליט אודיו באמצעות המיקרופון של המשקפיים
אתם יכולים להקליט אודיו מהמשקפיים באמצעות פרופיל דיבורית (HFP) של Bluetooth. במצב הזה, המשקפיים מתחברים לטלפון באמצעות פרופילים רגילים של אוזניות ו-Advanced Audio Distribution Profile (A2DP), ופועלים כמו ציוד היקפי רגיל של Bluetooth. אם האפליקציה שלכם כבר מותאמת להקלטה רגילה ב-Bluetooth, אתם יכולים להשתמש בשיטה הזו כדי להקליט אודיו מהמשקפיים בלי פיתוח נוסף.
הקלטת אודיו באמצעות Bluetooth HFP
כדי להקליט אודיו באמצעות Bluetooth HFP, קודם צריך לבקש את ההרשאות הנדרשות בתחילת ההפעלה, ואז להקליט את האודיו באמצעות ה-API של AudioManager, כמו שמתואר בקטעים הבאים.
שליחת בקשה להרשאות
כמו בכל מכשיר אודיו רגיל עם Bluetooth, ההרשאות RECORD_AUDIO, BLUETOOTH_CONNECT והרשאות קשורות אחרות נשלטות על ידי הטלפון ולא על ידי המכשיר המחובר (כמו משקפיים עם ממשק קולי או משקפיים עם תצוגה פנימית).
כדי לבקש את ההרשאות:
מצהירים על ההרשאות הבאות בקובץ המניפסט של האפליקציה:
מבקשים את ההרשאות
RECORD_AUDIOו-BLUETOOTH_CONNECTבזמן הריצה באמצעות תהליך ההרשאות הרגיל של Android.
שימוש ב-AudioManager לניתוב אודיו
אחרי שהמשתמש נותן לאפליקציה את ההרשאות הנדרשות בתחילת ההפעלה, משתמשים ב-API AudioManager כדי להגדיר את מכשיר התקשורת ל-TYPE_BLUETOOTH_SCO, כדי לנתב את האודיו דרך Bluetooth HFP. כך המערכת תדע לאחזר אודיו מהציוד ההיקפי של ה-Bluetooth.
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() }
צילום תמונה באמצעות המצלמה של המשקפיים
כדי לצלם תמונה באמצעות המצלמה של המשקפיים, צריך לעקוב אחרי הקישוריות באמצעות monitorProjectedDeviceConnectivity כדי לקבל הקשר של מכשיר מוקרן, ליצור LifecycleCameraProvider מבודד שקשור להקשר הזה, להאזין לנוכחות של המצלמה ולקשר את תרחיש השימוש של ImageCapture ב-CameraX.
קודם כול, עוקבים אחרי הקישוריות של המכשיר ומפעילים את LifecycleCameraProvider.createInstance באמצעות CameraXConfig.Builder בסטרימינג יחיד:
@OptIn(ExperimentalCameraProviderConfiguration::class) @RequiresApi(Build.VERSION_CODES.BAKLAVA) @SuppressLint("RestrictedApi") fun setUpGlassesCamera(activity: ComponentActivity) { monitorProjectedDeviceConnectivity(activity) { projectedContext -> val cameraManager = projectedContext.getSystemService(CameraManager::class.java) ?: run { Log.e(TAG, "CameraManager not available on projected context") return@monitorProjectedDeviceConnectivity null } // `setRepeatingStreamForced()` is currently internal but will be public soon. val cameraConfig = CameraXConfig.Builder .fromConfig(Camera2Config.defaultConfig()) .setRepeatingStreamForced(false) .build() val cameraProvider = try { // Acquire CameraX provider specifically bound to the projected context. // If the device disconnects while suspending, collectLatest cancels this coroutine. LifecycleCameraProvider.createInstance(projectedContext, cameraConfig) } catch (e: IllegalStateException) { Log.e(TAG, "Failed to initialize projected camera services", e) return@monitorProjectedDeviceConnectivity null } // Set up the listener to react to camera availability changes asynchronously. val availabilityCallback = registerAvailabilityListener( cameraManager = cameraManager, cameraProvider = cameraProvider, executor = ContextCompat.getMainExecutor(activity), onCameraAvailable = { cameraId -> // Delegate camera selection, resolution querying, and use-case binding. bindGlassesImageCapture(cameraProvider, cameraId, activity) } ) // Return a clean-up closure invoked automatically by monitorProjectedDeviceConnectivity // on disconnect, coroutine cancellation, or Activity destruction. return@monitorProjectedDeviceConnectivity { Log.i(TAG, "Projected camera setup scope ended. Tearing down resources...") try { cameraManager.unregisterAvailabilityCallback(availabilityCallback) } finally { cameraProvider.unbindAll() } } } }
בגרסה 1.6.0 ומעלה של CameraX, רושמים CameraPresenceListener באמצעות addCameraPresenceListener כדי להגיב כשמוסיפים או מסירים את המצלמה של המשקפיים:
@OptIn(ExperimentalCameraProviderConfiguration::class) fun registerAvailabilityListener( cameraManager: CameraManager, cameraProvider: LifecycleCameraProvider, executor: Executor, onCameraAvailable: (cameraId: String) -> Unit ): CameraManager.AvailabilityCallback { val callback = object : CameraManager.AvailabilityCallback() { override fun onCameraAvailable(cameraId: String) { super.onCameraAvailable(cameraId) Log.i(TAG, "Glasses camera available (ID: $cameraId). Binding use case...") // Fires only after the OS finishes re-registering the glasses' camera. // Pass the fresh cameraId directly—never cache it, as it may change when recreated. onCameraAvailable(cameraId) } override fun onCameraUnavailable(cameraId: String) { super.onCameraUnavailable(cameraId) Log.i(TAG, "Glasses camera unavailable (ID: $cameraId). Releasing resources...") // Gracefully release the pipeline when the projected camera becomes unavailable. cameraProvider.unbindAll() } } cameraManager.registerAvailabilityCallback(executor, callback) return callback }
אחר כך, בוחרים את המצלמה של המשקפיים מתוך availableCameraInfos באמצעות CameraIdentifier שסופק על ידי המאזין, ומקשרים את ImageCapture:
/** * Selects the projected camera matching dynamic [cameraId] from * [LifecycleCameraProvider.availableCameraInfos], verifies availability, and binds an * [ImageCapture] use case targeting a 16:9 resolution to [lifecycleOwner]. * * Note: Depending on your application's needs, [ImageCapture] can be swapped out for other * standard CameraX use cases: * - Use [ImageAnalysis] for real-time streaming workloads (e.g., OCR, AI vision, or VPS). * - Use [VideoCapture] for video recording pipelines. */ @OptIn(ExperimentalCamera2Interop::class, ExperimentalCameraProviderConfiguration::class) fun bindGlassesImageCapture( cameraProvider: LifecycleCameraProvider, cameraId: String, lifecycleOwner: LifecycleOwner, preferredResolution: Size = Size(1920, 1080) ): ImageCapture? { return try { // Discover available cameras dynamically via `availableCameraInfos` // Narrow it down by the dynamic `cameraId` because the projected camera's ID may // change when recreated val cameraInfo = cameraProvider.availableCameraInfos.firstOrNull { info -> Camera2CameraInfo.from(info).cameraId == cameraId } // Pre-binding check: Verify the selected camera is registered and available on the device. // The projected camera may be unavailable (for example, if the user took off the glasses). if (cameraInfo == null) { Log.w(TAG, "Glasses camera (ID: $cameraId) is not currently available.") return null } val cameraSelector = cameraInfo.cameraSelector val resolutionSelector = ResolutionSelector.Builder() .setAspectRatioStrategy(AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY) .setResolutionStrategy( ResolutionStrategy( preferredResolution, ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER ) ) .build() // Initialize the ImageCapture use case. val imageCapture = ImageCapture.Builder() .setResolutionSelector(resolutionSelector) .build() // Unbind any previously bound use cases before rebinding to the lifecycle owner. cameraProvider.unbindAll() // Bind the configured use case. You can swap `imageCapture` out for an `ImageAnalysis` // (e.g., from `setupCameraStreamingFps`) or `VideoCapture` instance here to match your use case. // `bindToLifecycle()` can throw IllegalArgumentException if use cases // are incompatible, or IllegalStateException if the LifecycleOwner is destroyed. cameraProvider.bindToLifecycle( lifecycleOwner, cameraSelector, imageCapture ) Log.i(TAG, "ImageCapture successfully bound for camera ID $cameraId") imageCapture } catch (exc: CameraInfoUnavailableException) { Log.e(TAG, "Unable to access camera info for ID $cameraId", exc) null } catch (exc: IllegalArgumentException) { Log.e(TAG, "Invalid camera configuration or use case combination for ID $cameraId", exc) null } catch (exc: IllegalStateException) { Log.e(TAG, "Camera is already bound to another lifecycle or closed", exc) null } }
מידע חשוב על הקוד
- לכל מכשיר
LifecycleCameraProvider: משתמשים ב-LifecycleCameraProvider.createInstanceכדי ליצור ספק מצלמה מבודד שמוגדר בהיקף של ההקשר המוקרן הפעיל. מכיוון שה-deviceIdשל ההקשר המוקרן יכול להשתנות כשהמשקפיים מתנתקים ומתחברים מחדש בזמן שתהליך האפליקציה נשאר פעיל, יצירת ספק לכל מכשיר מבטיחה ש-CameraX יתחבר למכשיר המחובר הפעיל. - האזנה לנוכחות של מצלמה: ב-CameraX מגרסה 1.6.0 ואילך, רושמים
CameraPresenceListenerבאמצעותcameraProvider.addCameraPresenceListenerבמקום לפתוח את המצלמה מיד כשהמשקפיים מתחברים. ההגדרה האסינכרונית בין המשקפיים למארח צריכה להסתיים לפני שמערכת ההפעלה מסיימת ליצור מחדש את המצלמה של המשקפיים. המצלמה של המשקפיים יכולה גם להיעלם באופן דינמי בזמן שהיא מחוברת (למשל, במהלך הפחתת החום).- הוספת מצלמה (
onCamerasAdded): מופעל אחרי ש-availableCameraInfosמתעדכן עם המצלמה שנוספה, כדי למנוע בעיות תזמון במהלך ההגדרה. - הסרת המצלמה (
onCamerasRemoved): עוקב אחרי נוכחות המצלמה ולא אחרי מצב השימוש, כך שביטול הקישור משחרר משאבים רק כשמסירים את המצלמה של המשקפיים, במקום להגיב כשהאפליקציה שלכם פותחת את המצלמה.
- הוספת מצלמה (
- ניקוי בזמן ניתוק: סגירת הניקוי חזרה אל
monitorProjectedDeviceConnectivityקריאותremoveCameraPresenceListenerו-unbindAll()כשהמשקפיים מתנתקים או כשהפעילות נהרסת. - בחירת מצלמה דינמית: התאמה של
CameraIdentifierשמועבר אלonCamerasAddedל-availableCameraInfosבאמצעותisOfכדי לבחור את מצלמת המשקפיים באופן דינמי. - רזולוציה בהתאמה אישית: יוצרת
ResolutionSelectorשמטרגט יחס גובה-רוחב לדוגמה של 16:9 ואת הרזולוציה המועדפת עליכם (עם חזרה לגודל הנתמך הקרוב ביותר) עבורImageCapture. יחסי הגובה-רוחב והרזולוציות הנתמכים משתנים בהתאם למכשיר המשקפיים ולמצב (למשל 4:3 ו-16:9), לכן צריך לשלוח שאילתה ל-StreamConfigurationMapאם רוצים לבדוק את הגדלים המדויקים שנתמכים. - קישור למחזור החיים: מקשר את
ImageCaptureל-LifecycleOwner, ומנהל באופן אוטומטי את המעברים בין פתיחה לסגירה של המצלמה בהתאם למחזור החיים של הפעילות. - הגדרה לחומרה עם סטרימינג יחיד: צינור עיבוד הנתונים של המצלמה במשקפיים מוגבל לסטרימינג פעיל אחד בכל פעם. כש-
ImageCaptureמקושר לבד, CameraX מצרף כברירת מחדל סטרימינג פנימי חוזר (MeteringRepeating) למיקוד ולמדידה, מה שגורם לפייפליין הזורם של הסטרימינג היחיד להיתקע. מעבירים אתsetRepeatingStreamForced(false)ב-CameraXConfigשמועבר אלLifecycleCameraProvider.createInstanceכדי ש-ImageCaptureיוכל להתחבר בלי סטרימינג של תצוגה מקדימה.
אחרי שמגדירים את המצלמה של המשקפיים, אפשר לצלם תמונה באמצעות המחלקה ImageCapture של CameraX. במסמכי התיעוד של CameraX מוסבר איך משתמשים ב-takePicture כדי לצלם תמונה.
צילום שידור באמצעות המצלמה של המשקפיים
כדי לצלם סטרימינג במקום תמונה, מחליפים את הרכיב ImageCapture מהדוגמה לצילום תמונה ברכיבים VideoCapture או ImageAnalysis ומשנים את לוגיקת הצילום.
מידע נוסף על ממשקי ה-API האלה ואיך להשתמש בהם זמין במסמכי התיעוד של צילום וידאו ב-CameraX וניתוח תמונות ב-CameraX.
בוחרים רזולוציה וקצב פריימים
כדאי לשלוח שאילתה למכשיר כדי לברר מהן הרזולוציות הנתמכות ומהם קצבי הפריימים המקסימליים שלהן. בטבלה הבאה מפורטים ערכים לדוגמה שאתם עשויים לראות, בהתאם לתרחיש השימוש של האפליקציה. כדי לחסוך בחשמל ולהפחית את החום במשקפיים, כדאי לבחור את הרזולוציה וקצב הפריימים הנמוכים ביותר שמתאימים לתרחיש השימוש שלכם.
| תרחיש שימוש | רזולוציה | קצב פריימים |
|---|---|---|
| זיהוי טקסט (OCR) או חישת העולם | 1920 x 1080 | פריים אחד לשנייה (FPS) |
| סטרימינג של סרטוני AI (עוזרים אישיים מולטי-מודאליים) | 1,024 x 768 | פריים אחד לשנייה (FPS) |
| לוקליזציה ומיקום חזותי (VPS) | 640 x 360 או 640 x 480 | 10 פריימים לשנייה (FPS) |
| שיחות וידאו | 640 x 360 או 640 x 480 | 24 פריימים לשנייה (FPS) |
שאילתה לגבי קצב הפריימים המקסימלי לכל רזולוציה
הפונקציה CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES מדווחת על גבולות קצב הפריימים הכולל של המכשיר, שיכול להיות גבוה יותר מקצב הסטרימינג שרזולוציה מסוימת תומכת בו. כדי לקבל את הערך המקסימלי בפועל לכל רזולוציה במשקפיים עם אודיו ותצוגה, קוראים את משך הזמן המינימלי של פריים וממירים אותו ל-FPS באמצעות 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] ?: 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,2] או [1,3] לשידור של 1 FPS, ו-[24,30] או [24,48] לשידור של 24 FPS.
הגדרת קצב הפריימים
כדי להגדיר את טווח קצב הפריימים על סמך תרחיש השימוש ב-CameraX:
// 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 דוחה את ההגדרה לפני שהסטרימינג נפתח.
- בקשת קצב פריימים מעל המקסימום: אם תבקשו קצב פריימים מינימלי שגבוה מהמקסימום שנתמך ברזולוציה שלכם, הסשן עדיין ייפתח, אבל קצב הפריימים בפועל במשקפיים יוגבל למקסימום הנתמך, והגבול העליון ימשיך לפעול כמגבלת קצב ההשלמה. לדוגמה, אם מבקשים [30,60] ברזולוציה של 640 x 480, קצב הפריימים מוגבל ל-24FPS (מתנהג כמו [24,60]).
- ויסות תרמי: כשהמשקפיים מתחממים, קצב הפריימים יורד אבל הרזולוציה נשארת זהה. צריך לפתח את האפליקציה כך שתתמודד עם קצב פריימים נמוך או לא אחיד, למשל על ידי בדיקת חותמות הזמן של הפריימים במקום להניח שקצב הפריימים קבוע.
גישה לחומרה של הטלפון מפעילות חזויה
פעילות חזויה יכולה גם לגשת לחומרה של הטלפון (כמו המצלמה או המיקרופון) באמצעות createHostDeviceContext(context) כדי לקבל את ההקשר של המכשיר המארח (הטלפון):
@OptIn(ExperimentalProjectedApi::class) fun getHostDeviceContext(context: Context): Context { // Obtain the host device (phone) context. // The `context` argument passed in can be any context (projected, host, Service, or App). return ProjectedContext.createHostDeviceContext(context) }
כשניגשים לחומרה או למשאבים שספציפיים למכשיר המארח (טלפון) באפליקציה היברידית (אפליקציה שכוללת גם חוויות בנייד וגם חוויות במשקפיים), צריך לבחור באופן מפורש את ההקשר הנכון כדי לוודא שהאפליקציה יכולה לגשת לחומרה הנכונה:
- משתמשים בהקשר
ActivityמהטלפוןActivityאו ב-ProjectedContext.createHostDeviceContextכדי לקבל את ההקשר של הטלפון. - אל תשתמשו ב-
getApplicationContextכי הקשר האפליקציה יכול להחזיר בטעות את ההקשר של המשקפיים אם הפעילות שהוקרנה הייתה הרכיב שהופעל לאחרונה.