Como a SmileID escalonou a confirmação de identidade para mais de 18 mil tipos de dispositivos Android com o CameraX

Os apps de confirmação de identidade para bancos e registro de chips exigem capturas de rosto nítidas e de alta resolução para detectar spoofing e deepfakes. Capturar frames nítidos o suficiente para verificações de atividade e anti-spoofing, sem causar falhas em dispositivos com pouca memória, é um desafio comum para desenvolvedores de câmeras Android.

Para o SmileID, um SDK de confirmação de identidade líder na África, esse desafio é ainda maior devido a um ecossistema de hardware diversificado. O Android representa 85% da participação de mercado dos dispositivos de destino da SmileID, incluindo smartphones básicos com processadores altamente limitados, modelos regionais desconhecidos e terminais de ponto de venda (PDV) personalizados e robustos.

Antes de adotar o CameraX, o SmileID enfrentou obstáculos padrão, mas assustadores, de engenharia de câmera: feeds de visualização esticados, orientações de sensor giradas, falhas de falta de memória (OOM, na sigla em inglês) e bugs personalizados do fabricante de equipamento original (OEM, na sigla em inglês). Ao migrar os principais SDKs do Android para o CameraX, a SmileID transformou esses desafios em uma grande vantagem comercial.

De acordo com a SmileID, a migração dos SDKs do Android para o CameraX gerou os seguintes resultados:

O desafio: hardware fragmentado e problemas com APIs legadas

Para confirmar que um usuário é quem diz ser, o SDK da SmileID precisa capturar frames de selfie em alta resolução para verificações de atividade no dispositivo e detecção de deepfake baseada na nuvem. 

Nas implementações da API legada Camera1 e da API de baixo nível Camera2, era difícil conseguir isso de forma consistente por vários motivos: 

• Personalizações e peculiaridades do OEM: dispositivos de fabricantes diferentes relataram orientações físicas do sensor da câmera de maneira diferente, resultando em visualizações giradas ou capturas de rosto com orientação incorreta.
• Distorções na proporção: solicitar um tamanho de frame específico em dispositivos mais baratos geralmente fazia com que a visualização da câmera se esticasse vertical ou horizontalmente, distorcendo o rosto do usuário e inutilizando a verificação biométrica.
• Falhas de falta de memória (OOM, na sigla em inglês): o processamento de imagens brutas de alta resolução em dispositivos com pouca RAM (geralmente 1 GB ou menos) costumava causar falhas fatais de alocação de memória.

Devido a esses pontos de atrito, o crescimento anual da adoção do SDK da SmileID foi limitado a 2 ou 3 vezes, e muitas verificações precisaram recorrer ao upload de fotos estáticas por uma API REST de alta latência, em vez de executar verificações de atividade em tempo real no dispositivo.

A solução: pipelines consistentes com o CameraX 

A SmileID reformulou os SDKs para dispositivos móveis do zero usando a CameraX, que foi criada especificamente para abstrair a complexidade do ecossistema de dispositivos subjacente e fornecer uma interface de desenvolvedor consistente e com reconhecimento de ciclo de vida nativo.

Usando os principais casos de uso do CameraX (especificamente Preview e ImageAnalysis), a SmileID criou um pipeline de câmera robusto e de dupla finalidade:

• Visualização: renderiza uma visualização em tempo real e perfeitamente proporcional da transmissão da câmera para orientar o usuário.
• ImageAnalysis: processa continuamente frames localmente em tempo real para executar a detecção automatizada de atividade e de rosto no frame e extrair o frame da selfie verificada.

Para capturar detalhes ultra nítidos para detecção de deepfakes sem causar falhas de OOM, o SmileID adicionou a API moderna ResolutionSelector do CameraX diretamente à configuração do ImageAnalysis. Ele permite que os desenvolvedores solicitem uma resolução de destino e escolham uma regra de substituição quando um dispositivo não oferece suporte para esse tamanho exato. Por exemplo, o diagrama e o exemplo de configuração a seguir mostram como o ResolutionSelector avalia os tamanhos candidatos em torno de um destino de 1200 x 900:

Confira o exemplo de código correspondente que mostra como parear o ResolutionSelector com STRATEGY_KEEP_ONLY_LATEST no seu app (use FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER para priorizar a nitidez ou FALLBACK_RULE_CLOSEST_LOWER_THEN_HIGHER para limitar o uso da memória):

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

