Caméra dans le développement mobile : ce que c'est, types d'API et comment l'utiliser

Qu'est-ce qu'une caméra dans les applications mobiles

Une caméra mobile est un module optique intégré composé d'un objectif, d'un capteur d'image et d'un processeur de signal d'image (ISP). Le développeur accède à la caméra via le système d'exploitation à l'aide de frameworks spécialisés. Sur Android, il s'agit de Camera2 API (bas niveau) et CameraX (haut niveau, basé sur Camera2), et sur iOS — AVFoundation et UIKit pour les scénarios simples. Chaque plateforme fournit son propre ensemble d'outils, mais le concept général est le même : l'application initialise une session de capture, configure les paramètres (résolution, mise au point, exposition) et reçoit un flux d'images ou des images individuelles.

Capacités matérielles des caméras modernes

Les caméras mobiles modernes prennent en charge de nombreux modes de prise de vue : HDR, mode nuit, portrait avec flou d'arrière-plan, vidéo au ralenti et enregistrement au format RAW. Le développeur a accès aux réglages logiciels : ISO (sensibilité du capteur), vitesse d'obturation (exposition), balance des blancs, mise au point (automatique et manuelle) et stabilisation d'image. Les appareils phares peuvent avoir jusqu'à 4 caméras avec différentes distances focales, et l'application peut sélectionner une caméra spécifique par ID.

Types d'API pour travailler avec la caméra

Les plateformes mobiles proposent plusieurs API pour travailler avec la caméra, variant en niveau d'abstraction et en fonctionnalités. Le choix d'une API spécifique dépend des exigences du projet : pour une simple capture de photos, CameraX ou UIImagePickerController suffit ; pour les applications professionnelles, Camera2 ou AVFoundation avec contrôle direct du capteur est nécessaire. Voici une comparaison des principales API.

Quand choisir CameraX

CameraX est le choix optimal pour la plupart des applications Android qui ont besoin d'une caméra sans personnalisation approfondie. La bibliothèque gère automatiquement le cycle de vie de l'Activity et du Fragment, prend en charge les autorisations et garantit la compatibilité entre différentes versions d'Android. CameraX garantit un comportement cohérent sur 95 % des appareils Android grâce à sa couche de compatibilité. Si vous avez besoin d'un aperçu de la caméra (Preview), d'une capture de photo (ImageCapture) ou d'une analyse d'image (ImageAnalysis) — CameraX gère les trois scénarios sans écrire de code complexe.

Quand choisir Camera2

Camera2 est une API de bas niveau pour les scénarios professionnels : enregistrement RAW, réglage manuel de l'exposition, capture en rafale et contrôle simultané de plusieurs caméras. Camera2 exige du développeur une compréhension approfondie du pipeline de capture d'images, de la gestion StateMachine et du traitement des callbacks. Utilisez Camera2 uniquement si CameraX ne couvre pas les exigences : par exemple, les applications de numérisation de documents avec mise au point manuelle ou les caméras personnalisées avec résolution non standard.

Demande d'autorisations d'accès à la caméra

L'accès à la caméra nécessite l'autorisation explicite de l'utilisateur sur les deux plateformes. Sur Android, l'autorisation CAMERA est ajoutée au manifeste, et à partir d'Android 6.0, l'autorisation doit également être demandée au moment de l'exécution via ActivityCompat.requestPermissions. Sur iOS, la clé NSCameraUsageDescription est ajoutée à Info.plist avec une description de la raison d'utilisation de la caméra. Sans cette description, l'application plantera lors de la tentative d'accès à la caméra. À partir d'iOS 14, la boîte de dialogue d'autorisation affiche non seulement le nom de l'application mais aussi la raison spécifiée — le libellé doit être clair pour l'utilisateur.

Implémentation sur Android avec CameraX

CameraX simplifie le travail avec la caméra à seulement quelques lignes de code. Pour lancer un aperçu, vous devez créer une instance de Preview, la lier à un LifecycleOwner et obtenir un SurfaceProvider pour l'affichage. Pour la capture de photos, ImageCapture avec une cible de sauvegarde est utilisé. Voici un exemple complet de lancement de la caméra et de prise de photo avec CameraX en Kotlin.

Configuration de Preview et ImageCapture

val preview = Preview.Builder()
    .build()
    .also {
        it.surfaceProvider = viewFinder.surfaceProvider
    }

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

val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
cameraProviderFuture.addListener(Runnable {
    val cameraProvider = cameraProviderFuture.get()
    val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

    try {
        cameraProvider.unbindAll()
        cameraProvider.bindToLifecycle(
            this, cameraSelector, preview, imageCapture
        )
    } catch (e: Exception) {
        Log.e("CameraX", "Échec de la liaison", e)
    }
}, ContextCompact.getMainExecutor(this))

