Kamera in der mobilen Entwicklung: Was es ist, API-Typen und Verwendung

Was ist eine Kamera in mobilen Anwendungen

Eine mobile Kamera ist ein integriertes optisches Modul, bestehend aus einem Objektiv, einem Bildsensor und einem Bildsignalprozessor (ISP). Der Entwickler greift über das Betriebssystem mit speziellen Frameworks auf die Kamera zu. Auf Android sind dies Camera2 API (niedrige Ebene) und CameraX (hohe Ebene, basierend auf Camera2), auf iOS — AVFoundation und UIKit für einfache Szenarien. Jede Plattform bietet ihr eigenes Toolkit, aber das Grundkonzept ist dasselbe: Die Anwendung initialisiert eine Aufnahmesitzung, konfiguriert Parameter (Auflösung, Fokus, Belichtung) und empfängt einen Bildstrom oder einzelne Bilder.

Hardware-Fähigkeiten moderner Kameras

Moderne Mobilkameras unterstützen viele Aufnahmemodi: HDR, Nachtmodus, Porträt mit Hintergrundunschärfe, Zeitlupenvideo und Aufnahme im RAW-Format. Der Entwickler hat Zugriff auf Softwareeinstellungen: ISO (Sensorempfindlichkeit), Verschlusszeit (Belichtung), Weißabgleich, Fokus (automatisch und manuell) und Bildstabilisierung. Flaggschiff-Geräte können bis zu 4 Kameras mit unterschiedlichen Brennweiten haben, und die Anwendung kann eine bestimmte Kamera nach ID auswählen.

Arten von APIs für die Kameraarbeit

Mobile Plattformen bieten mehrere APIs für die Kameraarbeit, die sich im Abstraktionsgrad und Funktionsumfang unterscheiden. Die Wahl einer bestimmten API hängt von den Projektanforderungen ab: Für einfache Fotoaufnahmen reichen CameraX oder UIImagePickerController; für professionelle Anwendungen ist Camera2 oder AVFoundation mit direkter Sensorsteuerung erforderlich. Nachfolgend ein Vergleich der wichtigsten APIs.

Wann CameraX wählen

CameraX ist die optimale Wahl für die meisten Android-Anwendungen, die eine Kamera ohne tiefgehende Anpassung benötigen. Die Bibliothek verwaltet automatisch den Activity- und Fragment-Lebenszyklus, unterstützt Berechtigungen und gewährleistet Kompatibilität zwischen verschiedenen Android-Versionen. CameraX garantiert dank seiner Kompatibilitätsschicht ein konsistentes Verhalten auf 95 % der Android-Geräte. Wenn Sie eine Kameravorschau (Preview), Fotoaufnahme (ImageCapture) oder Bildanalyse (ImageAnalysis) benötigen — CameraX bewältigt alle drei Szenarien ohne komplexen Code.

Wann Camera2 wählen

Camera2 ist eine niedrigschwellige API für professionelle Szenarien: RAW-Aufnahme, manuelle Belichtungseinstellung, Burst-Aufnahme und gleichzeitige Steuerung mehrerer Kameras. Camera2 erfordert vom Entwickler ein tiefes Verständnis der Bildaufnahme-Pipeline, des StateMachine-Managements und der Callback-Behandlung. Verwenden Sie Camera2 nur, wenn CameraX die Anforderungen nicht abdeckt: beispielsweise Dokumentenscan-Anwendungen mit manuellem Fokus oder benutzerdefinierte Kameras mit nicht standardmäßiger Auflösung.

Anfordern von Kameraberechtigungen

Der Zugriff auf die Kamera erfordert auf beiden Plattformen die ausdrückliche Zustimmung des Benutzers. Auf Android wird die CAMERA-Berechtigung im Manifest hinzugefügt, und ab Android 6.0 muss die Berechtigung auch zur Laufzeit über ActivityCompat.requestPermissions angefordert werden. Auf iOS wird der Schlüssel NSCameraUsageDescription mit einer Beschreibung des Verwendungszwecks der Kamera in Info.plist hinzugefügt. Ohne diese Beschreibung stürzt die Anwendung beim Versuch, auf die Kamera zuzugreifen, ab. Ab iOS 14 zeigt der Berechtigungsdialog nicht nur den Namen der Anwendung, sondern auch den angegebenen Grund an — die Formulierung muss für den Benutzer klar sein.

Implementierung auf Android mit CameraX

