Comment SmileID a étendu la validation de l'identité à plus de 18 000 types d'appareils Android avec CameraX

Les applications de validation de l'identité pour les services bancaires et l'enregistrement de cartes SIM nécessitent des captures de visage claires et en haute résolution pour détecter l'usurpation d'identité et les deepfakes. Capturer des images suffisamment nettes pour les contrôles de détection d'activité et d'anti-spoofing, sans faire planter les appareils à faible mémoire, est un défi courant pour les développeurs d'appareils photo Android.

Pour SmileID, un SDK de validation d'identité de premier plan en Afrique, ce défi est doublé par un écosystème matériel diversifié. Android représente 85 % de la part de marché des appareils cibles de SmileID, y compris les smartphones d'entrée de gamme dotés de processeurs très limités, les modèles régionaux peu connus et les terminaux de point de vente personnalisés et renforcés.

Avant d'adopter CameraX, SmileID était confronté à des obstacles d'ingénierie de caméra standards, mais intimidants : flux d'aperçu étirés, orientations de capteur pivotées, plantages de mémoire insuffisante et bugs de fabricant d'équipement d'origine (OEM) personnalisés. En migrant ses principaux SDK Android vers CameraX, SmileID a transformé ces défis en un avantage commercial majeur.

Selon SmileID, la migration de ses SDK Android vers CameraX a donné les résultats suivants :

Le défi : un matériel fragmenté et des API anciennes

Pour confirmer l'identité d'un utilisateur, le SDK de SmileID doit capturer des selfies haute résolution pour les contrôles de détection du vivant sur l'appareil et la détection des deepfakes dans le cloud. 

Avec les anciennes implémentations de l'API Camera1 et de l'API Camera2 de bas niveau, il était difficile d'obtenir un résultat cohérent pour plusieurs raisons : 

• Personnalisations et particularités des OEM : les appareils de différents fabricants indiquent différemment les orientations physiques du capteur de l'appareil photo, ce qui entraîne des aperçus pivotés ou des captures de visage mal orientées.
• Distorsions du format : demander une taille d'image spécifique sur les appareils d'entrée de gamme entraînait souvent l'étirement vertical ou horizontal de l'aperçu de l'appareil photo, ce qui déformait le visage de l'utilisateur et rendait la validation biométrique inutile.
• Plantages dus à un manque de mémoire (OOM) : le traitement d'images RAW haute résolution sur des appareils disposant de peu de RAM (souvent 1 Go ou moins) entraînait fréquemment des plantages fatals d'allocation de mémoire.

En raison de ces points de friction, la croissance de l'adoption du SDK de SmileID d'une année sur l'autre était limitée à un facteur de deux à trois, et de nombreuses vérifications devaient se rabattre sur l'importation de photos statiques via une API REST à latence élevée au lieu d'exécuter des vérifications de liveness en temps réel sur l'appareil.

La solution : des pipelines cohérents avec CameraX 

SmileID a entièrement repensé ses SDK mobiles à l'aide de CameraX, qui est spécialement conçu pour éliminer la complexité de l'écosystème d'appareils sous-jacent et fournir une interface de développement cohérente, nativement sensible au cycle de vie.

En utilisant les principaux cas d'utilisation de CameraX (en particulier Preview et ImageAnalysis), SmileID a créé un pipeline d'appareil photo robuste à double usage :

• Aperçu : affiche un aperçu en temps réel parfaitement proportionné du flux de la caméra pour guider l'utilisateur.
• ImageAnalysis : traite en continu les images localement et en temps réel pour exécuter la détection automatisée de liveness et de visage dans l'image, et extraire l'image du selfie vérifié.

Pour capturer des détails ultra-nets pour la détection des deepfakes sans provoquer de plantages OOM, SmileID a ajouté l'API ResolutionSelector moderne de CameraX directement à sa configuration ImageAnalysis. Elle permet aux développeurs de demander une résolution cible et de choisir une règle de remplacement lorsqu'un appareil n'est pas compatible avec cette taille exacte. Par exemple, le diagramme et l'exemple de configuration suivants illustrent comment ResolutionSelector évalue les tailles candidates autour d'une cible de 1200 x 900 :

Voici l'exemple de code correspondant montrant comment associer ResolutionSelector à STRATEGY_KEEP_ONLY_LATEST dans votre propre application (utilisez FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER pour donner la priorité à la netteté ou FALLBACK_RULE_CLOSEST_LOWER_THEN_HIGHER pour limiter l'utilisation de la mémoire) :

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

