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 der Code in einer projizierten Aktivität ausgeführt wird
Wenn der Code Ihrer App innerhalb Ihrer projizierten Aktivität ausgeführt wird, ist der 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 Aufruf createProjectedDeviceContext 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 Hardware der Brille 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ätzliche Entwicklung aufzunehmen.
Audio über 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 erteilt 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, richte den ImageCapture-Anwendungsfall von CameraX ein und binde ihn mit dem richtigen Kontext für deine App an die Kamera der Datenbrille:
/** * Filters [CameraSelector.DEFAULT_BACK_CAMERA] by dynamic [cameraId], 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) fun bindGlassesImageCapture( cameraProvider: ProcessCameraProvider, cameraId: String, lifecycleOwner: LifecycleOwner, preferredResolution: Size = Size(1920, 1080) ): ImageCapture? { // Within a projected context, the glasses' primary outward-facing camera maps to // `DEFAULT_BACK_CAMERA`. Narrow it down by the dynamic `cameraId` because the projected // camera's ID may change when recreated. val cameraSelector = CameraSelector.Builder() .addCameraFilter { cameraInfos -> // Filter the `DEFAULT_BACK_CAMERA` candidates by our target dynamic ID. CameraSelector.DEFAULT_BACK_CAMERA.filter(cameraInfos).filter { info -> Camera2CameraInfo.from(info).cameraId == cameraId } } .build() // 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 (!cameraProvider.hasCamera(cameraSelector)) { Log.w(TAG, "Glasses camera (ID: $cameraId) is not currently available.") return null } 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() return try { // 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: 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
- Ruft eine Instanz von
ProcessCameraProvidermit dem Kontext des Geräts mit der Projektionsfläche ab. - Im Rahmen des projizierten Kontexts wird die primäre, nach außen gerichtete Kamera der Brille bei der Auswahl einer Kamera der
DEFAULT_BACK_CAMERAzugeordnet. - Bei einer Vorabprüfung wird mit
cameraProvider.hasCamera(cameraSelector)geprüft, ob die ausgewählte Kamera auf dem Gerät verfügbar ist, bevor fortgefahren wird. - Verwendet Camera2 Interop mit
Camera2CameraInfo, um die zugrunde liegendeCameraCharacteristics#SCALER_STREAM_CONFIGURATION_MAPzu lesen. Das kann für erweiterte Prüfungen der unterstützten Auflösungen nützlich sein. - Eine benutzerdefinierte
ResolutionSelectorwird erstellt, um die Auflösung des Ausgabebilds fürImageCapturegenau zu steuern. - Erstellt einen
ImageCapture-Anwendungsfall, der mit einem benutzerdefiniertenResolutionSelectorkonfiguriert ist. - Bindet den Anwendungsfall
ImageCapturean den Lebenszyklus der Aktivität. Dadurch wird das Öffnen und Schließen der Kamera automatisch basierend auf dem Status der Aktivität verwaltet, z. B. wird die Kamera gestoppt, wenn die Aktivität pausiert wird. - Konfiguration für Single-Stream-Hardware: Die Kamerapipeline der Brille ist auf einen einzelnen aktiven Stream beschränkt. Wenn
ImageCaptureallein gebunden ist, hängt CameraX standardmäßig einen internen sich wiederholenden Stream (MeteringRepeating) für Fokus und Messung an, was dazu führt, dass die Streamingpipeline mit einem einzelnen Stream ins Stocken gerät. Wenn SieImageCaptureohne Vorschaustream binden möchten, deaktivieren Sie den erzwungenen Wiederholungsstream, indem SiesetRepeatingStreamForced(false)fürCameraXConfig.Builderfestlegen. Implementieren Sie dazu beispielsweiseCameraXConfig.Providerin IhrerApplication-Klasse oder konfigurieren SieProcessCameraProvidervor der Initialisierung.
Nachdem die Kamera der Brille eingerichtet ist, kannst du mit der Klasse ImageCapture 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 finden Sie Beispiele für Werte, die je nach Anwendungsfall Ihrer App angezeigt werden können. Um den Akku zu schonen und die Wärmeentwicklung der Brille 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. Um den tatsächlichen Höchstwert für jede Auflösung bei Audio- und Display-Brillen zu ermitteln, lesen Sie die minimale Framedauer und rechnen Sie 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 Bereich der Zielframerate 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-Streaming-Framerate fest und sollte höchstens dem ausgetOutputMinFrameDurationberechneten Wert entsprechen. Die Obergrenze (maxFps) dient als Aufholfenster für verzögerte Frames, um eine dauerhafte Latenz zu verhindern. 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 jedoch 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 Sie eine Größe anfordern, 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 minimale Framerate 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 du beispielsweise [30, 60] bei 640 × 480 anforderst,wird die Zielframerate auf 24 fps begrenzt (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, indem du beispielsweise Frame-Zeitstempel 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 Kontext
Activityvom 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.