L'équipe CameraX est ravie d'annoncer la sortie de la version 1.5. Cette dernière mise à jour vise à vous offrir des fonctionnalités de qualité professionnelle et à simplifier 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 des 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 HDR 10 bits et 60 FPS, ce qui garantit 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 de caméra puissantes.

Ces fonctionnalités reposent sur la nouvelle API SessionConfig, qui simplifie la configuration et la reconfiguration de l'appareil photo. Examinons maintenant en détail ces nouvelles fonctionnalités intéressantes.

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

CameraX 1.5 étend considérablement ses fonctionnalités vidéo, ce qui permet des expériences d'enregistrement plus créatives et 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 exceptionnellement fluide.

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

1. Vérifiez 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. Configurez et liez le cas d'utilisation : utilisez l'élément videoCapabilities renvoyé (qui contient des informations sur la qualité vidéo acceptée) pour créer un HighSpeedVideoSessionConfig. Vous devez ensuite interroger les plages de fréquence d'images acceptées via cameraInfo.getSupportedFrameRateRanges() et définir la plage souhaitée. Appelez setSlowMotionEnabled(true) pour enregistrer des vidéos au ralenti. Sinon, des vidéos à fréquence d'images élevée seront enregistrées. La dernière étape consiste à utiliser le Recorder.prepareRecording().start() habituel pour commencer l'enregistrement de 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 à haute vitesse nécessite la prise en charge de CameraConstrainedHighSpeedCaptureSession et de CamcorderProfile. Effectuez toujours la vérification des fonctionnalités et n'activez l'enregistrement à haute vitesse que sur les appareils compatibles pour éviter une mauvaise expérience utilisateur. Actuellement, cette fonctionnalité est disponible sur les caméras arrière de presque tous les appareils Pixel et sur certains modèles d'autres fabricants.

Pour en savoir plus, consultez l'article de blog.

Combinez des fonctionnalités 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, ce qui garantit une session de caméra stable. Le groupe de fonctionnalités est actuellement compatible avec : HDR (HLG), 60 FPS, stabilisation de l'aperçu et Ultra HDR. Par exemple, vous pouvez activer simultanément HDR, 60 FPS et la stabilisation de l'aperçu sur les séries Pixel 10 et Galaxy S25. Des améliorations futures sont prévues pour inclure l'enregistrement 4K et le zoom ultra-large. 

L'API Feature Group permet deux cas d'utilisation essentiels :

Cas d'utilisation 1 : Prioriser la meilleure qualité

Si vous souhaitez effectuer une capture en utilisant la meilleure combinaison possible de fonctionnalités, vous pouvez fournir une liste priorisée. 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 interface utilisateur de paramètres destinée aux utilisateurs

Vous pouvez désormais refléter avec précision les combinaisons de fonctionnalités compatibles dans l'interface utilisateur des paramètres de votre application, en désactivant les boutons pour les options non compatibles, comme illustré ci-dessous. 

Pour déterminer si un bouton 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é individuelle. 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 doivent maintenant ê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 le groupe de fonctionnalités . 

Autres améliorations vidéo

• Améliorations simultanées de la caméra : 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 composition (mêmes cas d'utilisation avec CompositionSettings),  vous pouvez désormais définir le CameraEffect appliqué au résultat final de la composition.
• Désactivation dynamique du son : vous pouvez désormais démarrer un enregistrement en mode silencieux à 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).
• Gestion améliorée du stockage insuffisant : CameraX distribue 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 faible 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é grâce à la capture DNG (RAW)

Pour un contrôle total sur le 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 à partir du capteur de l'appareil photo, ce qui permet une édition 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 de caméra

Profitez du meilleur des deux mondes : la photographie computationnelle époustouflante des extensions de caméra (comme le mode Nuit) combinée aux couleurs éclatantes et à la plage dynamique d'Ultra HDR. Cette fonctionnalité est désormais disponible sur de nombreux téléphones Android haut de gamme récents, tels que les séries 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 l'usabilité

Une nouvelle façon de configurer : SessionConfig

Comme vous pouvez le voir 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 principales :

1. Plus d'appels manuels unbind() : les API CameraX sont compatibles avec le cycle de vie. Elles "délieront" implicitement vos cas d'utilisation lorsque l'activité ou un autre LifecycleOwner sera détruit. Toutefois, la mise à jour des cas d'utilisation ou le changement d'appareil photo nécessitent toujours d'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 transparente, ce qui élimine le besoin d'appels de déliement.
2. Contrôle déterministe de la fréquence d'images : la nouvelle API SessionConfig introduit une manière déterministe de gérer la fréquence d'images. Contrairement à la précédente setTargetFrameRate, qui n'était qu'une indication, cette nouvelle méthode garantit que la plage de fréquence d'images spécifiée sera appliquée une fois la configuration réussie. Pour garantir la précision, vous devez interroger les fréquences d'images acceptées à l'aide de CameraInfo.getSupportedFrameRateRanges(SessionConfig). En transmettant l'intégralité de SessionConfig, CameraX peut déterminer avec précision les plages acceptées 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 d'annoncer que la camera-compose bibliothèque 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 à ajouter des fonctionnalités à camera-compose dans les prochaines versions.

Améliorations d'ImageAnalysis et de CameraControl

• Ajustement de l'intensité de la lampe torche : bénéficiez d'un contrôle précis sur la lampe torche de l'appareil grâce aux nouvelles API. Vous pouvez interroger l'intensité maximale acceptée à l'aide de CameraInfo.getMaxTorchStrengthLevel(), puis définir le niveau souhaité avec CameraControl.setTorchStrengthLevel().
• Prise en charge de NV21 dans ImageAnalysis: vous pouvez désormais demander le format d'image NV21 directement à partir de ImageAnalysis, ce qui simplifie l'intégration avec d'autres bibliothèques et API. Pour ce faire, 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 intéressantes. Nous sommes impatients de voir ce que vous allez créer.

Pour utiliser CameraX 1.5,  veuillez ajouter 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 simultanées de la caméra.)

[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 ensuite ces éléments 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 signalez un bug :

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