Utiliser un appareil comme webcam

Pour les appareils équipés d'Android 14 QPR1 ou version ultérieure, Android permet d'utiliser l'appareil comme webcam USB. Les appareils Android compatibles avec cette fonctionnalité sont annoncés comme un appareil UVC, ce qui permet à un large éventail d'hôtes USB avec différents systèmes d'exploitation (par exemple, Linux, macOS, Windows et ChromeOS) d'utiliser l' appareil photo de l'appareil comme webcam. Le service DeviceAsWebcam est compatible avec cette fonctionnalité pour utiliser l'appareil comme webcam.

Service DeviceAsWebcam

Le service DeviceAsWebcam dans AOSP inclut une activité d'aperçu (DeviceAsWebcamPreview.java) qui permet aux utilisateurs de cadrer la scène. L'activité d'aperçu permet à l'utilisateur d'effectuer les opérations suivantes :

  • Prévisualiser l'apparence du flux de la webcam sur la machine hôte avant le début de la diffusion.

  • Personnaliser le flux de la webcam envoyé à l'hôte de différentes manières :

    • Sélectionner la caméra à diffuser (avant ou arrière).
    • Sélectionner le niveau de zoom à l'aide d'un curseur ou de boutons.
    • Appuyer sur une région spécifique de l'aperçu pour faire la mise au point ou la supprimer sur une région.

L'activité d'aperçu fonctionne avec les fonctionnalités d'accessibilité générales sur Android, telles que TalkBack, Switch Access, et Voice Access.

Flux de la webcam transmis à l'organisateur

Figure 1. Flux de la webcam diffusé sur un hôte avec un aperçu contrôlant le flux.

Architecture

L'architecture permettant d'utiliser un appareil comme webcam est illustrée à la figure 2. La description suivante présente le flux d'interaction du service DeviceAsWebcam avec le reste du framework Android :

  1. L'utilisateur sélectionne l'option de webcam USB dans l'application Paramètres.
  2. L'application Paramètres envoie un appel de binder à system_server via la classe UsbManager pour l'informer que FUNCTION_UVC est sélectionné.
  3. Le serveur système effectue les opérations suivantes :
    1. Informe le HAL du gadget USB de récupérer la fonction de gadget UVC via un appel d'interface HAL setUsbFunctions.
    2. Informe le HAL du gadget USB de configurer le pilote du gadget UVC à l'aide de ConfigFs.
  4. Lorsqu'il reçoit un rappel du HAL du gadget, system_server envoie une diffusion au framework pour qu'elle soit récupérée par le service DeviceAsWebcam.
  5. Le pilote du gadget USB démarre le flux de la webcam lorsqu'il reçoit des commandes de configuration de l'hôte via les nœuds V4L2 à l'adresse /dev/video*.

Architecture de l'appareil en tant que webcam

Figure 2. Architecture de DeviceAsWebcam.

Implémentation

Cette section explique comment prendre en charge l'utilisation d'un appareil Android comme webcam.

Prise en charge du noyau

Pour Android 14 ou version ultérieure, l'image de noyau générique (GKI) active le pilote du gadget UVC par défaut (pour en savoir plus, consultez le correctif AOSP).

Prise en charge de l'UVC dans le HAL du gadget

À partir d'Android 14, la fonction UVC est incluse dans l' GadgetFunction.aidl interface HAL. Pour le HAL du gadget, le gadget UVC est monté sur ConfigFS de la même manière que les autres fonctions ConfigFS, telles que MTP ou ADB.

Pour implémenter le HAL du gadget, apportez des modifications pour monter la fonction UVC sur ConfigFS. Voici un exemple d'extrait d'implémentation du HAL du gadget compatible avec la fonction UVC :

UsbGadget::setCurrentUsbFunctions(long functions) {
   ...
   // Existing functions
   if ((functions & GadgetFunction::MTP) != 0) {
       ...
       linkFunction("ffs.mtp"); // Mount to ConfigFS
       ...
   }
   ...
   // UVC function follows the same pattern!
   if ((&functions  GadgetFunction::UVC) != 0) {
       ...
       linkFunction("uvc.0"); // Mount to ConfigFS
       ...
   }
   ...
}

