CameraX: o que é, API CameraX e como a câmera funciona

O que é CameraX?

CameraX é uma biblioteca do conjunto Android Jetpack, lançada pela Google em 2019 como substituta da obsoleta Camera API e uma alternativa simplificada à complexa Camera2. A filosofia central do CameraX é “escreva uma vez, funciona em todos os dispositivos”. A biblioteca lida automaticamente com as diferenças de hardware: posicionamento das câmeras, resoluções suportadas, orientação do sensor e formatos disponíveis — o desenvolvedor não precisa escrever código específico do dispositivo.

A arquitetura do CameraX é construída em casos de uso: Preview (exibir o feed da câmera no Viewfinder), ImageCapture (tirar fotos), ImageAnalysis (analisar o fluxo de frames para ML) e VideoCapture (gravar vídeo). Cada caso de uso é um componente independente que pode ser combinado: executar Preview para o visor e ImageAnalysis para processamento ML simultaneamente. De acordo com a Google (2026), o CameraX é suportado em 99% dos dispositivos Android com API 21+.

Principais funcionalidades

CameraX fornece alternância automática entre câmeras frontal e traseira, suporte para rotação de ecrã sem recriar a sessão, gerenciamento integrado do ciclo de vida através do LifecycleOwner, vinculação de casos de uso a um único processo Lifecycle, suporte para Camera2 Extensions para retrato, HDR e modo noturno, e TestableCameraX para testes unitários sem dispositivo real.

Casos de uso do CameraX

CameraX define quatro casos de uso padrão, cada um resolvendo uma tarefa específica da câmera. Os casos de uso podem ser combinados: as combinações mais populares são Preview + ImageCapture para um aplicativo de câmera e Preview + ImageAnalysis para um scanner ML.

Preview

O caso de uso Preview exibe o fluxo de vídeo da câmera no PreviewView — uma View especial da biblioteca CameraX. O PreviewView adapta-se automaticamente à proporção da câmera, suporta ScaleType (FillCenter, FitCenter) e rotação de ecrã sem recriar o caso de uso. O desenvolvedor só precisa vincular o Preview a um Lifecycle através do ProcessCameraProvider.

ImageAnalysis

O caso de uso ImageAnalysis envia cada frame da câmera para um manipulador para análise: reconhecimento de texto, deteção facial, leitura de QR codes. O analisador recebe frames no formato YUV_420_888 — o espaço de cores universal do Android. Modo de operação (BLOCKING ou NON_BLOCKING) controla a fila de frames: BLOCKING aguarda a conclusão da análise anterior, NON_BLOCKING ignora frames durante atrasos.

ImageCapture

O caso de uso ImageCapture tira fotos da câmera com configurações de flash, resolução e compressão. Os formatos JPEG e RAW são suportados (em dispositivos compatíveis). O ImageCapture salva a foto de forma assíncrona através do OnImageCapturedCallback ou diretamente num ficheiro através do ImageCapture.OutputFileOptions.

VideoCapture — Gravação de vídeo

O caso de uso VideoCapture foi adicionado no CameraX 1.1.0 (beta) e permite gravar vídeo até 4K a 30 FPS. O caso de uso sincroniza-se automaticamente com o Preview: a imagem no visor corresponde ao que está a ser gravado no ficheiro. O VideoCapture usa MediaCodec e MediaMuxer internamente, ocultando a complexidade de configurar o codec de vídeo e o contentor MP4.

CameraX vs Camera2

CameraX e Camera2 são duas abordagens para trabalhar com a câmera no Android. Camera2 é uma API de baixo nível que oferece controlo total sobre o dispositivo. CameraX é uma abstração de alto nível que automatiza cenários típicos. A escolha entre eles depende dos requisitos do projeto.

Use CameraX para tarefas padrão: câmera na aplicação, scanner QR, processamento de fluxo ML. Use Camera2 quando for necessário controlo manual de exposição, captura RAW com controlo total de parâmetros, ou trabalho com múltiplas câmeras simultaneamente.

Exemplos de código em Kotlin

Vamos rever uma configuração completa do CameraX numa aplicação Android usando os três casos de uso principais: Preview, ImageCapture e ImageAnalysis.

Configuração do ProcessCameraProvider

O código vincula o CameraX ao ciclo de vida da Activity através do ProcessCameraProvider. Primeiro, é solicitada uma instância do fornecedor, depois os casos de uso são criados e a vinculação é realizada.

val cameraProviderFuture =
    ProcessCameraProvider.getInstance(this)

cameraProviderFuture.addListener({
    val cameraProvider = cameraProviderFuture.get()

    // Criando Preview
    val preview = Preview.Builder()
        .build()
        .also {
            it.setSurfaceProvider(
                binding.viewFinder.surfaceProvider
            )
        }

    // Criando ImageCapture
    val imageCapture = ImageCapture.Builder()
        .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
        .build()

    // Vinculando ao Lifecycle
    cameraProvider.unbindAll()
    cameraProvider.bindToLifecycle(
        this,
        CameraSelector.DEFAULT_BACK_CAMERA,
        preview,
        imageCapture
    )
}, ContextCompact.getMainExecutor(this))

