Présentation de CameraX 1.5 : enregistrement vidéo puissant et capture d'images de niveau professionnel

L'équipe CameraX est ravie d'annoncer la sortie de la version 1.5. Cette dernière mise à jour vise à mettre à votre disposition des fonctionnalités de qualité professionnelle, tout en facilitant plus que jamais la configuration de la session de l'appareil photo.

Pour l'enregistrement vidéo, les utilisateurs peuvent désormais capturer sans effort de superbes vidéos au ralenti ou à fréquence d'images élevée. Plus important encore, la nouvelle API Feature Group vous permet d'activer en toute confiance des combinaisons complexes telles que le HDR 10 bits et 60 FPS, garantissant ainsi des résultats cohérents sur les appareils compatibles.

En ce qui concerne la capture d'images, vous bénéficiez d'une flexibilité maximale grâce à la prise en charge de la capture de fichiers DNG (RAW) non traités et non compressés. De plus, vous pouvez désormais exploiter la sortie Ultra HDR même lorsque vous utilisez des extensions d'appareil photo puissantes.

Ces fonctionnalités reposent sur la nouvelle API SessionConfig, qui simplifie la configuration et la reconfiguration de la caméra. Examinons maintenant ces nouvelles fonctionnalités plus en détail.

Enregistrement vidéo puissant : combinaisons de fonctionnalités et de vitesse élevée

CameraX 1.5 étend considérablement ses fonctionnalités vidéo, ce qui permet des expériences d'enregistrement plus créatives et plus robustes.

Vidéo au ralenti et à fréquence d'images élevée

L'une de nos fonctionnalités les plus attendues, la vidéo au ralenti, est désormais disponible. Vous pouvez désormais capturer des vidéos à haute vitesse (par exemple, 120 ou 240 fps) et les encoder directement dans une vidéo au ralenti spectaculaire. Vous pouvez également enregistrer à la même fréquence d'images élevée pour produire une vidéo d'une fluidité exceptionnelle.

L'implémentation est simple si vous connaissez l'API VideoCapture.

1. Vérifier la compatibilité avec la haute vitesse : utilisez la nouvelle méthode Recorder.getHighSpeedVideoCapabilities() pour vérifier si l'appareil est compatible avec cette fonctionnalité.

val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

if (highSpeedCapabilities == null) {
    // This camera device does not support high-speed video.
    return
}

2. Configurer et lier le cas d'utilisation : utilisez le videoCapabilities renvoyé (qui contient des informations sur la qualité vidéo compatible) pour créer un HighSpeedVideoSessionConfig. Vous devez ensuite interroger les plages de fréquences d'images compatibles via cameraInfo.getSupportedFrameRateRanges() et définir la plage souhaitée. Appelez setSlowMotionEnabled(true) pour enregistrer des vidéos au ralenti. Sinon, l'enregistrement se fera à une fréquence d'images élevée. La dernière étape consiste à utiliser l'élément Recorder.prepareRecording().start() standard pour commencer à enregistrer la vidéo.

val preview = Preview.Builder().build()
val quality = highSpeedCapabilities
        .getSupportedQualities(DynamicRange.SDR).first()

val recorder = Recorder.Builder()
      .setQualitySelector(QualitySelector.from(quality)))
      .build()

val videoCapture = VideoCapture.withOutput(recorder)

val frameRateRange = cameraInfo.getSupportedFrameRateRanges(      
       HighSpeedVideoSessionConfig(videoCapture, preview)
).first()

val sessionConfig = HighSpeedVideoSessionConfig(
    videoCapture, 
    preview, 
    frameRateRange = frameRateRange, 
    // Set true for slow-motion playback, or false for high-frame-rate
    isSlowMotionEnabled = true
)

cameraProvider.bindToLifecycle(
     lifecycleOwner, cameraSelector, sessionConfig)

// Start recording slow motion videos. 
val recording = recorder.prepareRecording(context, outputOption)
      .start(executor, {})

Compatibilité et limites

