Camera in mobiele ontwikkeling: wat het is, API-typen en hoe te gebruiken

Wat is een camera in mobiele apps

Mobiele camera — is een ingebouwde optische module bestaande uit een lens, matrix (sensor) en beeldverwerkingsprocessor (ISP). De ontwikkelaar krijgt toegang tot de camera via het besturingssysteem met behulp van speciale frameworks. Op Android zijn dit Camera2 API (laag niveau) en CameraX (hoog niveau gebaseerd op Camera2), op iOS — AVFoundation en UIKit voor eenvoudige scenario's. Elk platform biedt zijn eigen set tools, maar het algemene concept is hetzelfde: de app initialiseert een vastlegsessie, configureert parameters (resolutie, focus, belichting) en ontvangt een stroom frames of afzonderlijke afbeeldingen.

Hardwaremogelijkheden van moderne camera's

Moderne mobiele camera's ondersteunen meerdere modi voor fotograferen: HDR, nachtmodus, portret met vervaging van de achtergrond, slow motion en opname in RAW-formaat. Voor de ontwikkelaar zijn softwarematige instellingen beschikbaar: ISO (gevoeligheid van de matrix), sluitertijd (belichting), witbalans, focus (automatisch en handmatig) en beeldstabilisatie. Op flagship-apparaten zijn tot 4 camera's met verschillende brandpuntsafstanden beschikbaar, en de app kan een specifieke camera selecteren op ID.

Soorten API's voor werken met de camera

Op mobiele platforms zijn er verschillende API's voor het werken met de camera, die verschillen in abstractieniveau en functionaliteit. De keuze van een specifieke API hangt af van de projectvereisten: voor eenvoudige fotocaptuur is CameraX of UIImagePickerController voldoende, voor professionele apps is Camera2 of AVFoundation met directe sensorbediening nodig. Hieronder vindt u een vergelijking van de belangrijkste API's.

Wanneer CameraX kiezen

CameraX — de optimale keuze voor de meeste Android-apps die een camera nodig hebben zonder diepgaande aanpassing. De bibliotheek beheert automatisch de levenscyclus van Activity en Fragment, ondersteunt rechten en compatibiliteit met verschillende Android-versies. CameraX garandeert hetzelfde gedrag op 95% van de Android-apparaten dankzij de compatibiliteitslaag. Als cameravoorbeeld (Preview), fotocaptuur (ImageCapture) of streamanalyse (ImageAnalysis) nodig is — CameraX kan alle drie de scenario's aan zonder complexe code te schrijven.

Wanneer Camera2 kiezen

Camera2 — een laag-niveau API voor professionele scenario's: opname in RAW, handmatige belichtingsinstelling, burst-fotografie, gelijktijdig beheer van meerdere camera's. Camera2 vereist van de ontwikkelaar een diepgaand begrip van de beeldvastlegpijplijn, StateMachine-beheer en callback-verwerking. Gebruik Camera2 alleen als CameraX niet aan de vereisten voldoet: bijvoorbeeld voor apps voor documentscannen met handmatige scherpstelling of aangepaste camera's met niet-standaard resolutie.

Aanvragen van cameratoegangsrechten

Toegang tot de camera vereist expliciete toestemming van de gebruiker op beide platforms. Op Android wordt de CAMERA-machtiging aan het manifest toegevoegd en vanaf Android 6.0 moet de machtiging ook tijdens runtime worden aangevraagd via ActivityCompat.requestPermissions. Op iOS wordt de sleutel NSCameraUsageDescription met een beschrijving van de reden voor cameragebruik aan Info.plist toegevoegd. Zonder deze beschrijving zal de app crashen bij een poging tot cameratoegang. Vanaf iOS 14 wordt in het machtigingsdialoogvenster niet alleen de app-naam weergegeven, maar ook de opgegeven reden — de formulering moet begrijpelijk zijn voor de gebruiker.

Implementatie op Android met CameraX

