Android Academy · Leçon

Prendre des photos

Capturez et enregistrez une image.

Prendre des photos est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Prise d’une photo

Une fois l’aperçu affiché à l’écran, l’étape suivante consiste à prendre une photo. CameRX gère cette opération avec le cas d’utilisation ImageCapture.

Vous lierez ImageCapture à l’aperçu, puis appellerez takePicture() lorsque l’utilisateur appuiera sur le bouton de prise de vue, afin d’enregistrer le résultat dans la galerie de l’appareil.

Création du cas d’utilisation ImageCapture

ImageCapture se configure avec un générateur. Une option utile est le mode de capture, qui établit un compromis entre latence et qualité :

CAPTURE_MODE_MINIMIZE_LATENCY — déclenchement rapide.
CAPTURE_MODE_MAXIMIZE_QUALITY — meilleure image, légèrement plus lente.

val imageCapture = ImageCapture.Builder()
    .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
    .build()

Liaison de Preview et ImageCapture

Vous pouvez lier plusieurs cas d’utilisation en même temps. Transmettez preview et imageCapture à bindToLifecycle afin que la caméra fournisse le flux en direct tout en étant prête à prendre une photo.

cameraProvider.unbindAll()
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    preview,
    imageCapture
)

Où enregistrer : MediaStore

La méthode moderne, compatible avec le stockage cloisonné, pour enregistrer une photo consiste à utiliser MediaStore. Vous décrivez le fichier (nom, type MIME, dossier) avec ContentValues, puis laissez le système le placer dans la collection partagée Pictures.

Cette méthode fonctionne sans l’ancienne autorisation WRITE_EXTERNAL_STORAGE sur Android 10 et versions ultérieures.

val name = "photo_${System.currentTimeMillis()}"
val contentValues = ContentValues().apply {
    put(MediaStore.MediaColumns.DISPLAY_NAME, name)
    put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
    put(MediaStore.Images.Media.RELATIVE_PATH, "Pictures/MyApp")
}

Options de sortie

Pour indiquer à CameraX où écrire le fichier JPEG, créez un OutputFileOptions à partir du résolveur de contenu, de l’URI de la collection cible et de vos ContentValues.

val outputOptions = ImageCapture.OutputFileOptions
    .Builder(
        context.contentResolver,
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
        contentValues
    )
    .build()

Appel de takePicture()

Déclenchez maintenant la capture. takePicture() reçoit les options de sortie, un Executor et un rappel. CameRX signale la réussite ou l’erreur de manière asynchrone.

Utilisez ContextCompat.getMainExecutor(context) afin que le rappel s’exécute sur le thread principal.

imageCapture.takePicture(
    outputOptions,
    ContextCompat.getMainExecutor(context),
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(output: ImageCapture.OutputFileResults) {
            val savedUri = output.savedUri
            // Photo saved! Show a confirmation.
        }
        override fun onError(exc: ImageCaptureException) {
            // Handle the failure.
        }
    }
)

Gérer le résultat

En cas de réussite, OutputFileResults.savedUri fournit l’URI de l’image enregistrée. Vous pouvez l’afficher (avec Coil), la partager ou afficher une Snackbar confirmant l’enregistrement.

En cas d’erreur, ImageCaptureException vous indique ce qui s’est mal passé — consignez l’erreur et informez l’utilisateur.

override fun onImageSaved(output: ImageCapture.OutputFileResults) {
    val uri = output.savedUri ?: return
    Toast.makeText(context, "Saved: $uri", Toast.LENGTH_SHORT).show()
}

Connecter un bouton d’obturateur

Dans Compose, superposez un bouton d’obturateur à votre aperçu à l’aide d’une Box. Faites remonter la référence ImageCapture afin que le onClick du bouton puisse appeler takePhoto.

Box(modifier = Modifier.fillMaxSize()) {
    CameraPreview(imageCapture = imageCapture)
    IconButton(
        onClick = { takePhoto(context, imageCapture) },
        modifier = Modifier
            .align(Alignment.BottomCenter)
            .padding(32.dp)
    ) {
        Icon(Icons.Default.PhotoCamera, contentDescription = "Take photo")
    }
}

Extraire takePhoto()

Gardez votre composable clair en déplaçant la logique de capture dans une fonction utilitaire. Celle-ci reçoit le contexte et le cas d’utilisation ImageCapture, construit les options de sortie et appelle takePicture.

fun takePhoto(context: Context, imageCapture: ImageCapture) {
    val values = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, "IMG_${System.currentTimeMillis()}")
        put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
    }
    val options = ImageCapture.OutputFileOptions.Builder(
        context.contentResolver,
        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
        values
    ).build()

    imageCapture.takePicture(
        options,
        ContextCompat.getMainExecutor(context),
        object : ImageCapture.OnImageSavedCallback {
            override fun onImageSaved(o: ImageCapture.OutputFileResults) {}
            override fun onError(e: ImageCaptureException) {}
        }
    )
}

Flash et rotation

Deux dernières touches :

Flash : définissez imageCapture.flashMode sur FLASH_MODE_ON, OFF ou AUTO.
Rotation : CameRX utilise la rotation cible pour orienter correctement le fichier JPEG enregistré ; maintenez-la à jour pour garantir une orientation exacte.

imageCapture.flashMode = ImageCapture.FLASH_MODE_AUTO
// Update target rotation when the device rotates:
imageCapture.targetRotation = display.rotation

Tout assembler

Le flux complet de prise de photos est le suivant : construisez ImageCapture → liez-le à l’aperçu → lors de l’appui sur l’obturateur, construisez OutputFileOptions et appelez takePicture → gérez onImageSaved / onError.

Vous obtenez ainsi un appareil photo complet qui enregistre les images dans la galerie, en seulement quelques lignes.

Vérification rapide

Vérifiez que vous avez compris le flux de prise de photos.

Récapitulatif

Vous pouvez maintenant prendre et enregistrer des photos avec CameRX :

Construisez un cas d’utilisation ImageCapture et liez-le à l’aperçu.
Décrivez la sortie avec ContentValues et MediaStore pour le stockage cloisonné.
Appelez takePicture() avec OutputFileOptions, un exécuteur et un OnImageSavedCallback.
Lisez savedUri en cas de réussite ; gérez ImageCaptureException en cas d’erreur.

Ensuite, vous enregistrerez des vidéos avec le cas d’utilisation VideoCapture.

Questions Fréquemment Posées

La leçon « Prendre des photos » est-elle gratuite ?

Oui — le texte complet de « Prendre des photos » 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 « Prendre des photos » ?

Capturez et enregistrez une image. 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 3 sur 4.

Combien de temps prend la leçon « Prendre des photos » ?

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