L'enregistrement à grande vitesse nécessite une compatibilité spécifique avec CameraConstrainedHighSpeedCaptureSession et CamcorderProfile. Effectuez toujours la vérification des fonctionnalités et n'activez l'enregistrement à grande vitesse que sur les appareils compatibles pour éviter une mauvaise expérience utilisateur. Actuellement, cette fonctionnalité est compatible avec les caméras arrière de presque tous les appareils Pixel et de certains modèles d'autres fabricants.

Pour en savoir plus, consultez cet article de blog.

Combiner des caractéristiques en toute confiance : l'API Feature Group

CameraX 1.5 introduit l'API Feature Group, qui élimine les incertitudes liées à la compatibilité des fonctionnalités. Grâce à l'API de requête de combinaison de fonctionnalités d'Android 15, vous pouvez désormais activer plusieurs fonctionnalités en même temps en toute confiance, ce qui garantit une session d'appareil photo stable. Le groupe de fonctionnalités est actuellement compatible avec les fonctionnalités suivantes : HDR (HLG), 60 FPS, stabilisation de l'aperçu et Ultra HDR. Par exemple, vous pouvez activer simultanément le HDR, le 60 FPS et la stabilisation de l'aperçu sur les séries Pixel 10 et Galaxy S25. Nous prévoyons d'ajouter l'enregistrement 4K et le zoom ultra grand angle. 

L'API de groupe de caractéristiques permet deux cas d'utilisation essentiels :

Cas d'utilisation 1 : Prioriser la meilleure qualité

Si vous souhaitez effectuer la capture en utilisant la meilleure combinaison possible de caractéristiques, vous pouvez fournir une liste classée par ordre de priorité. CameraX tentera de les activer dans l'ordre, en sélectionnant la première combinaison entièrement compatible avec l'appareil.

val sessionConfig = SessionConfig(
    useCases = listOf(preview, videoCapture),
    preferredFeatureGroup = listOf(
        GroupableFeature.HDR_HLG10,
        GroupableFeature.FPS_60,
        GroupableFeature.PREVIEW_STABILIZATION
    )
).apply {
    // (Optional) Get a callback with the enabled features to update your UI.
    setFeatureSelectionListener { selectedFeatures ->
        updateUiIndicators(selectedFeatures)
    }
}
processCameraProvider.bindToLifecycle(activity, cameraSelector, sessionConfig)

Dans cet exemple, CameraX tente d'activer les fonctionnalités dans l'ordre suivant :

1. HDR + 60 FPS + stabilisation de l'aperçu
2. HDR + 60 FPS
3. HDR + stabilisation de l'aperçu
4. HDR
5. 60 FPS + stabilisation de l'aperçu
6. 60 FPS
7. Stabilisation de l'aperçu
8. Aucun

Cas d'utilisation 2 : Créer une UI de paramètres visible par l'utilisateur

Vous pouvez désormais indiquer précisément les combinaisons de fonctionnalités compatibles dans l'UI des paramètres de votre application, en désactivant les boutons d'activation/désactivation des options non compatibles, comme illustré ci-dessous. 

Pour déterminer si un bouton d'activation doit être grisé, utilisez les codes suivants pour vérifier la compatibilité des combinaisons de fonctionnalités. Commencez par interroger l'état de chaque fonctionnalité. Une fois qu'une fonctionnalité est activée, interrogez à nouveau les fonctionnalités restantes avec les fonctionnalités activées pour voir si leurs boutons d'activation doivent désormais être grisés en raison de contraintes de compatibilité.

fun disableFeatureIfNotSuported(
   enabledFeatures: Set<GroupableFeature>,     
   featureToCheck:GroupableFeature
) {
 val sessionConfig = SessionConfig(
     useCases = useCases,
     requiredFeatureGroup = enabledFeatures + featureToCheck
 )
 val isSupported = cameraInfo.isFeatureGroupSupported(sessionConfig)

 if (!isSupported) {
     // disable the toggle for featureToCheck
 }
}

Pour en savoir plus, consultez l'article de blog sur les groupes de caractéristiques . 

Autres améliorations vidéo

