Kamera i mobilutveckling: vad det är, API-typer och hur man använder

Vad är kamera i mobilappar

Mobil kamera — är en inbyggd optisk modul bestående av lins, matris (sensor) och bildbehandlingsprocessor (ISP). Utvecklaren får åtkomst till kameran via operativsystemet med hjälp av speciella ramverk. På Android är det Camera2 API (låg nivå) och CameraX (hög nivå baserad på Camera2), på iOS — AVFoundation och UIKit för enkla scenarier. Varje plattform tillhandahåller sin egen uppsättning verktyg, men det allmänna konceptet är detsamma: appen initierar en inspelningssession, konfigurerar parametrar (upplösning, fokus, exponering) och tar emot en ström av bildrutor eller enskilda bilder.

Hårdvarukapacitet hos moderna kameror

Moderna mobilkameror stöder flera lägen för fotografering: HDR, nattläge, porträtt med bakgrundsoskärpa, slowmotion och inspelning i RAW-format. För utvecklaren finns programvaruinställningar tillgängliga: ISO (matrisens känslighet), exponeringstid, vitbalans, fokus (automatisk och manuell) och bildstabilisering. På flaggskeppsenheter finns upp till 4 kameror med olika brännvidder, och appen kan välja en specifik kamera efter ID.

Typer av API:er för kameraarbete

På mobila plattformar finns flera API:er för kameraarbete som skiljer sig åt i abstraktionsnivå och funktionalitet. Valet av specifikt API beror på projektets krav: för enkel fotofångst räcker CameraX eller UIImagePickerController, för professionella appar behövs Camera2 eller AVFoundation med direkt sensorstyrning. Nedan följer en jämförelse av de viktigaste API:erna.

När välja CameraX

CameraX — optimalt val för de flesta Android-appar som behöver kamera utan djupgående anpassning. Biblioteket hanterar automatiskt livscykeln för Activity och Fragment, stöder behörigheter och kompatibilitet med olika Android-versioner. CameraX garanterar samma beteende på 95% av Android-enheter tack vare kompatibilitetslagret. Om kameraförhandsvisning (Preview), fotofångst (ImageCapture) eller strömanalys (ImageAnalysis) behövs — klarar CameraX alla tre scenarier utan att skriva komplex kod.

När välja Camera2

Camera2 — lågnivå-API för professionella scenarier: RAW-inspelning, manuell exponeringsinställning, burst-fotografering, samtidig styrning av flera kameror. Camera2 kräver av utvecklaren djup förståelse av bildfångstpipelinen, StateMachine-hantering och callback-bearbetning. Använd Camera2 endast om CameraX inte täcker kraven: till exempel för dokumentskanningsappar med manuell fokusering eller anpassade kameror med icke-standard upplösning.

Begära behörigheter för kameratillgång

Åtkomst till kameran kräver uttryckligt användarsamtycke på båda plattformarna. På Android läggs CAMERA-behörigheten till i manifestet, och från Android 6.0 måste behörigheten även begäras under körning via ActivityCompat.requestPermissions. På iOS läggs nyckeln NSCameraUsageDescription till i Info.plist med en beskrivning av anledningen till kameranvändning. Utan denna beskrivning kommer appen att krascha vid försök att komma åt kameran. Från iOS 14 visas i behörighetsdialogrutan inte bara appens namn utan även den angivna anledningen — formuleringen bör vara begriplig för användaren.

Implementering på Android med CameraX

CameraX förenklar kameraarbetet till några rader kod. För att starta förhandsvisningen måste en Preview-instans skapas, kopplas till LifecycleOwner och en SurfaceProvider erhållas för visning. För fotofångst används ImageCapture med ett sparmål. Nedan följer ett komplett exempel på att starta kameran och ta foton med CameraX i Kotlin.

Konfiguration av Preview och 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", "Bindning misslyckades", e)
    }
}, ContextCompact.getMainExecutor(this))

Metoden bindToLifecycle kopplar kameran till Activitys livscykel — vid skärmrotation eller övergång till bakgrunden frigörs kameran automatiskt. CameraSelector.DEFAULT_BACK_CAMERA väljer den bakre kameran, för den främre används DEFAULT_FRONT_CAMERA. Efter kopplingen börjar Preview visa bilden från kameran i PreviewView och användaren ser kamerabilden på skärmen.

Fotofångst

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

Metoden takePicture utför infångning av en bildruta från kameran och sparar den i en fil. OutputFileOptions stöder sparande till File, ContentResolver och MediaStore. I callbacken onImageSaved får appen ett meddelande om lyckad sparring och kan uppdatera UI. CAPTURE_MODE_MINIMIZE_LATENCY säkerställer maximal slutartid genom minskad efterbehandling.

Implementering på iOS med AVFoundation

På iOS tillhandahålls åtkomst till kameran av ramverket AVFoundation genom klassen AVCaptureSession. Utvecklaren skapar en inspelningssession, lägger till nödvändiga ingångar (AVCaptureDeviceInput) och utgångar (AVCapturePhotoOutput, AVCaptureVideoDataOutput) och startar sessionen. För visning av förhandsvisning används AVCaptureVideoPreviewLayer. Nedan följer ett exempel på konfiguration av en session för fotofångst i 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 ställer in den optimala upplösningen för foto (vanligtvis 12 MP på moderna enheter). Ingången är AVCaptureDeviceInput skapad för enhetens kamera. Efter att ingång och utgång lagts till startas sessionen i en bakgrundstråd via startRunning — sessionens start kan ta upp till 200 ms på äldre enheter. För fotofångst anropas capturePhoto(with:delegate:) och resultatet returneras via delegaten AVCapturePhotoCaptureDelegate.

Funktioner och begränsningar

Vid arbete med kameran på mobila enheter måste hårdvarubegränsningar beaktas: enhetens uppvärmning vid lång fotografering, batteriurladdning vid arbete med hög upplösning och varierande kamera kvalitet på olika enheter. På Android leder ekosystemets fragmentering till att samma CameraX-konfiguration kan fungera olika på olika modeller. På iOS gäller begränsningarna främst licensiering: användning av kameran i bakgrunden kräver särskilt tillstånd från Apple. Det är också viktigt att komma ihåg att simulatorer inte har tillgång till en riktig kamera — testning är endast möjlig på en fysisk enhet.

Kompatibilitet med olika operativsystemversioner

CameraX löser problemet med Android-fragmentering genom kompatibilitetslagret CameraXConfig — biblioteket tillämpar automatiskt workarounds för kända tillverkarfel. På iOS fungerar AVFoundation enhetligt på alla enheter från iOS 6, men vissa funktioner (t.ex. Portrait Mode eller LiDAR) är endast tillgängliga på iPhone 12-modeller och nyare. Vid utveckling av en plattformsoberoende app rekommenderas att använda Flutter eller React Native med kameraplugin — de abstraherar plattformsskillnader och tillhandahåller ett enhetligt API för båda operativsystemen.