Nachdem Sie die erforderlichen Berechtigungen angefordert und erhalten haben, kann Ihre App auf die Hardware der Audio- oder Display-Brille zugreifen. Der Schlüssel für den Zugriff auf die Hardware der Brille (anstelle der Hardware des Smartphones) ist die Verwendung eines projizierten Kontexts.
Es gibt zwei Möglichkeiten, einen projizierten Kontext abzurufen, je nachdem, wo Ihr Code ausgeführt wird:
Projizierten Kontext abrufen, wenn Ihr Code in einer projizierten Aktivität ausgeführt wird
Wenn der Code Ihrer App innerhalb Ihrer projizierten Aktivität ausgeführt wird, ist der eigene Aktivitätskontext bereits ein projizierter Kontext. In diesem Szenario können Aufrufe, die innerhalb dieser Aktivität erfolgen, bereits auf die Hardware der Brille zugreifen.
Projizierten Kontext für Code abrufen, der in einer Telefon-App-Komponente ausgeführt wird
Wenn ein Teil Ihrer App außerhalb Ihrer projizierten Aktivität (z. B. eine Smartphone-Aktivität oder ein Dienst) auf die Hardware der Brille zugreifen muss, muss er explizit einen projizierten Kontext abrufen. Verwenden Sie dazu die Methode 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 } } }
Gültigkeit prüfen
Binden Sie den createProjectedDeviceContext-Aufruf in ProjectedContext.isProjectedDeviceConnected ein. Während diese Methode true zurückgibt, bleibt der projizierte Kontext für das verbundene Gerät gültig und die Aktivität oder der Dienst Ihrer Telefon App (z. B. ein CameraManager) kann auf die Brillenhardware zugreifen.
Beim Trennen der Verbindung bereinigen
Der projizierte Kontext ist an den Lebenszyklus des verbundenen Geräts gebunden und wird daher zerstört, wenn die Verbindung zum Gerät getrennt wird. Wenn die Verbindung zum Gerät getrennt wird, gibt ProjectedContext.isProjectedDeviceConnected den Wert false zurück. Deine App sollte auf diese Änderung warten und alle Systemdienste (z. B. CameraManager) oder Ressourcen bereinigen, die deine App mit diesem projizierten Kontext erstellt hat.
Bei Wiederverbindung neu initialisieren
Wenn die Datenbrille wieder verbunden ist, kann Ihre App mit createProjectedDeviceContext eine weitere projizierte Kontextinstanz abrufen und dann alle Systemdienste oder Ressourcen mit dem neuen projizierten Kontext neu initialisieren.
Audio mit dem Mikrofon der Brille aufnehmen
Du kannst Audio von der Brille über das Bluetooth-Hands-Free Profile (HFP) aufnehmen. In diesem Modus wird die Brille über die Standardprofile „Headset“ und „Advanced Audio Distribution Profile“ (A2DP) mit dem Smartphone verbunden und funktioniert wie ein typisches Bluetooth-Peripheriegerät. Wenn deine App bereits für die Standard-Bluetooth-Aufnahme konzipiert ist, kannst du diese Methode verwenden, um Audio von der Brille ohne zusätzlichen Entwicklungsaufwand aufzunehmen.
Audio mit Bluetooth-HFP aufnehmen
Wenn du Audio mit Bluetooth HFP aufnehmen möchtest, musst du zuerst die erforderlichen Laufzeitberechtigungen anfordern und dann das Audio mit der AudioManager API aufnehmen, wie in den folgenden Abschnitten beschrieben.
Berechtigungen anfordern
Wie bei jedem Standard-Bluetooth-Audiogerät werden die Berechtigungen RECORD_AUDIO, BLUETOOTH_CONNECT und andere zugehörige Berechtigungen vom Smartphone und nicht vom verbundenen Gerät (z. B. Audio- oder Display-Brille) gesteuert.
So fordern Sie die Berechtigungen an:
Deklarieren Sie die folgenden Berechtigungen in der Manifestdatei Ihrer App:
Fordern Sie die Berechtigungen
RECORD_AUDIOundBLUETOOTH_CONNECTzur Laufzeit über den Standard-Android-Berechtigungsablauf an.
AudioManager zum Weiterleiten von Audio verwenden
Nachdem der Nutzer Ihrer App die erforderlichen Laufzeitberechtigungen gewährt hat, verwenden Sie die AudioManager API, um das Kommunikationsgerät auf TYPE_BLUETOOTH_SCO festzulegen, damit das Audio über Bluetooth HFP geleitet wird. Dadurch wird das System angewiesen, Audio von der Bluetooth-Peripherie abzurufen.
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() }
Bild mit der Kamera der Datenbrille aufnehmen
Wenn du ein Bild mit der Kamera der Datenbrille aufnehmen möchtest, musst du die Verbindung mit monitorProjectedDeviceConnectivity überwachen, um einen projizierten Gerätekontext zu erhalten. Erstelle dann einen isolierten LifecycleCameraProvider, der an diesen Kontext gebunden ist, überwache die Kameraverfügbarkeit und binde den Anwendungsfall ImageCapture von CameraX.
Überwache zuerst die Geräteverbindung und initialisiere LifecycleCameraProvider.createInstance mit einem Single-Stream-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() } } } }
Registrieren Sie in CameraX 1.6.0 und höher einen CameraPresenceListener mit addCameraPresenceListener, um zu reagieren, wenn die Kamera der Brille hinzugefügt oder entfernt wird:
@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 }
Wähle als Nächstes die Kamera der Datenbrille aus availableCameraInfos mit dem CameraIdentifier aus, der vom Listener bereitgestellt wird, und binde 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 } }
Wichtige Punkte zum Code
- Pro Gerät (
LifecycleCameraProvider): VerwendeLifecycleCameraProvider.createInstance, um einen isolierten Kameraanbieter zu erstellen, der auf den aktiven projizierten Kontext beschränkt ist. Da sich derdeviceIddes projizierten Kontexts ändern kann, wenn die Brille getrennt und wieder verbunden wird, während der App-Prozess aktiv bleibt, sorgt das Erstellen eines gerätespezifischen Anbieters dafür, dass CameraX an das aktive verbundene Gerät gebunden wird. - Auf Kameraverfügbarkeit warten: Registriere in CameraX 1.6.0 und höher einen
CameraPresenceListenermitcameraProvider.addCameraPresenceListener, anstatt die Kamera sofort zu öffnen, wenn die Brille verbunden wird. Die asynchrone Einrichtung zwischen der Datenbrille und dem Host muss abgeschlossen sein, bevor das Betriebssystem die Kamera der Datenbrille neu erstellt. Außerdem kann die Kamera der Datenbrille während der Verbindung dynamisch verschwinden (z. B. während der thermischen Entlastung).- Kamera hinzugefügt (
onCamerasAdded): Wird ausgelöst, nachdemavailableCameraInfosmit der hinzugefügten Kamera aktualisiert wurde, um Timing-Races während der Einrichtung zu vermeiden. - Kameraentfernung (
onCamerasRemoved): Hier wird die Anwesenheit der Kamera und nicht der Nutzungsstatus erfasst. Das Aufheben der Bindung gibt also nur dann Ressourcen frei, wenn die Kamera der Brille entfernt wird, und nicht, wenn deine eigene App die Kamera öffnet.
- Kamera hinzugefügt (
- Bereinigung bei Verbindungsabbruch: Der Bereinigungs-Closure, der an
monitorProjectedDeviceConnectivityzurückgegeben wird, ruftremoveCameraPresenceListenerundunbindAll()auf, wenn die Verbindung zur Brille getrennt oder die Aktivität beendet wird. - Dynamische Kameraauswahl: Gleicht die an
onCamerasAddedübergebeneCameraIdentifiermitavailableCameraInfosab und verwendetisOf, um die Kamera der Datenbrille dynamisch auszuwählen. - Benutzerdefinierte Auflösung: Erstellt eine
ResolutionSelector, die auf ein beispielhaftes Seitenverhältnis von 16:9 und Ihre bevorzugte Auflösung abzielt (mit Fallback auf die nächstniedrigere unterstützte Größe) fürImageCapture. Die unterstützten Seitenverhältnisse und Auflösungen variieren je nach Gerät und Modus (z. B. 4:3 und 16:9). Wenn du die genauen unterstützten Größen prüfen möchtest, frageStreamConfigurationMapab. - Lebenszyklusbindung: Bindet
ImageCaptureanLifecycleOwnerund verwaltet automatisch die Übergänge beim Öffnen und Schließen der Kamera mit dem Lebenszyklus der Aktivität. - Konfiguration für Hardware mit einem einzelnen Stream: Die Kamerapipeline der Brille ist auf einen einzelnen aktiven Stream beschränkt. Wenn
ImageCaptureallein gebunden ist, hängt CameraX standardmäßig einen internen wiederholten Stream (MeteringRepeating) für Fokus und Messung an, was dazu führt, dass die Streamingpipeline mit einem einzelnen Stream ins Stocken gerät. Übergeben SiesetRepeatingStreamForced(false)in derCameraXConfig, die anLifecycleCameraProvider.createInstanceübergeben wird, damitImageCaptureohne Vorschaustream binden kann.
Nachdem die Kamera der Brille eingerichtet ist, kannst du mit der ImageCapture-Klasse von CameraX ein Bild aufnehmen. Informationen zur Verwendung von takePicture zum Aufnehmen eines Bildes finden Sie in der CameraX-Dokumentation.
Stream mit der Kamera der Datenbrille aufnehmen
Wenn Sie Streams anstelle eines Bildes erfassen möchten, ersetzen Sie die Komponente ImageCapture aus dem Beispiel für die Bilderfassung durch die Komponente VideoCapture oder ImageAnalysis und ändern Sie die Erfassungslogik.
Weitere Informationen zu diesen APIs und ihrer Verwendung finden Sie in der Dokumentation zu CameraX-Videoaufnahmen und CameraX-Bildanalyse.
Auflösung und Framerate auswählen
Du solltest das Gerät abfragen, um die unterstützten Auflösungen und die entsprechenden maximalen Frameraten zu ermitteln. In der folgenden Tabelle sind Beispiele für Werte aufgeführt, die je nach Anwendungsfall Ihrer App angezeigt werden können. Um den Akku zu schonen und die Wärmeentwicklung der Datenbrille zu reduzieren, solltest du die niedrigste Auflösung und Framerate wählen, die für deinen Anwendungsfall geeignet ist.
| Anwendungsfall | Auflösung | Framerate |
|---|---|---|
| Texterkennung (OCR) oder Umgebungserkennung | 1.920 × 1.080 | 1 fps |
| KI-Videostreaming (multimodale Assistenten) | 1.024 x 768 | 1 fps |
| Lokalisierung und visuelle Positionierung (VPS) | 640 × 360 oder 640 × 480 | 10 fps |
| Videoanrufe | 640 × 360 oder 640 × 480 | 24 fps |
Maximale Framerate für jede Auflösung abfragen
CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES meldet die allgemeinen Frameraten-Grenzwerte des Geräts, die höher sein können als die Streamingrate, die eine bestimmte Auflösung unterstützt. Wenn du die tatsächliche maximale Framerate für jede Auflösung auf Audio- und Display-Brillen ermitteln möchtest, lies die minimale Framedauer und rechne sie mit StreamConfigurationMap.getOutputMinFrameDuration(format, size) in FPS um:
@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 } }
Verwende diesen Wert dann, um die Grenzen minFps und maxFps für den Zielbereich der Framerate zu berechnen. Begrenzen Sie die Untergrenze (minFps) auf die maximale Streaming-Framerate der Auflösung, die aus getOutputMinFrameDuration berechnet wird, und legen Sie eine höhere Obergrenze (maxFps) als Aufholfenster fest:
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
Wichtige Punkte zum Code
- Verwenden Sie das Format, das zu Ihrem Anwendungsfall passt. Für
ImageAnalysisist dasYUV_420_888. - Verwenden Sie für
VideoCapturestattdessen dieClass-Überladungen:getOutputSizes(MediaRecorder::class.java)undgetOutputMinFrameDuration(MediaRecorder::class.java, size). - Geben Sie einen Bereich an, in dem
maxFpsgrößer alsminFpsist (z. B.minFps*2), anstatt beide Grenzen auf denselben Wert wieRange(minFps, minFps)festzulegen. Die Untergrenze (minFps) legt die Ziel-Framerate für das Streaming fest und sollte höchstens dem ausgetOutputMinFrameDurationberechneten Wert entsprechen. Die Obergrenze (maxFps) dient als Zeitfenster, um verzögerte Frames nachzuholen und so eine dauerhafte Latenz zu vermeiden. Beispiel: [1,2] oder [1,3] für einen Stream mit 1 fps und [24,30] oder [24,48] für einen Stream mit 24 fps.
Framerate konfigurieren
So konfigurieren Sie den Frameratenbereich basierend auf Ihrem CameraX-Anwendungsfall:
// 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()
In diesem Beispiel wird die Konfiguration für VideoCapture und ImageAnalysis gezeigt. Sie können aber alle Anwendungsfälle implementieren, die Ihre App unterstützt.
Verhalten des Streams
Beachten Sie bei der Arbeit mit Erfassungsstreams die folgenden Systemverhaltensweisen:
- Nicht unterstützte Auflösungen werden abgelehnt: Wenn du eine Größe anforderst, die nicht in der Liste enthalten ist, lehnt Camera2 die Konfiguration ab, bevor der Stream geöffnet wird.
- Framerate über dem Maximum anfordern: Wenn Sie eine Mindestframerate anfordern, die über dem für Ihre Auflösung unterstützten Maximum liegt, wird die Sitzung trotzdem geöffnet. Die Zielframerate der Brille wird jedoch auf dieses unterstützte Maximum begrenzt, während die Obergrenze weiterhin als Aufholratenlimit dient. Wenn Sie beispielsweise [30, 60] bei 640 × 480 anfordern,wird die Zielframerate auf 24 fps beschränkt (wie bei [24,60]).
- Thermische Drosselung: Wenn die Datenbrille warm wird, sinkt die Framerate, die Auflösung bleibt jedoch gleich. Entwickle deine App so, dass sie mit niedrigeren oder ungleichmäßigen Frameraten umgehen kann, z. B. indem du die Zeitstempel der Frames prüfst, anstatt von einer festen Rate auszugehen.
Über eine projizierte Aktivität auf die Hardware eines Smartphones zugreifen
Eine projizierte Aktivität kann auch auf die Hardware des Smartphones (z. B. Kamera oder Mikrofon) zugreifen. Dazu wird createHostDeviceContext(context) verwendet, um den Kontext des Hostgeräts (Smartphone) abzurufen:
@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) }
Wenn du in einer Hybrid-App (einer App, die sowohl für Smartphones als auch für Datenbrillen geeignet ist) auf Hardware oder Ressourcen zugreifst, die spezifisch für das Hostgerät (Smartphone) sind, musst du explizit den richtigen Kontext auswählen, damit deine App auf die richtige Hardware zugreifen kann:
- Verwenden Sie den
Activity-Kontext vom SmartphoneActivityoder denProjectedContext.createHostDeviceContext, um den Kontext des Smartphones abzurufen. - Verwende nicht
getApplicationContext, da der Anwendungskontext fälschlicherweise den Kontext der Brille zurückgeben kann, wenn eine projizierte Aktivität die zuletzt gestartete Komponente war.