• Améliorations de la caméra simultanée : avec CameraX 1.5.1, vous pouvez désormais lier simultanément les cas d'utilisation Preview + ImageCapture + VideoCapture pour chaque SingleCameraConfig en mode non-composition. De plus, en mode Rédaction (mêmes cas d'utilisation avec CompositionSettings),  vous pouvez désormais définir le CameraEffect appliqué au résultat final de la composition.
• Coupe dynamique du son : vous pouvez désormais démarrer un enregistrement avec le son coupé à l'aide de PendingRecording.withAudioEnabled(boolean initialMuted) et permettre à l'utilisateur de réactiver le son ultérieurement à l'aide de Recording.mute(boolean muted).
• Amélioration de la gestion de l'espace de stockage insuffisant : CameraX envoie désormais de manière fiable l'erreur VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE, ce qui permet à votre application de gérer correctement les situations de stockage insuffisant et d'en informer l'utilisateur.
• Amélioration en basse lumière : sur les appareils compatibles (comme la série Pixel 10), vous pouvez activer CameraControl.enableLowLightBoostAsync pour éclaircir automatiquement l'aperçu et les flux vidéo dans les environnements sombres.

Capture d'images de qualité professionnelle

CameraX 1.5 apporte des améliorations majeures à ImageCapture pour les développeurs qui exigent une qualité et une flexibilité maximales.

Libérez votre créativité avec la capture DNG (RAW)

Pour un contrôle total du post-traitement, CameraX est désormais compatible avec la capture DNG (RAW). Vous avez ainsi accès aux données d'image non traitées et non compressées directement depuis le capteur de l'appareil photo, ce qui vous permet d'effectuer des retouches et un étalonnage des couleurs de qualité professionnelle. L'API permet de capturer le fichier DNG seul ou de capturer simultanément des sorties JPEG et DNG. Consultez l'exemple de code ci-dessous pour savoir comment capturer simultanément des fichiers JPEG et DNG.

val capabilities = ImageCapture.getImageCaptureCapabilities(cameraInfo)
val imageCapture = ImageCapture.Builder().apply {
    if (capabilities.supportedOutputFormats
             .contains(OUTPUT_FORMAT_RAW_JPEG)) {
        // Capture both RAW and JPEG formats.
        setOutputFormat(OUTPUT_FORMAT_RAW_JPEG)
    }
}.build()
// ... bind imageCapture to lifecycle ...


// Provide separate output options for each format.
val outputOptionRaw = /* ... configure for image/x-adobe-dng ... */
val outputOptionJpeg = /* ... configure for image/jpeg ... */
imageCapture.takePicture(
    outputOptionRaw,
    outputOptionJpeg,
    executor,
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(results: OutputFileResults) {
            // This callback is invoked twice: once for the RAW file
            // and once for the JPEG file.
        }

        override fun onError(exception: ImageCaptureException) {}
    }
)

Ultra HDR pour les extensions d'appareil photo

Profitez du meilleur des deux mondes : la superbe photographie computationnelle des extensions de l'appareil photo (comme le mode Nuit) combinée aux couleurs éclatantes et à la plage dynamique de l'Ultra HDR. Cette fonctionnalité est désormais compatible avec de nombreux téléphones Android haut de gamme récents, comme les gammes Pixel 9/10 et Samsung S24/S25.

// Support UltraHDR when Extension is enabled. 

val extensionsEnabledCameraSelector = extensionsManager
     .getExtensionEnabledCameraSelector(
        CameraSelector.DEFAULT_BACK_CAMERA, ExtensionMode.NIGHT)