En demandant des images à haute densité de pixels et en les traitant localement, SmileID a multiplié par quatre la résolution des selfies capturés. SmileID a également compressé la zone du visage recadrée sur l'appareil afin que la taille d'importation sur le réseau reste identique à celle de son système précédent. Cette architecture a permis d'obtenir des données plus précises pour leurs modèles de machine learning sans augmenter les coûts de données mobiles pour leurs utilisateurs.

Comment CameraX résout les différences matérielles

En adoptant CameraX, SmileID a pu s'appuyer sur deux couches d'ingénierie de compatibilité pour maintenir la stabilité de son SDK sur tous les appareils :

1. Laboratoire de test des appareils photo et des contenus multimédias de Google

La compatibilité de CameraX est assurée par une vérification continue du matériel physique. Dans le Test Lab de CameraX de Google, une suite de tests automatisés est exécutée quotidiennement sur une matrice massive et rotative de plus de 190 modèles d'appareils Android physiques. Cela inclut des appareils représentant différents chipsets, versions d'OS et capacités matérielles. 

Pour assurer un comportement plus cohérent sur les appareils populaires, le Camera and Media Test Lab de Google détecte automatiquement les régressions de la bibliothèque avant qu'elles n'affectent votre code de production.

2. Solutions automatiques pour les particularités des appareils

Les limites physiques varient selon les appareils Android. Certains appareils peuvent ne pas parvenir à définir des paramètres d'exposition personnalisés, tandis que d'autres peuvent signaler des données d'image inversées lors de l'utilisation de certains formats. Pour éviter que les développeurs ne polluent leurs codebases avec des blocs conditionnels complexes basés sur le fabricant et le modèle de l'appareil, CameraX gère des classes de particularités d'appareil internes telles que DeviceQuirks et CameraQuirks dans camera-camera2 (DeviceQuirksLoader.kt). Lorsque CameraX détecte un appareil présentant un problème connu, il injecte automatiquement une solution de contournement adaptée. Pour SmileID, cela signifiait que son SDK pouvait fonctionner de manière fiable sur plus de 18 000 types d'appareils Android sans nécessiter de correctifs spécifiques à l'appareil dans sa codebase.

Scaling up to 160 million+ Verifications

En migrant vers CameraX, SmileID a simplifié l'intégration du SDK pour les développeurs d'applications externes. 

En éliminant les distorsions du format, les aperçus lents et les plantages soudains dus à un manque de mémoire, l'entreprise a pu augmenter de 20 % le taux de réussite de la validation pour les services utilisant ses SDK. Pour les institutions financières et les applications d'argent mobile en Afrique, une augmentation de 20 % des taux de réussite signifie que des centaines de milliers d'utilisateurs légitimes sont intégrés avec succès au lieu d'être perdus.

Les développeurs ont remarqué ce changement. La facilité d'intégration du SDK basé sur CameraX a entraîné une multiplication par 15 de l'adoption au cours de la première année, puis une multiplication par 20 au cours de la deuxième année. À ce jour, SmileID a traité avec succès plus de 160 millions de validations d'identité à l'aide de CameraX.

Développer votre histoire de compatibilité avec la compétence CameraX

Le développement pour les caméras n'est pas forcément difficile. Pour aider votre équipe à adopter les mêmes modèles CameraX que SmileID, Android a lancé la compétence CameraX pour les agents de codage IA. 

Lorsque vous utilisez la compétence CameraX dans votre environnement de développement, les agents de codage IA tels que Gemini appliquent les modèles CameraX actuels pour la migration, la liaison du cycle de vie, ConcurrentCamera et MlKitAnalyzer. Que vous configuriez des flux à double caméra, un aperçu avec PreviewView ou CameraXViewfinder, ou que vous gériez l'analyse de machine learning (ML) en temps réel, la compétence CameraX guide votre agent pour générer un code précis et prêt pour la production.

• Explorez la compétence CameraX : consultez le répertoire des compétences des développeurs Android ou exécutez android skills add camerax avec la CLI Android pour ajouter la compétence à votre outil de codage IA.
• Premiers pas avec CameraX : consultez la documentation officielle de CameraX et faites en sorte que votre expérience photo fonctionne partout.