CameraX vereinfacht die Arbeit mit der Kamera auf nur wenige Codezeilen. Zum Starten einer Vorschau müssen Sie eine Preview-Instanz erstellen, sie an einen LifecycleOwner binden und einen SurfaceProvider für die Anzeige erhalten. Für die Fotoaufnahme wird ImageCapture mit einem Speicherziel verwendet. Nachfolgend ein vollständiges Beispiel zum Starten der Kamera und Aufnehmen eines Fotos mit CameraX in Kotlin.

Einrichten von Preview und 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", "Bindung fehlgeschlagen", e)
    }
}, ContextCompact.getMainExecutor(this))

Die Methode bindToLifecycle bindet die Kamera an den Lebenszyklus der Activity — bei Bildschirmdrehung oder Wechsel in den Hintergrund wird die Kamera automatisch freigegeben. CameraSelector.DEFAULT_BACK_CAMERA wählt die Rückkamera; für die Frontkamera wird DEFAULT_FRONT_CAMERA verwendet. Nach der Bindung beginnt Preview mit der Anzeige des Kamerafeeds im PreviewView, und der Benutzer sieht das Kamerabild auf dem Bildschirm.

Ein Foto aufnehmen

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

Die Methode takePicture nimmt ein Bild von der Kamera auf und speichert es in einer Datei. OutputFileOptions unterstützt das Schreiben in File, ContentResolver und MediaStore. Im onImageSaved-Callback erhält die Anwendung eine Benachrichtigung über erfolgreiches Speichern und kann die UI aktualisieren. CAPTURE_MODE_MINIMIZE_LATENCY sorgt durch Reduzierung der Nachbearbeitung für maximale Verschlussgeschwindigkeit.

Implementierung auf iOS mit AVFoundation

Auf iOS wird der Zugriff auf die Kamera durch das AVFoundation-Framework über die Klasse AVCaptureSession bereitgestellt. Der Entwickler erstellt eine Aufnahmesitzung, fügt die erforderlichen Eingänge (AVCaptureDeviceInput) und Ausgänge (AVCapturePhotoOutput, AVCaptureVideoDataOutput) hinzu und startet die Sitzung. Für die Vorschauanzeige wird AVCaptureVideoPreviewLayer verwendet. Nachfolgend ein Beispiel für die Einrichtung einer Sitzung zur Fotoaufnahme 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 stellt die optimale Auflösung für Fotos ein (normalerweise 12 MP auf modernen Geräten). Der Eingang ist ein für die Kamera des Geräts erstellter AVCaptureDeviceInput. Nach dem Hinzufügen von Eingang und Ausgang wird die Sitzung über startRunning in einem Hintergrundthread gestartet — das Starten der Sitzung kann auf älteren Geräten bis zu 200 ms dauern. Zum Aufnehmen eines Fotos wird capturePhoto(with:delegate:) aufgerufen, und das Ergebnis wird über AVCapturePhotoCaptureDelegate zurückgegeben.

Funktionen und Einschränkungen

Bei der Arbeit mit der Kamera auf mobilen Geräten müssen Hardware-Einschränkungen berücksichtigt werden: Erwärmung des Geräts bei längerer Aufnahme, Batterieverbrauch bei hoher Auflösung und unterschiedliche Kameraqualität bei verschiedenen Geräten. Auf Android führt die Fragmentierung des Ökosystems dazu, dass dieselbe CameraX-Konfiguration auf verschiedenen Modellen unterschiedlich funktionieren kann. Auf iOS betreffen die Einschränkungen hauptsächlich die Lizenzierung: Die Verwendung der Kamera im Hintergrund erfordert eine spezielle Genehmigung von Apple. Es ist auch wichtig zu bedenken, dass Simulatoren keinen Zugriff auf eine echte Kamera haben — Tests sind nur auf einem physischen Gerät möglich.

Kompatibilität mit verschiedenen OS-Versionen

CameraX löst das Fragmentierungsproblem von Android durch die Kompatibilitätsschicht CameraXConfig — die Bibliothek wendet automatisch Workarounds für bekannte Herstellerfehler an. Auf iOS funktioniert AVFoundation auf allen Geräten ab iOS 6 einheitlich, aber einige Funktionen (wie Porträtmodus oder LiDAR) sind nur auf iPhone 12 und neueren Modellen verfügbar. Bei der Entwicklung einer plattformübergreifenden Anwendung wird die Verwendung von Flutter oder React Native mit Kamera-Plugins empfohlen — sie abstrahieren Plattformunterschiede und bieten eine einheitliche API für beide Betriebssysteme.