La méthode bindToLifecycle lie la caméra au cycle de vie de l'Activity — lors de la rotation de l'écran ou du passage en arrière-plan, la caméra est automatiquement libérée. CameraSelector.DEFAULT_BACK_CAMERA sélectionne la caméra arrière ; pour la caméra avant, DEFAULT_FRONT_CAMERA est utilisé. Après la liaison, Preview commence à afficher le flux de la caméra dans PreviewView, et l'utilisateur voit l'image de la caméra à l'écran.

Capture d'une photo

val photoFile = File(
    externalMediaDirs.firstOrNull(),
    "IMG_${System.currentTimeMillis()}.jpg"
)
val outputOptions = ImageCapture.OutputFileOptions
    .Builder(photoFile)
    .build()

imageCapture.takePicture(
    outputOptions,
    ContextCompact.getMainExecutor(this),
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(output: ImageCapture.OutputFileResults) {
            Log.d("CameraX", "Photo saved: ${photoFile.absolutePath}")
        }
        override fun onError(exception: ImageCaptureException) {
            Log.e("CameraX", "Erreur de capture", exception)
        }
    }
)

La méthode takePicture capture une image de la caméra et la sauvegarde dans un fichier. OutputFileOptions prend en charge l'écriture dans File, ContentResolver et MediaStore. Dans le callback onImageSaved, l'application reçoit une notification de sauvegarde réussie et peut mettre à jour l'UI. CAPTURE_MODE_MINIMIZE_LATENCY garantit une vitesse d'obturation maximale en réduisant le post-traitement.

Implémentation sur iOS avec AVFoundation

Sur iOS, l'accès à la caméra est fourni par le framework AVFoundation via la classe AVCaptureSession. Le développeur crée une session de capture, ajoute les entrées nécessaires (AVCaptureDeviceInput) et les sorties (AVCapturePhotoOutput, AVCaptureVideoDataOutput) et démarre la session. AVCaptureVideoPreviewLayer est utilisé pour afficher l'aperçu. Voici un exemple de configuration d'une session pour la capture de photos en Swift.

import AVFoundation

let captureSession = AVCaptureSession()
captureSession.sessionPreset = .photo

guard let camera = AVCaptureDevice.default(
    for: .video
) else { return }

guard let input = try? AVCaptureDeviceInput(device: camera)
else { return }

let output = AVCapturePhotoOutput()
captureSession.addInput(input)
captureSession.addOutput(output)

DispatchQueue.global(qos: .userInitiated).async {
    captureSession.startRunning()
}

AVCaptureSessionPreset.photo définit la résolution optimale pour les photos (généralement 12 MP sur les appareils modernes). L'entrée est un AVCaptureDeviceInput créé pour la caméra de l'appareil. Après avoir ajouté l'entrée et la sortie, la session est démarrée sur un thread d'arrière-plan via startRunning — le démarrage de la session peut prendre jusqu'à 200 ms sur les anciens appareils. Pour capturer une photo, capturePhoto(with:delegate:) est appelé, et le résultat est renvoyé via AVCapturePhotoCaptureDelegate.

Fonctionnalités et limitations

Lors du travail avec la caméra sur les appareils mobiles, les limitations matérielles doivent être prises en compte : échauffement de l'appareil lors d'un enregistrement prolongé, consommation de batterie lors du travail en haute résolution et qualité de caméra variable selon les appareils. Sur Android, la fragmentation de l'écosystème fait que la même configuration CameraX peut se comporter différemment sur différents modèles. Sur iOS, les limitations concernent principalement les licences : l'utilisation de la caméra en arrière-plan nécessite une autorisation spéciale d'Apple. Il est également important de se rappeler que les simulateurs n'ont pas accès à une caméra réelle — les tests ne sont possibles que sur un appareil physique.

Compatibilité avec différentes versions de l'OS

CameraX résout le problème de fragmentation d'Android grâce à la couche de compatibilité CameraXConfig — la bibliothèque applique automatiquement des solutions de contournement pour les bogues connus des fabricants. Sur iOS, AVFoundation fonctionne uniformément sur tous les appareils à partir d'iOS 6, mais certaines fonctionnalités (comme le mode Portrait ou LiDAR) ne sont disponibles que sur iPhone 12 et modèles plus récents. Lors du développement d'une application multiplateforme, il est recommandé d'utiliser Flutter ou React Native avec des plugins de caméra — ils abstraient les différences de plateforme et fournissent une API unifiée pour les deux systèmes d'exploitation.