CameraX vereenvoudigt het werken met de camera tot een paar regels code. Om een voorbeeld te starten, moet u een Preview-instantie maken, deze aan LifecycleOwner koppelen en een SurfaceProvider voor weergave verkrijgen. Voor het vastleggen van foto's wordt ImageCapture gebruikt met een opslagdoel. Hieronder vindt u een volledig voorbeeld van het starten van de camera en het maken van foto's met CameraX in Kotlin.

Configuratie van Preview en 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", "Bindingsfout", e)
    }
}, ContextCompact.getMainExecutor(this))

De methode bindToLifecycle koppelt de camera aan de levenscyclus van Activity — bij schermrotatie of overgang naar de achtergrond wordt de camera automatisch vrijgegeven. CameraSelector.DEFAULT_BACK_CAMERA selecteert de achtercamera, voor de voorkant wordt DEFAULT_FRONT_CAMERA gebruikt. Na het koppelen begint Preview met het weergeven van het camerabeeld in PreviewView en ziet de gebruiker het camerabeeld op het scherm.

Fotocaptuur

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", "Vastlegfout", exception)
        }
    }
)

De methode takePicture legt een frame van de camera vast en slaat het op in een bestand. OutputFileOptions ondersteunt opslag naar File, ContentResolver en MediaStore. In de onImageSaved-callback ontvangt de app een melding van succesvolle opslag en kan de UI worden bijgewerkt. CAPTURE_MODE_MINIMIZE_LATENCY zorgt voor maximale sluitersnelheid door vermindering van nabewerking.

Implementatie op iOS met AVFoundation

Op iOS biedt het framework AVFoundation toegang tot de camera via de klasse AVCaptureSession. De ontwikkelaar maakt een vastlegsessie, voegt de benodigde inputs (AVCaptureDeviceInput) en outputs (AVCapturePhotoOutput, AVCaptureVideoDataOutput) toe en start de sessie. Voor weergave van het voorbeeld wordt AVCaptureVideoPreviewLayer gebruikt. Hieronder vindt u een voorbeeld van het configureren van een sessie voor fotocaptuur in 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 stelt de optimale resolutie voor foto's in (meestal 12 MP op moderne apparaten). De input is AVCaptureDeviceInput gemaakt voor de camera van het apparaat. Na het toevoegen van input en output wordt de sessie gestart in een achtergrondthread via startRunning — het starten van de sessie kan tot 200 ms duren op oudere apparaten. Voor het vastleggen van een foto wordt capturePhoto(with:delegate:) aangeroepen en het resultaat wordt geretourneerd via de delegate AVCapturePhotoCaptureDelegate.

Kenmerken en beperkingen

Bij het werken met de camera op mobiele apparaten moet rekening worden gehouden met hardwarebeperkingen: oververhitting van het apparaat bij langdurig fotograferen, leeglopen van de batterij bij werken met hoge resolutie en verschillende camerakwaliteit op verschillende apparaten. Op Android leidt fragmentatie van het ecosysteem ertoe dat dezelfde CameraX-configuratie anders kan werken op verschillende modellen. Op iOS hebben beperkingen vooral betrekking op licenties: voor cameragebruik op de achtergrond is aparte toestemming van Apple vereist. Het is ook belangrijk om te onthouden dat simulatoren geen toegang hebben tot een echte camera — testen is alleen mogelijk op een fysiek apparaat.

Compatibiliteit met verschillende OS-versies

CameraX lost het fragmentatieprobleem van Android op via de compatibiliteitslaag CameraXConfig — de bibliotheek past automatisch workarounds toe voor bekende bugs van fabrikanten. Op iOS werkt AVFoundation uniform op alle apparaten vanaf iOS 6, maar sommige functies (zoals Portrait Mode of LiDAR) zijn alleen beschikbaar op iPhone 12-modellen en nieuwer. Bij de ontwikkeling van een cross-platform app wordt aanbevolen Flutter of React Native te gebruiken met camera-plugins — ze abstraheren platformverschillen en bieden een uniforme API voor beide besturingssystemen.