Une fois que vous avez demandé et obtenu les autorisations nécessaires, votre application peut accéder au matériel des lunettes audio ou des lunettes avec affichage. Pour accéder au matériel des lunettes (au lieu de celui du téléphone), vous devez utiliser un contexte projeté.
Il existe deux méthodes principales pour obtenir un contexte projeté, selon l'endroit où votre code est exécuté :
Obtenir un contexte projeté si votre code s'exécute dans une activité projetée
Si le code de votre application s'exécute à partir de votre activité projetée, son propre contexte d'activité est déjà un contexte projeté. Dans ce scénario, les appels effectués dans cette activité peuvent déjà accéder au matériel des lunettes.
Obtenir un contexte projeté pour le code exécuté dans un composant d'application pour téléphone
Si une partie de votre application en dehors de votre activité projetée (comme une activité téléphonique ou un service) doit accéder au matériel des lunettes, elle doit explicitement obtenir un contexte projeté. Pour ce faire, utilisez la méthode 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 } } }
Vérifier la validité
Encapsulez l'appel createProjectedDeviceContext dans ProjectedContext.isProjectedDeviceConnected. Tant que cette méthode renvoie true, le contexte projeté reste valide pour l'appareil connecté, et l'activité ou le service de votre application Téléphone (comme un CameraManager) peut accéder au matériel des lunettes.
Nettoyer à la déconnexion
Le contexte projeté est lié au cycle de vie de l'appareil connecté. Il est donc détruit lorsque l'appareil se déconnecte. Lorsque l'appareil se déconnecte, ProjectedContext.isProjectedDeviceConnected renvoie false. Votre application doit écouter cette modification et nettoyer tous les services système (comme un CameraManager) ou les ressources qu'elle a créés à l'aide de ce contexte projeté.
Réinitialiser lors de la reconnexion
Lorsque les lunettes se reconnectent, votre application peut obtenir une autre instance de contexte projeté à l'aide de createProjectedDeviceContext, puis réinitialiser les services ou ressources système à l'aide du nouveau contexte projeté.
Enregistrer du contenu audio avec le micro des lunettes
Vous pouvez enregistrer du contenu audio à partir des lunettes à l'aide du profil mains libres (HFP) Bluetooth. Dans ce mode, les lunettes se connectent au téléphone à l'aide des profils standard Headset et Advanced Audio Distribution Profile (A2DP), et fonctionnent comme un périphérique Bluetooth classique. Si votre application est déjà conçue pour l'enregistrement Bluetooth standard, vous pouvez utiliser cette méthode pour enregistrer l'audio des lunettes sans développement supplémentaire.
Enregistrer du contenu audio à l'aide du profil mains libres Bluetooth
Pour enregistrer du contenu audio à l'aide du profil Bluetooth HFP, demandez d'abord les autorisations d'exécution requises, puis enregistrez le contenu audio à l'aide de l'API AudioManager, comme décrit dans les sections suivantes.
Demander des autorisations
Comme pour tout appareil audio Bluetooth standard, les autorisations RECORD_AUDIO, BLUETOOTH_CONNECT et les autres autorisations associées sont contrôlées par le téléphone, et non par l'appareil connecté (comme des lunettes audio ou des lunettes avec affichage).
Pour demander les autorisations, procédez comme suit :
Déclarez les autorisations suivantes dans le fichier manifeste de votre application :
Demandez les autorisations
RECORD_AUDIOetBLUETOOTH_CONNECTau moment de l'exécution à l'aide du processus d'autorisation Android standard.
Utiliser AudioManager pour acheminer l'audio
Une fois que l'utilisateur a accordé à votre application les autorisations d'exécution nécessaires, utilisez l'API AudioManager pour définir l'appareil de communication sur TYPE_BLUETOOTH_SCO afin de router l'audio via le profil Bluetooth HFP. Cela indique au système de récupérer l'audio du périphérique 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() }
Prendre une photo avec la caméra des lunettes
Pour capturer une image avec la caméra des lunettes, surveillez la connectivité avec monitorProjectedDeviceConnectivity pour obtenir un contexte d'appareil projeté, créez un LifecycleCameraProvider isolé lié à ce contexte, écoutez la présence de la caméra et associez le cas d'utilisation ImageCapture de CameraX.
Tout d'abord, surveillez la connectivité de l'appareil et initialisez LifecycleCameraProvider.createInstance avec un CameraXConfig.Builder à flux unique :
@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() } } } }
Sur CameraX 1.6.0 et versions ultérieures, enregistrez un CameraPresenceListener à l'aide de addCameraPresenceListener pour réagir lorsque la caméra des lunettes est ajoutée ou supprimée :
@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 }
Ensuite, sélectionnez la caméra des lunettes dans availableCameraInfos à l'aide de l'CameraIdentifier fourni par l'écouteur et associez 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 } }
Points clés concernant le code
LifecycleCameraProviderpar appareil : utilisezLifecycleCameraProvider.createInstancepour créer un fournisseur de caméra isolé limité au contexte projeté actif. Étant donné que ledeviceIddu contexte projeté peut changer lorsque les lunettes se déconnectent et se reconnectent alors que le processus de votre application reste actif, la création d'un fournisseur par appareil garantit que CameraX se lie à l'appareil connecté actif.- Écouter la présence de la caméra : sur CameraX 1.6.0 et versions ultérieures, enregistrez un
CameraPresenceListenerà l'aide decameraProvider.addCameraPresenceListenerau lieu d'ouvrir la caméra immédiatement lorsque les lunettes se connectent. La configuration asynchrone entre les lunettes et l'hôte doit se terminer avant que l'OS ne finisse de recréer la caméra des lunettes. De plus, la caméra des lunettes peut également disparaître de manière dynamique lorsqu'elle est connectée (par exemple, lors d'une atténuation thermique).- Ajout de caméra (
onCamerasAdded) : se déclenche après la mise à jour deavailableCameraInfosavec la caméra ajoutée, ce qui évite les problèmes de timing lors de la configuration. - Suppression de la caméra (
onCamerasRemoved) : suit la présence de la caméra plutôt que son état d'utilisation. Ainsi, la dissociation ne libère des ressources que lorsque la caméra des lunettes est retirée, au lieu de réagir lorsque votre propre application ouvre la caméra.
- Ajout de caméra (
- Nettoyage lors de la déconnexion : la fermeture de nettoyage renvoyée à
monitorProjectedDeviceConnectivityappelleremoveCameraPresenceListeneretunbindAll()lorsque les lunettes se déconnectent ou que l'activité est détruite. - Sélection dynamique de la caméra : compare le
CameraIdentifiertransmis àonCamerasAddedavecavailableCameraInfosà l'aide deisOfpour sélectionner dynamiquement la caméra des lunettes. - Résolution personnalisée : crée un
ResolutionSelectorciblant un exemple de format 16:9 et votre résolution préférée (en revenant à la taille inférieure compatible la plus proche) pourImageCapture. Les formats et résolutions acceptés varient selon les appareils et les modes de lunettes (par exemple, 4:3 et 16:9). Interrogez doncStreamConfigurationMapsi vous devez vérifier les tailles exactes acceptées. - Liaison du cycle de vie : lie
ImageCaptureàLifecycleOwner, en gérant automatiquement les transitions d'ouverture et de fermeture de l'appareil photo avec le cycle de vie de l'activité. - Configuration pour le matériel à flux unique : le pipeline de la caméra des lunettes est limité à un seul flux actif à la fois. Lorsque
ImageCaptureest lié seul, CameraX associe par défaut un flux de répétition interne (MeteringRepeating) pour la mise au point et la mesure, ce qui entraîne le blocage du pipeline à flux unique. TransmettezsetRepeatingStreamForced(false)dans leCameraXConfigtransmis àLifecycleCameraProvider.createInstanceafin queImageCapturepuisse effectuer la liaison sans flux d'aperçu.
Une fois la caméra des lunettes configurée, vous pouvez capturer une image avec la classe ImageCapture de CameraX. Consultez la documentation de CameraX pour savoir comment utiliser takePicture pour capturer une image.
Enregistrer un flux avec la caméra des lunettes
Pour capturer des flux au lieu d'une image, remplacez le composant ImageCapture de l'exemple de capture d'image par les composants VideoCapture ou ImageAnalysis, puis modifiez la logique de capture.
Pour en savoir plus sur ces API et leur utilisation, consultez la documentation sur la capture vidéo CameraX et l'analyse d'images CameraX.
Choisir une résolution et une fréquence d'images
Vous devez interroger l'appareil pour connaître les résolutions compatibles et les fréquences d'images maximales correspondantes. Le tableau suivant présente des exemples de valeurs que vous pouvez voir, en fonction du cas d'utilisation de votre application. Pour économiser la batterie et réduire la chaleur sur les lunettes, choisissez la résolution et la fréquence d'images les plus basses qui conviennent à votre cas d'utilisation.
| Cas d'utilisation | Solution | Fréquence d'images |
|---|---|---|
| Reconnaissance de texte (OCR) ou détection de l'environnement | 1920 x 1080 | 1 FPS |
| Streaming vidéo IA (assistants multimodaux) | 1 024 x 768 | 1 FPS |
| Localisation et positionnement visuel (VPS) | 640 x 360 ou 640 x 480 | 10 FPS |
| Appels vidéo | 640 x 360 ou 640 x 480 | 24 FPS |
Interroger la fréquence d'images maximale pour chaque résolution
CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES indique les limites globales de fréquence d'images de l'appareil, qui peuvent être supérieures au débit de streaming accepté par une résolution donnée. Pour obtenir le maximum réel pour chaque résolution sur les lunettes audio et avec affichage, lisez la durée minimale de l'image et convertissez-la en FPS avec 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 } }
Ensuite, utilisez cette valeur pour calculer les limites minFps et maxFps de votre plage de fréquence d'images cible. Limitez la limite inférieure (minFps) à la fréquence d'images maximale de streaming de la résolution calculée à partir de getOutputMinFrameDuration, et définissez une limite supérieure plus élevée (maxFps) comme fenêtre de rattrapage :
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
Points clés concernant le code
- Utilisez le format qui correspond à votre cas d'utilisation. Pour
ImageAnalysis, il s'agit deYUV_420_888. - Pour
VideoCapture, utilisez plutôt les surchargesClass:getOutputSizes(MediaRecorder::class.java)etgetOutputMinFrameDuration(MediaRecorder::class.java, size). - Spécifiez une plage où
maxFpsest supérieur àminFps(par exemple,minFps*2) plutôt que de définir les deux limites sur la même valeur, commeRange(minFps, minFps). La limite inférieure (minFps) définit la fréquence d'images de streaming cible et doit être au maximum la valeur calculée à partir degetOutputMinFrameDuration, tandis que la limite supérieure (maxFps) sert de fenêtre de rattrapage pour les images retardées afin d'éviter une latence persistante. Par exemple, [1,2] ou [1,3] pour un flux à 1 FPS, et [24,30] ou [24,48] pour un flux à 24 FPS.
Configurer la fréquence d'images
Pour configurer la plage de fréquences d'images en fonction de votre cas d'utilisation de 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()
Cet exemple montre la configuration pour VideoCapture et ImageAnalysis, mais vous pouvez implémenter les cas d'utilisation compatibles avec votre application.
Comprendre le comportement du flux
Tenez compte des comportements système suivants lorsque vous utilisez des flux de capture :
- Les résolutions non compatibles sont refusées : si vous demandez une taille qui ne figure pas dans la liste, Camera2 refuse la configuration avant l'ouverture du flux.
- Demander des fréquences d'images supérieures au maximum : si vous demandez une fréquence d'images minimale supérieure au maximum accepté pour votre résolution, la session s'ouvre quand même, mais la fréquence d'images cible des lunettes est limitée à ce maximum accepté, tandis que la limite supérieure continue de servir de limite de fréquence de rattrapage. Par exemple, demander [30,60] à 640 x 480 limite la fréquence d'images cible à 24 FPS (comportement similaire à [24,60]).
- Limitation thermique : lorsque les lunettes chauffent, la fréquence d'images diminue, mais la résolution reste la même. Créez votre application de manière à gérer des fréquences d'images plus faibles ou irrégulières, par exemple en vérifiant les codes temporels des images plutôt qu'en supposant une fréquence fixe.
Accéder au matériel d'un téléphone à partir d'une activité projetée
Une activité projetée peut également accéder au matériel du téléphone (comme l'appareil photo ou le micro) en utilisant createHostDeviceContext(context) pour obtenir le contexte de l'appareil hôte (téléphone) :
@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) }
Lorsque vous accédez à du matériel ou à des ressources spécifiques à l'appareil hôte (téléphone) dans une application hybride (une application contenant à la fois des expériences mobiles et des expériences sur lunettes), vous devez sélectionner explicitement le contexte approprié pour vous assurer que votre application peut accéder au matériel approprié :
- Utilisez le contexte
Activitydu téléphoneActivityouProjectedContext.createHostDeviceContextpour obtenir le contexte du téléphone. - N'utilisez pas
getApplicationContext, car le contexte de l'application peut renvoyer de manière incorrecte le contexte des lunettes si une activité projetée était le composant lancé le plus récemment.