Android Academy · Leçon

Présentation de CameraX

Pourquoi choisir CameraX plutôt que les anciennes API de caméra.

Présentation de CameraX est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Pourquoi CameraX ?

Ajouter une caméra à une application Android était autrefois laborieux. L’ancienne API android.hardware.camera2 est puissante, mais extrêmement verbeuse, et son comportement varie selon les milliers d’appareils disponibles.

CameraX est une bibliothèque Jetpack qui s’appuie sur Camera2 et vous fournit une API simple, cohérente et consciente du cycle de vie. Dans ce cours, vous utiliserez CameraX pour afficher un aperçu en direct, prendre des photos et enregistrer des vidéos.

Ce que CameraX résout

CameraX a été conçu autour de trois objectifs :

Facilité d’utilisation — beaucoup moins de code répétitif qu’avec Camera2.
Cohérence — Google le teste sur un vaste parc d’appareils, afin que les appareils atypiques se comportent de manière prévisible.
Prise en compte du cycle de vie — la caméra démarre et s’arrête automatiquement selon le cycle de vie de votre écran, ce qui évite de laisser la caméra ouverte.

Vous décrivez ce que vous voulez (un aperçu, une photo ou une vidéo), et CameraX détermine comment le faire sur l’appareil actuel.

Les trois principaux cas d’utilisation

CameraX s’articule autour des cas d’utilisation. Un cas d’utilisation est une fonctionnalité de caméra autonome. Les trois principaux sont :

Preview — afficher à l’écran ce que voit la caméra.
ImageCapture — prendre une photo.
VideoCapture — enregistrer une vidéo.

Vous créez les cas d’utilisation nécessaires, puis vous les reliez à la caméra.

// You create the use cases you need:
val preview = Preview.Builder().build()
val imageCapture = ImageCapture.Builder().build()
// Later you bind them to a lifecycle and a camera.

Ajout des dépendances

CameraX est distribué sous la forme de plusieurs artefacts. Vous les ajoutez au build.gradle.kts de votre module. Une configuration classique inclut la bibliothèque principale, le moteur Camera2, l’intégration au cycle de vie et les utilitaires d’affichage.

Conservez la même version pour tous les artefacts CameraX afin d’éviter les conflits.

dependencies {
    val cameraxVersion = "1.3.4"
    implementation("androidx.camera:camera-core:$cameraxVersion")
    implementation("androidx.camera:camera-camera2:$cameraxVersion")
    implementation("androidx.camera:camera-lifecycle:$cameraxVersion")
    implementation("androidx.camera:camera-view:$cameraxVersion")
    implementation("androidx.camera:camera-video:$cameraxVersion")
}

Déclaration des autorisations

Pour utiliser la caméra, vous devez déclarer l’autorisation CAMERA dans votre AndroidManifest.xml. Si vous enregistrez également des vidéos, vous pouvez avoir besoin de RECORD_AUDIO.

Il s’agit d’autorisations à l’exécution : les déclarer ne suffit pas ; vous devez également les demander à l’utilisateur pendant l’exécution (ce point sera abordé dans les leçons suivantes).

<!-- AndroidManifest.xml -->
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-feature
    android:name="android.hardware.camera.any"
    android:required="false" />

Le CameraProvider

Le point d’entrée de CameraX est ProcessCameraProvider. Il relie les cas d’utilisation à la caméra et au cycle de vie de votre écran.

Vous l’obtenez de manière asynchrone avec getInstance(), qui renvoie un ListenableFuture. En Kotlin, vous pouvez utiliser await() à l’intérieur d’une coroutine.

import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.core.ExperimentalGetImage

suspend fun Context.getCameraProvider(): ProcessCameraProvider {
    return ProcessCameraProvider.getInstance(this).await()
}

Liaison des cas d’utilisation à un cycle de vie

Une fois le fournisseur obtenu, vous liez vos cas d’utilisation à un LifecycleOwner et à un CameraSelector (caméra avant ou arrière).

Comme la liaison tient compte du cycle de vie, CameraX ouvre automatiquement la caméra lorsque votre écran est visible et la ferme lorsqu’il ne l’est plus : aucun nettoyage manuel n’est nécessaire.

val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

cameraProvider.unbindAll()
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    cameraSelector,
    preview,
    imageCapture
)

Choix d’une caméra

Un CameraSelector indique à CameraX quelle caméra physique utiliser. Les deux plus courantes sont la caméra arrière par défaut et la caméra avant par défaut.

Vous pouvez également créer un sélecteur personnalisé pour exiger certaines caractéristiques, mais les valeurs par défaut conviennent à presque toutes les applications.

// Back camera (most common for photos)
val back = CameraSelector.DEFAULT_BACK_CAMERA

// Front camera (selfies, video calls)
val front = CameraSelector.DEFAULT_FRONT_CAMERA

// Toggle between them by swapping the selector and re-binding.

PreviewView : la surface d’affichage

CameraX affiche l’aperçu en direct dans une PreviewView. Il s’agit d’une View Android classique qui gère pour vous la surface, la mise à l’échelle et la rotation.

Dans Jetpack Compose, vous l’intégrez avec AndroidView, ce qui vous permet de placer une View classique dans un composable. Vous mettrez tout cela en place dans la prochaine leçon.

AndroidView(
    factory = { context ->
        PreviewView(context).apply {
            scaleType = PreviewView.ScaleType.FILL_CENTER
        }
    },
    modifier = Modifier.fillMaxSize()
)

Le cycle de vie en pratique

Le principal avantage pratique de CameraX est sa prise en compte du cycle de vie. Avec Camera2, vous deviez ouvrir manuellement la caméra dans onResume et la libérer dans onPause ; un oubli pouvait provoquer des plantages ou bloquer la caméra.

Avec CameraX, dès que vous utilisez bindToLifecycle, le framework s’occupe de tout cela. Lorsque l’utilisateur quitte l’écran, la caméra est automatiquement libérée ; lorsqu’il revient, elle est rouverte.

// No manual open/close needed.
// bindToLifecycle ties the camera to the screen's
// lifecycle, so it follows onStart/onStop for you.
cameraProvider.bindToLifecycle(lifecycleOwner, selector, preview)

Votre modèle mental

Gardez cette représentation à l’esprit pour la suite du cours :

Obtenez un ProcessCameraProvider.
Créez les cas d’utilisation nécessaires (Preview, ImageCapture, VideoCapture).
Choisissez un CameraSelector.
Utilisez bindToLifecycle pour tout relier.

Toute fonctionnalité CameraX n’est qu’une variante de ces quatre étapes.

Vérification rapide

Vérifiez votre compréhension des principes fondamentaux de CameraX.

Récapitulatif

Vous comprenez maintenant la vue d’ensemble de CameraX :

CameraX encapsule Camera2 dans une API plus simple, plus cohérente et consciente du cycle de vie.
Il s’articule autour des cas d’utilisation : Preview, ImageCapture et VideoCapture.
Vous ajoutez les artefacts CameraX, déclarez l’autorisation CAMERA, obtenez un ProcessCameraProvider et utilisez bindToLifecycle.
Un CameraSelector choisit la caméra avant ou arrière ; une PreviewView affiche le flux.

Ensuite, vous mettrez en place un véritable aperçu en direct à l’écran.

Questions Fréquemment Posées

La leçon « Présentation de CameraX » est-elle gratuite ?

Oui — le texte complet de « Présentation de CameraX » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Présentation de CameraX » ?

Pourquoi choisir CameraX plutôt que les anciennes API de caméra. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Présentation de CameraX » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy