Wie SmileID die Identitätsüberprüfung mit CameraX auf mehr als 18.000 Android-Gerätetypen ausgeweitet hat

Apps zur Identitätsbestätigung für Bankgeschäfte und die SIM-Registrierung erfordern klare, hochauflösende Gesichtsaufnahmen, um Spoofing und Deepfakes zu erkennen. Für Android-Kameraentwickler ist es oft eine Herausforderung, Frames aufzunehmen, die scharf genug für Lebendigkeits- und Anti-Spoofing-Prüfungen sind, ohne dass Geräte mit wenig Arbeitsspeicher abstürzen.

Für SmileID, ein führendes SDK zur Identitätsbestätigung in Afrika, wird diese Herausforderung durch ein vielfältiges Hardware-Ökosystem noch verstärkt. Android macht 85 % des Marktanteils der Zielgeräte von SmileID aus, darunter Einsteiger-Smartphones mit stark eingeschränkten Prozessoren, unbekannte regionale Modelle und robuste, benutzerdefinierte Kassenterminals.

Vor der Einführung von CameraX stand SmileID vor den üblichen, aber entmutigenden Herausforderungen der Kameratechnik: verzerrte Vorschau-Feeds, gedrehte Sensorausrichtungen, Abstürze aufgrund von Speichermangel und benutzerdefinierte OEM-Fehler. Durch die Migration der wichtigsten Android-SDKs zu CameraX konnte SmileID diese Herausforderungen in einen großen Geschäftsvorteil verwandeln.

Laut SmileID hat die Migration der Android SDKs zu CameraX die folgenden Ergebnisse geliefert:

Die Herausforderung: Fragmentierte Hardware und Probleme mit Legacy-APIs

Um zu bestätigen, dass ein Nutzer der ist, für den er sich ausgibt, muss das SDK von SmileID hochauflösende Selfie-Frames für die Lebendigkeitsprüfung auf dem Gerät und die cloudbasierte Deepfake-Erkennung erfassen. 

Bei der Implementierung der alten Camera1 und der Low-Level-Camera2 API war es aus mehreren Gründen schwierig, dies konsistent zu erreichen: 

• OEM-Anpassungen und ‑Besonderheiten: Geräte verschiedener Hersteller meldeten die physische Ausrichtung des Kamerasensors unterschiedlich, was zu gedrehten Vorschauen oder falsch ausgerichteten Gesichtserfassungen führte.
• Verzerrungen des Seitenverhältnisses: Wenn auf günstigen Geräten eine bestimmte Framegröße angefordert wurde, wurde die Kameravorschau oft vertikal oder horizontal gestreckt. Dadurch wurde das Gesicht des Nutzers verzerrt und die biometrische Bestätigung unbrauchbar.
• Abstürze aufgrund von Speichermangel (Out-of-Memory, OOM): Die Verarbeitung von hochauflösenden Rohbildern auf Geräten mit wenig RAM (oft 1 GB oder weniger) führte häufig zu schwerwiegenden Abstürzen bei der Arbeitsspeicherzuweisung.

Aufgrund dieser Reibungspunkte war das Wachstum der SDK-Einführung von SmileID im Jahresvergleich auf das Zwei- bis Dreifache begrenzt. Viele Überprüfungen mussten auf das Hochladen statischer Fotos über eine REST API mit hoher Latenz zurückgreifen, anstatt Echtzeit-Lebendigkeitsprüfungen auf dem Gerät auszuführen.

Die Lösung: Konsistente Pipelines mit CameraX 

SmileID hat seine mobilen SDKs von Grund auf neu entwickelt und dabei CameraX verwendet. CameraX wurde speziell entwickelt, um die Komplexität des zugrunde liegenden Geräte-Ökosystems zu abstrahieren und eine konsistente, native, lebenszyklusbewusste Entwicklerschnittstelle bereitzustellen.

Mithilfe der wichtigsten Anwendungsfälle von CameraX (insbesondere Preview und ImageAnalysis) hat SmileID eine robuste, zweigleisige Kamera-Pipeline entwickelt:

• Vorschau: Rendert eine perfekt proportionierte Echtzeitvorschau des Kamerafeeds, um den Nutzer zu unterstützen.
• ImageAnalysis: Verarbeitet Frames kontinuierlich lokal in Echtzeit, um eine automatisierte Lebendigkeits- und Gesichtserkennung durchzuführen und den verifizierten Selfie-Frame zu extrahieren.

Um gestochen scharfe Details für die Deepfake-Erkennung zu erfassen, ohne dass es zu OOM-Abstürzen kommt, hat SmileID die moderne ResolutionSelector API von CameraX direkt in die ImageAnalysis-Konfiguration eingebunden. Entwickler können damit eine Zielauflösung anfordern und eine Fallback-Regel auswählen, wenn ein Gerät diese genaue Größe nicht unterstützt. Das folgende Diagramm und die Beispielkonfiguration zeigen, wie ResolutionSelector Kandidatengrößen um ein Ziel von 1200 × 900 bewertet:

Hier ist der entsprechende Beispielcode, der zeigt, wie Sie ResolutionSelector mit STRATEGY_KEEP_ONLY_LATEST in Ihrer eigenen App koppeln können. Verwenden Sie FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER, um die Schärfe zu priorisieren, oder FALLBACK_RULE_CLOSEST_LOWER_THEN_HIGHER, um die Speichernutzung zu begrenzen:

import android.util.Size
import androidx.camera.core.CameraSelector
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.Preview
import androidx.camera.core.resolutionselector.AspectRatioStrategy
import androidx.camera.core.resolutionselector.ResolutionSelector
import androidx.camera.core.resolutionselector.ResolutionStrategy
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.lifecycle.LifecycleOwner

fun configureCameraX(cameraProvider: ProcessCameraProvider, lifecycleOwner: LifecycleOwner, 
                     surfaceProvider: Preview.SurfaceProvider, 
                     executor: java.util.concurrent.Executor, analyzer: ImageAnalysis.Analyzer) {
    // 1. Define a resolution strategy requesting high quality (for example, 1200x900px) 
    // and selecting the closest higher (or, if unavailable, lower) resolution.
    val resolutionSelector = ResolutionSelector.Builder()
        .setResolutionStrategy(
            ResolutionStrategy(
                Size(1200, 900),
                ResolutionStrategy.FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER
            )
        )
        .setAspectRatioStrategy(AspectRatioStrategy.RATIO_4_3_FALLBACK_AUTO_STRATEGY)
        .build()

    // 2. Configure the ImageAnalysis use case with the resolution selector
    // and a backpressure strategy that keeps the UI responsive on slow processors.
    val imageAnalysis = ImageAnalysis.Builder()
        .setResolutionSelector(resolutionSelector)        
        // Drops older frames if the device's CPU is still busy analyzing the previous one
        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
        .build()

    // 3. Set up the preview stream and attach the Analyzer and SurfaceProvider
    imageAnalysis.setAnalyzer(executor, analyzer)
    val preview = Preview.Builder().build().also { it.surfaceProvider = surfaceProvider }

    // 4. Bind both use cases concurrently to the lifecycle provider
    try {
        cameraProvider.unbindAll()
        cameraProvider.bindToLifecycle(
            lifecycleOwner,
            CameraSelector.DEFAULT_FRONT_CAMERA,
            preview,
            imageAnalysis
        )
    } catch (exc: Exception) {
        // Handle binding failure safely
    }
}

Durch das Anfordern von Pixel-Frames mit hoher Dichte und die lokale Verarbeitung konnte SmileID die Auflösung der aufgenommenen Selfies um das Vierfache erhöhen. SmileID komprimierte auch den zugeschnittenen Gesichtsbereich auf dem Gerät, sodass die Uploadgröße im Netzwerk mit der des vorherigen Systems identisch blieb. Diese Architektur sorgte für präzisere Daten für die Machine-Learning-Modelle, ohne dass die Kosten für die mobile Datennutzung der Nutzer stiegen.

How CameraX Solves Hardware Differences

Durch die Standardisierung auf CameraX konnte SmileID zwei Ebenen der Kompatibilitätstechnik nutzen, um das SDK auf allen Geräten stabil zu halten:

1. Google Camera and Media Test Lab

Die Kompatibilität von CameraX wird durch kontinuierliche, physische Hardwareprüfungen sichergestellt. Im Camera and Media Test Lab von Google wird täglich eine automatisierte Test-Suite auf einer riesigen, rotierenden Matrix von über 190 physischen Android-Gerätemodellen ausgeführt. Dazu gehören Geräte mit unterschiedlichen Chipsätzen, Betriebssystemversionen und Hardwarefunktionen. 

Um ein einheitlicheres Verhalten auf gängigen Geräten zu erreichen, werden im Camera and Media Test Lab von Google automatisch Regressionen in Bibliotheken erkannt, bevor sie sich auf Ihren Produktionscode auswirken können.

2. Automatische Problemumgehungen für Gerätebesonderheiten

Verschiedene Android-Geräte haben unterschiedliche physische Einschränkungen. Bei einigen kann es vorkommen, dass benutzerdefinierte Belichtungseinstellungen nicht festgelegt werden können, während bei anderen bei bestimmten Seitenverhältnissen invertierte Bilddaten gemeldet werden. Damit Entwickler ihre Codebasen nicht mit komplexen bedingten Blöcken basierend auf Gerätehersteller und ‑modell überladen, verwaltet CameraX interne Geräte-Quirk-Klassen wie DeviceQuirks und CameraQuirks in camera-camera2 (DeviceQuirksLoader.kt). Wenn CameraX ein Gerät mit einem bekannten Problem erkennt, wird automatisch ein maßgeschneiderter Workaround eingefügt. Für SmileID bedeutete dies, dass das SDK auf mehr als 18.000 Android-Gerätetypen zuverlässig funktionieren konnte,ohne dass gerätespezifische Patches in der Codebasis erforderlich waren.

Skalierung auf über 160 Millionen Verifizierungen

Durch die Migration zu CameraX konnte SmileID die SDK-Integration für externe App-Entwickler vereinfachen. 

Durch die Beseitigung von Verzerrungen des Seitenverhältnisses, verzögerten Vorschauen und plötzlichen Abstürzen aufgrund von Speichermangel konnte die Erfolgsquote bei der Überprüfung um 20 % gesteigert werden. Für Finanzinstitute und mobile Geld-Apps in ganz Afrika bedeutet eine Steigerung der Erfolgsquote um 20 %, dass Hunderttausende legitime Nutzer erfolgreich registriert werden, anstatt abzuwandern.

Das ist auch Entwicklern aufgefallen. Die einfache Integration des CameraX-basierten SDK führte im ersten Jahr zu einem 15-fachen Anstieg der Akzeptanz, der im zweiten Jahr auf das 20-fache anstieg. Bisher hat SmileID mit CameraX über 160 Millionen Identitätsüberprüfungen erfolgreich durchgeführt.

Kompatibilität mit dem CameraX-Skill verbessern

Die Entwicklung für Kameras muss nicht schwierig sein. Damit Ihr Team dieselben CameraX-Muster wie SmileID verwenden kann, hat Android den CameraX-Skill für KI-Coding-Agenten eingeführt. 

Wenn Sie den CameraX-Skill in Ihrer Entwicklungsumgebung verwenden, wenden KI-Coding-Agenten wie Gemini aktuelle CameraX-Muster für die Migration, die Lebenszyklusbindung, ConcurrentCamera und MlKitAnalyzer an. Egal, ob Sie Dual-Kamera-Feeds einrichten, eine Vorschau mit PreviewView oder CameraXViewfinder konfigurieren oder Echtzeitanalysen mit maschinellem Lernen (ML) verwalten – der CameraX-Skill führt Ihren Agenten dazu, präzisen, produktionsreifen Code zu generieren.

• CameraX-Skill entdecken: Rufen Sie das Android Developer Skills Directory auf oder führen Sie android skills add camerax mit der Android-Befehlszeile aus, um den Skill Ihrem KI-Coding-Tool hinzuzufügen.
• Erste Schritte mit CameraX: In der offiziellen CameraX-Dokumentation erfährst du, wie du deine Kamerafunktionen überall nutzen kannst.