O código Kotlin obtém o ProcessCameraProvider através de um future, cria os casos de uso Preview e ImageCapture, e vincula-os ao ciclo de vida da Activity atual. O CameraX lida automaticamente com a rotação do ecrã, a troca de câmera e a libertação de recursos ao fechar a Activity.

ImageAnalysis para processamento ML

Vamos adicionar um caso de uso ImageAnalysis para processamento frame a frame do fluxo da câmera, por exemplo para integrar com ML Kit.

val imageAnalysis = ImageAnalysis.Builder()
    .setBackpressureStrategy(
        ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST
    )
    .build()

imageAnalysis.setAnalyzer(
    ContextCompact.getMainExecutor(this)
) { imageProxy ->
    // Convertendo YUV para Bitmap para ML Kit
    val bitmap = ImageUtils.yuvToBitmap(imageProxy)
    val inputImage = InputImage.fromBitmap(bitmap)

    // Iniciando reconhecimento de texto do ML Kit
    recognizer.process(inputImage)
        .addOnSuccessListener { result ->
            // Processando o resultado
            processTextResult(result)
        }
        .addOnCompleteListener {
            imageProxy.close()
        }
}

O ImageAnalysis com estratégia KEEP_ONLY_LATEST processa apenas o último frame disponível, ignorando os desatualizados se o analisador não estiver a acompanhar. Cada frame é convertido de YUV para Bitmap para o ML Kit, após o que o reconhecimento de texto é iniciado. A chamada imageProxy.close() é obrigatória — caso contrário, o CameraX deixará de fornecer novos frames.

CameraX Extensions

CameraX Extensions é um módulo que adiciona modos de disparo avançados: retrato (desfoque de fundo), HDR (alcance dinâmico estendido), modo noturno (disparo com pouca luz), retoque automático (correção de pele) e modo beleza. As extensões são ativadas apenas em dispositivos onde o fabricante da câmera forneceu uma implementação OEM.

Verificação e ativação de extensões

Antes de usar CameraX Extensions, deve verificar se a extensão está disponível no dispositivo atual. A Google recomenda verificar através do ExtensionsManager.isExtensionAvailable.

val extensionsManager =
    ExtensionsManager.getInstance(this)

if (extensionsManager.isExtensionAvailable(
    cameraProvider,
    CameraSelector.DEFAULT_BACK_CAMERA,
    ExtensionMode.BOKEH
)) {
    // Ativando modo retrato
    cameraProvider.bindToLifecycle(
        this,
        CameraSelector.DEFAULT_BACK_CAMERA,
        preview,
        imageCapture
    )
}

O código verifica o suporte para a extensão BOKEH (retrato) através do ExtensionsManager e ativa-a se uma implementação OEM estiver disponível. O CameraX muda automaticamente as configurações da câmera para o modo retrato. Se a extensão não estiver disponível, a aplicação continua a funcionar em modo padrão sem falhas.

O CameraX Extensions resolve um dos principais problemas do desenvolvimento Android: a fragmentação de câmeras. Em diferentes dispositivos, o modo retrato é implementado de forma diferente — alguns usam lentes duplas, outros usam desfoque por software. O CameraX abstrai essa diferença: o desenvolvedor ativa o modo BOKEH, e a própria biblioteca determina como implementá-lo num dispositivo específico. A Google mantém uma lista de parceiros OEM verificados: Samsung, Xiaomi, OPPO, vivo, Google Pixel.

Ao trabalhar com CameraX, é importante considerar as limitações no número de casos de uso simultâneos: na maioria dos dispositivos, um máximo de 3 casos de uso pode ser executado ao mesmo tempo. Por exemplo, Preview + ImageCapture + ImageAnalysis funciona em todos os dispositivos modernos, mas Preview + ImageCapture + VideoCapture pode não ser suportado em modelos económicos. O CameraX fornece o método ProcessCameraProvider.checkAvailability(), que verifica a compatibilidade da combinação de casos de uso antes da vinculação, ajudando a evitar falhas em tempo de execução.

O CameraX integra-se com o Jetpack Navigation através do CameraXFragment ou PreviewView compatível com Compose. Para Compose, é utilizado o elemento AndroidView, no qual o PreviewView é incorporado. O CameraX lida corretamente com a rotação do ecrã e alterações de configuração sem perder o estado da sessão da câmera — basta especificar o LifecycleOwner, e a biblioteca recriará automaticamente as vinculações dos casos de uso ao rodar o dispositivo.

Para testar o CameraX sem um dispositivo real, a Google fornece o TestableCameraX — uma biblioteca que emula o comportamento da câmera em testes unitários. O TestableCameraX permite simular frames da câmera, testar o funcionamento do ImageAnalysis e a correção do ImageCapture sem um dispositivo físico. Isso acelera significativamente o pipeline CI/CD para projetos que trabalham com a câmera.