val imageCapabilities = ImageCapture.getImageCaptureCapabilities(
               cameraProvider.getCameraInfo(extensionsEnabledCameraSelector)

val imageCapture = ImageCapture.Builder()
     .apply {
       if (imageCapabilities.supportedOutputFormats
                .contains(OUTPUT_FORMAT_JPEG_ULTRA_HDR) {
           setOutputFormat(OUTPUT_FORMAT_JPEG_ULTRA_HDR)

       }

     }.build()

Améliorations de l'API principale et de la facilité d'utilisation

Une nouvelle façon de configurer : SessionConfig

Comme illustré dans les exemples ci-dessus, SessionConfig est un nouveau concept dans CameraX 1.5. Il centralise la configuration et simplifie l'API de deux manières :

1. Plus d'appels unbind() manuels : les API CameraX sont sensibles au cycle de vie. Il "dissociera" implicitement vos cas d'utilisation lorsque l'activité ou un autre LifecycleOwner sera détruit. Toutefois, pour mettre à jour les cas d'utilisation ou changer de caméra, vous devez toujours appeler unbind() ou unbindAll() avant de relier. Désormais, avec CameraX 1.5, lorsque vous liez un nouveau SessionConfig, CameraX met à jour la session de manière fluide, ce qui élimine le besoin d'appels de dissociation.
2. Contrôle déterministe de la fréquence d'images : la nouvelle API SessionConfig introduit un moyen déterministe de gérer la fréquence d'images. Contrairement à l'ancienne méthode setTargetFrameRate, qui n'était qu'une indication, cette nouvelle méthode garantit que la plage de fréquences d'images spécifiée sera appliquée une fois la configuration terminée. Pour garantir la précision, vous devez interroger les fréquences d'images compatibles à l'aide de CameraInfo.getSupportedFrameRateRanges(SessionConfig). En transmettant l'intégralité de SessionConfig, CameraX peut déterminer avec précision les plages compatibles en fonction des configurations de flux.

Camera-Compose est désormais stable

Nous savons à quel point vous appréciez Jetpack Compose, et nous sommes ravis de vous annoncer que la bibliothèque camera-compose est désormais stable dans la version 1.5.1. Cette version inclut des corrections de bugs critiques liés à l'utilisation de CameraXViewfinder avec des fonctionnalités Compose telles que moveableContentOf et Pager, ainsi que la résolution d'un problème d'étirement de l'aperçu. Nous continuerons d'ajouter des fonctionnalités à camera-compose dans les prochaines versions.

Améliorations apportées à ImageAnalysis et CameraControl

• Réglage de l'intensité de la lampe torche : contrôlez précisément la lampe torche de l'appareil grâce à de nouvelles API. Vous pouvez interroger l'intensité maximale acceptée à l'aide de CameraInfo.getMaxTorchStrengthLevel(), puis définir le niveau souhaité avec CameraControl.setTorchStrengthLevel().
• Compatibilité avec NV21 dans ImageAnalysis : vous pouvez désormais demander le format d'image NV21 directement depuis ImageAnalysis, ce qui simplifie l'intégration avec d'autres bibliothèques et API. Pour l'activer, appelez ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21).

Lancez-vous dès maintenant

Mettez à jour vos dépendances vers CameraX 1.5 dès aujourd'hui et découvrez les nouvelles fonctionnalités. Nous avons hâte de découvrir vos créations.

Pour utiliser CameraX 1.5,  ajoutez les dépendances suivantes à votre fichier libs.versions.toml. (Nous vous recommandons d'utiliser la version 1.5.1, qui contient de nombreuses corrections de bugs critiques et des améliorations de la caméra simultanée.) 

[versions]

camerax = "1.5.1"


[libraries]

..

androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "camerax" }

androidx-camera-compose = { module = "androidx.camera:camera-compose", version.ref = "camerax" }

androidx-camera-view = { module = "androidx.camera:camera-view", version.ref = "camerax" }

androidx-camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "camerax" }

androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax" }

androidx-camera-extensions = { module = "androidx.camera:camera-extensions", version.ref = "camerax" }

Ajoutez-les ensuite aux dépendances build.gradle.kts de votre module :

dependencies {

  ..

  implementation(libs.androidx.camera.core)
  implementation(libs.androidx.camera.lifecycle)

  implementation(libs.androidx.camera.camera2)

  implementation(libs.androidx.camera.view) // for PreviewView 
  implementation(libs.androidx.camera.compose) // for compose UI

  implementation(libs.androidx.camera.extensions) // For Extensions 

}

Vous avez des questions ou vous souhaitez contacter l'équipe CameraX ? Rejoignez le groupe de discussion des développeurs CameraX ou envoyez un rapport de bug :

• Groupe de discussion des développeurs CameraX
• Signaler un bug