Cara SmileID Menskalakan Verifikasi Identitas ke Lebih dari 18.000 Jenis Perangkat Android dengan CameraX

Aplikasi verifikasi identitas untuk perbankan dan pendaftaran SIM memerlukan pengambilan gambar wajah yang jelas dan beresolusi tinggi untuk mendeteksi spoofing dan deepfake. Mengambil frame yang cukup tajam untuk pemeriksaan keaktifan dan anti-spoofing, tanpa membuat perangkat dengan memori rendah error, adalah tantangan umum bagi developer kamera Android.

Bagi SmileID, SDK verifikasi identitas terkemuka di Afrika, tantangan ini menjadi dua kali lipat karena ekosistem hardware yang beragam. Android mewakili 85% pangsa pasar perangkat target SmileID, termasuk smartphone entry-level dengan prosesor yang sangat terbatas, model regional yang tidak jelas, dan terminal Point of Sale (POS) kustom yang tangguh.

Sebelum menggunakan CameraX, SmileID menghadapi rintangan rekayasa kamera standar, tetapi berat: feed pratinjau yang melebar, orientasi sensor yang diputar, error kehabisan memori (OOM), dan bug produsen peralatan asli (OEM) kustom. Dengan memigrasikan Android SDK intinya ke CameraX, SmileID mengubah tantangan ini menjadi keunggulan bisnis yang besar.

Menurut SmileID, memigrasikan Android SDK mereka ke CameraX memberikan hasil berikut:

Tantangan: Masalah Hardware yang Terfragmentasi & API Lama

Untuk mengonfirmasi bahwa pengguna adalah orang yang mereka klaim, SDK SmileID harus mengambil frame selfie beresolusi tinggi untuk pemeriksaan keaktifan di perangkat dan deteksi deepfake berbasis cloud. 

Dalam Camera1 lama dan implementasi API Camera2 level rendah, mencapai hal ini secara konsisten sulit dilakukan karena beberapa alasan: 

• Penyesuaian & Keunikan OEM: Perangkat dari produsen yang berbeda melaporkan orientasi sensor kamera fisik secara berbeda, sehingga menghasilkan pratinjau yang diputar atau pengambilan wajah dengan orientasi yang salah.
• Distorsi Rasio Aspek: Meminta ukuran frame tertentu pada perangkat murah sering kali menyebabkan pratinjau kamera meregang secara vertikal atau horizontal, sehingga mendistorsi wajah pengguna dan membuat verifikasi biometrik tidak berguna.
• Error Kehabisan Memori (OOM): Memproses gambar mentah beresolusi tinggi di perangkat dengan RAM rendah (sering kali 1 GB atau kurang) sering kali menyebabkan error alokasi memori yang fatal.

Karena titik hambatan ini, pertumbuhan adopsi SDK SmileID dari tahun ke tahun terbatas pada 2-3x, dan banyak verifikasi harus kembali mengupload foto statis melalui REST API latensi tinggi, bukan menjalankan pemeriksaan keaktifan di perangkat secara real-time.

Solusi: Pipeline yang Konsisten dengan CameraX 

SmileID merekayasa ulang Mobile SDK mereka dari awal menggunakan CameraX, yang dibuat khusus untuk mengabstraksi kompleksitas ekosistem perangkat yang mendasarinya dan menyediakan antarmuka developer yang konsisten dan berbasis siklus proses native.

Dengan menggunakan kasus penggunaan inti CameraX (khususnya Preview dan ImageAnalysis), SmileID membangun pipeline kamera ganda yang andal:

• Pratinjau: Merender pratinjau feed kamera real-time dengan proporsi sempurna untuk memandu pengguna.
• ImageAnalysis: Terus memproses frame secara lokal dan real-time untuk menjalankan deteksi liveness dan wajah dalam frame otomatis serta mengekstrak frame selfie yang diverifikasi.

Untuk menangkap detail yang sangat tajam untuk deteksi deepfake tanpa menyebabkan error OOM, SmileID menambahkan API ResolutionSelector modern CameraX langsung ke konfigurasi ImageAnalysis mereka. Dengan begitu, developer dapat meminta resolusi target dan memilih aturan penggantian jika perangkat tidak mendukung ukuran yang tepat. Misalnya, diagram dan contoh konfigurasi berikut mengilustrasikan cara ResolutionSelector mengevaluasi ukuran kandidat di sekitar target 1200x900:

Berikut adalah kode contoh terkait yang menunjukkan cara menyambungkan ResolutionSelector dengan STRATEGY_KEEP_ONLY_LATEST di aplikasi Anda sendiri (gunakan FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER untuk memprioritaskan ketajaman, atau FALLBACK_RULE_CLOSEST_LOWER_THEN_HIGHER untuk membatasi penggunaan memori):

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
    }
}