Ao solicitar frames de pixels de alta densidade e processá-los localmente, o SmileID conseguiu um aumento de 4 vezes na resolução das selfies capturadas. A SmileID também compactou a região do rosto cortada no dispositivo para que o tamanho do upload de rede permanecesse idêntico ao do sistema anterior. Essa arquitetura garantiu dados mais nítidos para os modelos de machine learning sem aumentar os custos de dados móveis para os usuários.

Como o CameraX resolve as diferenças de hardware

A padronização com o CameraX permitiu que a SmileID usasse duas camadas de engenharia de compatibilidade para manter o SDK estável em todos os dispositivos:

1. Laboratório de teste de câmera e mídia do Google

A compatibilidade do CameraX é respaldada por uma verificação contínua de hardware físico. No Laboratório de Testes de Câmera e Mídia dedicado do Google, um pacote de testes automatizado é executado diariamente em uma matriz rotativa de mais de 190 modelos de dispositivos Android físicos. Isso inclui dispositivos que representam diferentes chipsets, versões de SO e recursos de hardware. 

Para que o comportamento seja mais consistente em dispositivos conhecidos, o Test Lab de Câmera e Mídia do Google detecta automaticamente regressões de biblioteca antes que elas afetem o código de produção.

2. Soluções automáticas para peculiaridades de dispositivos

Dispositivos Android diferentes têm limitações físicas diferentes. Alguns podem não definir as configurações de exposição personalizadas, enquanto outros podem relatar dados de imagem invertidos ao usar determinadas proporções. Para evitar que os desenvolvedores poluam as bases de código com blocos condicionais complexos com base no fabricante e no modelo do dispositivo, o CameraX mantém classes internas de peculiaridades do dispositivo, como DeviceQuirks e CameraQuirks, em camera-camera2 (DeviceQuirksLoader.kt). Quando a CameraX detecta um dispositivo com um problema conhecido, ela injeta automaticamente uma solução alternativa personalizada. Para a SmileID, isso significou que o SDK deles poderia funcionar de forma confiável em mais de 18 mil tipos de dispositivos Android sem precisar de patches específicos para cada dispositivo na base de código.

Escalonamento para mais de 160 milhões de verificações

Ao migrar para o CameraX, o SmileID simplificou a integração do SDK para desenvolvedores de apps externos. 

A eliminação de distorções na proporção, visualizações com atraso e falhas repentinas de OOM resultou em um aumento de 20% nas taxas de aprovação de verificação para serviços que usam os SDKs. Para instituições financeiras e apps de dinheiro móvel em toda a África, um aumento de 20% nas taxas de aprovação significa que centenas de milhares de usuários legítimos estão sendo integrados com sucesso, em vez de desistirem.

Os desenvolvedores perceberam isso. A facilidade de integração do SDK baseado no CameraX resultou em um aumento de 15 vezes na adoção no primeiro ano, que subiu para 20 vezes no segundo ano. Até o momento, a SmileID já processou mais de 160 milhões de confirmações de identidade usando o CameraX.

Crie sua história de compatibilidade com a habilidade do CameraX

Desenvolver para câmeras não precisa ser difícil. Para ajudar sua equipe a adotar os mesmos padrões do CameraX usados pela SmileID, o Android lançou a habilidade do CameraX para agentes de programação de IA. 

Ao usar a habilidade da CameraX no seu ambiente de desenvolvimento, os agentes de programação de IA, como o Gemini, aplicam os padrões atuais da CameraX para migração, vinculação de ciclo de vida, ConcurrentCamera e MlKitAnalyzer. Seja para configurar transmissões de câmera dupla, uma visualização com PreviewView ou CameraXViewfinder ou gerenciar análises de aprendizado de máquina (ML) em tempo real, a habilidade do CameraX orienta seu agente a gerar um código preciso e pronto para produção.

• Conheça a habilidade do CameraX: acesse o diretório de habilidades para desenvolvedores Android ou execute android skills add camerax com a CLI do Android para adicionar a habilidade à sua ferramenta de programação com IA.
• Introdução ao CameraX: acesse a documentação oficial do CameraX e faça com que sua experiência de câmera funcione em qualquer lugar.