Lorsque l'appareil fait office de webcam, assurez-vous que le HAL du gadget USB annonce les combinaisons VID/PID appropriées.

Étant donné que toute la logique UVC se trouve dans l'initialisation du fournisseur ou dans le service DeviceAsWebcam, aucune logique spécifique à l'UVC n'est requise dans le HAL du gadget, à l'exception de la création d'un lien symbolique entre la fonction UVC et ConfigFS.

Pour obtenir des conseils supplémentaires sur l'implémentation, consultez l'exemple de code suivant dans AOSP :

Configurer ConfigFS avec des configurations UVC

Pour informer le pilote du gadget UVC des formats, des tailles et des fréquences d'images compatibles avec la webcam Android, configurez ConfigFS avec des configurations UVC. Pour en savoir plus, consultez la documentation Linux en amont sur l'ABI du gadget UVC ConfigFS.

Voici un exemple de la façon dont l'initialisation du fournisseur peut configurer le pilote du gadget UVC (extrait de code dans AOSP) :

# uvc function
   mkdir /configfs_path/functions/uvc.0
   write /configfs_path/functions/uvc.0/function_name "Android Webcam"
   write /configfs_path/functions/uvc.0/streaming_maxpacket 3072
   # setup control params
   mkdir /configfs_path/functions/uvc.0/control/header/h
   symlink /configfs_path/functions/uvc.0/control/header/h \
                /configfs_path/functions/uvc.0/control/class/fs/h
   symlink /configfs_path/functions/uvc.0/control/header/h \
                /configfs_path/functions/uvc.0/control/class/ss/h
   # advertise 1080p resolution for webcam encoded as mjpeg
   mkdir /configfs_path/functions/uvc.0/streaming/mjpeg/m/1080p
   write /configfs_path/functions/uvc.0/streaming/mjpeg/m/1080p/wHeight 1080
   write /configfs_path/functions/uvc.0/streaming/mjpeg/m/1080p/wWidth 1920
   write /configfs_path/functions/uvc.0/streaming/mjpeg/m/1080p/dwMaxVideoFrameBufferSize 4147200
   # advertise 30 fps support for 1080p.
   write /configfs_path/functions/uvc.0/streaming/mjpeg/m/1080p/dwDefaultFrameInterval 333333
   write /configfs_path/functions/uvc.0/streaming/mjpeg/m/1080p/dwFrameInterval "333333"
   # setup streaming params
   mkdir /configfs_path/functions/uvc.0/streaming/header/h
   symlink /configfs_path/functions/uvc.0/streaming/mjpeg/m \
                /configfs_path/functions/uvc.0/streaming/header/h/m
   symlink /configfs_path/functions/uvc.0/streaming/header/h \
                /configfs_path/functions/uvc.0/streaming/class/fs/h
   symlink /configfs_path/functions/uvc.0/streaming/header/h \
                /configfs_path/functions/uvc.0/streaming/class/hs/h
   symlink /configfs_path/functions/uvc.0/streaming/header/h \
                /config/usb_gadget/g1/functions/uvc.0/streaming/class/ss/h
   # ...

Cet extrait configure le pilote du gadget UVC pour qu'il annonce un flux MJPEG 1080p à 30 images par seconde. Ces fonctionnalités sont communiquées à l'hôte USB lorsqu'il interroge les résolutions et les fréquences d'images compatibles.