Dengan meminta frame piksel kepadatan tinggi dan memprosesnya secara lokal, SmileID mencapai peningkatan 4x lipat dalam resolusi selfie yang diambil. SmileID juga mengompresi area wajah yang dipangkas di perangkat sehingga ukuran upload jaringan tetap sama dengan sistem sebelumnya. Arsitektur ini menjamin data yang lebih tajam untuk model machine learning mereka tanpa meningkatkan biaya data seluler bagi pengguna.

Cara CameraX Mengatasi Perbedaan Hardware

Standardisasi pada CameraX berarti SmileID dapat mengandalkan dua lapisan rekayasa kompatibilitas untuk menjaga SDK-nya tetap stabil di berbagai perangkat:

1. Lab Pengujian Kamera dan Media Google

Kompatibilitas CameraX didukung oleh verifikasi hardware fisik yang berkelanjutan. Di Lab Pengujian Kamera dan Media khusus Google, suite pengujian otomatis berjalan setiap hari di seluruh matriks yang sangat besar dan bergilir yang terdiri dari lebih dari 190 model perangkat Android fisik. Hal ini mencakup perangkat yang mewakili berbagai chipset, versi OS, dan kemampuan hardware. 

Untuk beralih ke perilaku yang lebih konsisten di berbagai perangkat populer, Camera and Media Test Lab Google otomatis mendeteksi regresi library sebelum dapat memengaruhi kode produksi Anda.

2. Solusi Otomatis untuk Keunikan Perangkat

Perangkat Android yang berbeda memiliki batasan fisik yang berbeda. Beberapa mungkin gagal menyetel setelan eksposur kustom, sementara yang lain mungkin melaporkan data gambar terbalik saat menggunakan rasio aspek tertentu. Untuk mencegah developer mengotori codebase mereka dengan blok kondisional yang kompleks berdasarkan produsen dan model perangkat, CameraX mempertahankan class quirk perangkat internal seperti DeviceQuirks dan CameraQuirks di camera-camera2 (DeviceQuirksLoader.kt). Saat CameraX mendeteksi perangkat dengan masalah umum, CameraX akan otomatis memasukkan solusi yang disesuaikan. Bagi SmileID, ini berarti SDK mereka dapat berfungsi dengan andal di lebih dari 18.000 jenis perangkat Android tanpa memerlukan patch khusus perangkat di codebase mereka.

Menskalakan hingga 160 juta+ Verifikasi

Dengan bermigrasi ke CameraX, SmileID menyederhanakan integrasi SDK untuk developer aplikasi eksternal. 

Menghilangkan distorsi rasio lebar tinggi, pratinjau yang lambat, dan error OOM yang tiba-tiba mendorong peningkatan 20% dalam tingkat kelulusan verifikasi untuk layanan yang menggunakan SDK mereka. Bagi lembaga keuangan dan aplikasi uang seluler di seluruh Afrika, peningkatan tingkat kelulusan sebesar 20% berarti ratusan ribu pengguna yang sah berhasil bergabung, bukan berhenti.

Developer pun menyadarinya. Kemudahan mengintegrasikan SDK berbasis CameraX memicu lonjakan adopsi sebesar 15x pada tahun pertama, dan meningkat menjadi adopsi sebesar 20x pada tahun kedua. Hingga saat ini, SmileID telah berhasil memproses lebih dari 160 juta verifikasi identitas menggunakan CameraX.

Membangun Kisah Kompatibilitas Anda dengan Kemampuan CameraX

Mengembangkan aplikasi untuk kamera tidak harus sulit. Untuk membantu tim Anda mengadopsi pola CameraX yang sama dengan yang digunakan SmileID, Android telah meluncurkan Kemampuan CameraX untuk agen coding AI. 

Saat Anda menggunakan CameraX Skill di lingkungan pengembangan, agen coding AI seperti Gemini akan menerapkan pola CameraX saat ini untuk migrasi, binding siklus proses, ConcurrentCamera, dan MlKitAnalyzer. Baik Anda menyiapkan feed kamera ganda, mengonfigurasi pratinjau dengan PreviewView atau CameraXViewfinder, atau mengelola analisis machine learning (ML) real-time, Kemampuan CameraX memandu agen Anda untuk menghasilkan kode yang akurat dan siap produksi.

• Pelajari Skill CameraX: Buka Android Developer Skills Directory atau jalankan android skills add camerax dengan Android CLI untuk menambahkan skill ke alat coding AI Anda.
• Memulai CameraX: Pelajari Dokumentasi Resmi CameraX dan buat pengalaman kamera Anda berjalan di mana saja.