Über einen projizierten Kontext auf die Hardware von Audio- und Displaybrillen zugreifen

XR‑Geräte, für die der Leitfaden gilt
Dieser Leitfaden hilft Ihnen dabei, Erlebnisse für die folgenden Arten von XR-Geräten zu entwickeln.
Audio- und
Display-Brillen

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:

  1. Deklarieren Sie die folgenden Berechtigungen in der Manifestdatei Ihrer App:

  2. Fordern Sie die Berechtigungen RECORD_AUDIO und BLUETOOTH_CONNECT zur 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): Verwende LifecycleCameraProvider.createInstance, um einen isolierten Kameraanbieter zu erstellen, der auf den aktiven projizierten Kontext beschränkt ist. Da sich der deviceId des 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 CameraPresenceListener mit cameraProvider.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, nachdem availableCameraInfos mit 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.
  • Bereinigung bei Verbindungsabbruch: Der Bereinigungs-Closure, der an monitorProjectedDeviceConnectivity zurückgegeben wird, ruft removeCameraPresenceListener und unbindAll() auf, wenn die Verbindung zur Brille getrennt oder die Aktivität beendet wird.
  • Dynamische Kameraauswahl: Gleicht die an onCamerasAdded übergebene CameraIdentifier mit availableCameraInfos ab und verwendet isOf, 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ür ImageCapture. 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, frage StreamConfigurationMap ab.
  • Lebenszyklusbindung: Bindet ImageCapture an LifecycleOwner und 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 ImageCapture allein 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 Sie setRepeatingStreamForced(false) in der CameraXConfig, die an LifecycleCameraProvider.createInstance übergeben wird, damit ImageCapture ohne 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 ImageAnalysis ist das YUV_420_888.
  • Verwenden Sie für VideoCapture stattdessen die Class-Überladungen: getOutputSizes(MediaRecorder::class.java) und getOutputMinFrameDuration(MediaRecorder::class.java, size).
  • Geben Sie einen Bereich an, in dem maxFps größer als minFps ist (z. B. minFps*2), anstatt beide Grenzen auf denselben Wert wie Range(minFps, minFps) festzulegen. Die Untergrenze (minFps) legt die Ziel-Framerate für das Streaming fest und sollte höchstens dem aus getOutputMinFrameDuration berechneten 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 Smartphone Activity oder den ProjectedContext.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.