Voici des consignes générales pour sélectionner les configurations annoncées par la webcam :

  • Les deux formats de flux compatibles avec le service DeviceAsWebcam sont MJPEG et YUYV non compressé.
  • L'USB 2.0 est compatible avec le transfert de données à 480 Mbit/s (60 Mo/s). Cela signifie qu'à 30 images par seconde, chaque image doit avoir une taille maximale de 2 Mo, et à 60 images par seconde, une taille maximale de 1 Mo.
    • Flux non compressés (YUYV) : à 30 images par seconde, la taille d'image maximale prise en charge est de 720p, car YUYV est de 2 octets par pixel.
    • Flux MJPEG compressés : en supposant un taux de compression de 1:10 à partir de YUV, l'USB 2.0 peut prendre en charge la 4K (1,18 Mo par image).
  • Les appareils photo avant et arrière principaux doivent être compatibles avec toutes les tailles d'image annoncées. En effet, l'utilisateur peut passer d'un ID de caméra à l'autre à l'aide de l'interface utilisateur d'aperçu. Pour les flux MJPEG, nous recommandons aux fournisseurs d'annoncer des tailles d'image de 480p (640 x 480), 720p (1 280 x 820) et 1080p (1 920 x 1 080), car il s'agit de tailles couramment utilisées par les applications hôtes.
  • Les appareils photo avant et arrière principaux doivent être compatibles avec toutes les fréquences d'images annoncées. Nous recommandons vivement aux fournisseurs de prendre en charge 30 images par seconde.

Pour obtenir un exemple d'ajout de configurations de flux de webcam (ConfigFS), consultez l'exemple de correctif AOSP.

Activer la webcam dans la compilation

Pour activer le service DeviceAsWebcam, vous devez définir la propriété système ro.usb.uvc.enabled sur true dans le fichier device.mk.

# Enable UVC support
PRODUCT_VENDOR_PROPERTIES += \
    ro.usb.uvc.enabled=true

Lorsque cette propriété système est activée, une option Webcam s'affiche dans l'application Paramètres sous les préférences USB, comme illustré à la figure 3. Lorsque l'option est sélectionnée, l'appareil Android apparaît comme une webcam USB sur l'appareil hôte.

Préférences USB dans l'application Paramètres

Figure 3. Préférences USB dans l'application Paramètres.

Vous pouvez également définir l'appareil sur la fonction de webcam USB via ADB à l'aide de la commande suivante :

adb shell svc usb setFunctions uvc

Tenir compte des problèmes d'alimentation et thermiques

Les opérations de la webcam signifient que l'appareil photo d'un appareil peut être allumé pendant plusieurs heures par jour. Nous vous recommandons donc de prendre des mesures pour vous assurer que la consommation d'énergie et la température de l'appareil restent dans certaines limites. Voici les solutions recommandées pour limiter la consommation d'énergie :

  • Pour améliorer les performances énergétiques du HAL de l'appareil photo, activez STREAM_USE_CASE_VIDEO_CALL dans le service DeviceAsWebcam.

  • Si l'alimentation est un problème même lorsque STREAM_USE_CASE_VIDEO_CALL est activé, le service DeviceAsWebcam offre une option permettant de réduire davantage la consommation d'énergie en utilisant des flux physiques. Vous pouvez utiliser des superpositions de ressources d'exécution (RRO) pour spécifier l'appareil photo physique à utiliser. Les flux physiques réduisent considérablement la qualité vidéo et entraînent une expérience utilisateur déroutante. N'utilisez donc cette solution qu'en dernier recours. L'optimisation de STREAM_USE_CASE_VIDEO_CALL est la solution privilégiée pour les problèmes d'alimentation. Pour en savoir plus sur les RRO compatibles avec le DeviceAsWebcam service, consultez le fichier readme.md.

    Voici un exemple de configuration d'un RRO pour utiliser l'ID de caméra physique 3 au lieu de l'ID de caméra logique 0. Pour obtenir un exemple dans AOSP, consultez DeviceAsWebcamRaven.

    // For logical camera id 0 - use physical camera id 3
{"0": {"3" : "UW"}}

Validation

Pour tester l'implémentation du service DeviceAsWebcam sur votre appareil, utilisez les tests suivants :

  • Test de vérification CTS de la webcam : vérifiez que les formats, les tailles et les fréquences d'images sont compatibles avec l'appareil.
  • Tests manuels : vérifiez que la fonctionnalité de webcam fonctionne avec différentes applications hôtes sur différents systèmes d'exploitation hôtes.

Problèmes connus

Voici les problèmes connus concernant le service DeviceAsWebcam :