Câmera no desenvolvimento móvel: o que é, tipos de API e como usar

O que é uma câmera em aplicativos móveis

Uma câmera móvel é um módulo óptico integrado composto por uma lente, um sensor de imagem e um processador de sinal de imagem (ISP). O desenvolvedor acessa a câmera através do sistema operacional usando frameworks especializados. No Android, são eles Camera2 API (baixo nível) e CameraX (alto nível, baseado no Camera2), e no iOS — AVFoundation e UIKit para cenários simples. Cada plataforma fornece seu próprio conjunto de ferramentas, mas o conceito geral é o mesmo: o aplicativo inicializa uma sessão de captura, configura parâmetros (resolução, foco, exposição) e recebe um fluxo de quadros ou imagens individuais.

Capacidades de hardware das câmeras modernas

Câmeras móveis modernas suportam muitos modos de captura: HDR, modo noturno, retrato com desfoque de fundo, vídeo em câmera lenta e gravação em formato RAW. O desenvolvedor tem acesso a configurações de software: ISO (sensibilidade do sensor), velocidade do obturador (exposição), balanço de branco, foco (automático e manual) e estabilização de imagem. Dispositivos flagship podem ter até 4 câmeras com diferentes distâncias focais, e o aplicativo pode selecionar uma câmera específica por ID.

Tipos de API para trabalhar com câmera

As plataformas móveis oferecem várias APIs para trabalhar com a câmera, variando em nível de abstração e funcionalidade. A escolha de uma API específica depende dos requisitos do projeto: para captura simples de fotos, CameraX ou UIImagePickerController é suficiente; para aplicações profissionais, é necessário Camera2 ou AVFoundation com controle direto do sensor. Abaixo está uma comparação das principais APIs.

Quando escolher CameraX

CameraX é a escolha ideal para a maioria dos aplicativos Android que precisam de uma câmera sem personalização profunda. A biblioteca gerencia automaticamente o ciclo de vida da Activity e Fragment, suporta permissões e garante compatibilidade entre diferentes versões do Android. O CameraX garante comportamento consistente em 95% dos dispositivos Android graças à sua camada de compatibilidade. Se você precisar de visualização da câmera (Preview), captura de fotos (ImageCapture) ou análise de quadros (ImageAnalysis) — o CameraX lida com todos os três cenários sem escrever código complexo.

Quando escolher Camera2

Camera2 é uma API de baixo nível para cenários profissionais: gravação RAW, ajuste manual de exposição, captura em burst e controle simultâneo de várias câmeras. O Camera2 exige que o desenvolvedor tenha um conhecimento profundo do pipeline de captura de imagens, gerenciamento de StateMachine e manipulação de callbacks. Use Camera2 apenas se o CameraX não cobrir os requisitos: por exemplo, aplicativos de digitalização de documentos com foco manual ou câmeras personalizadas com resolução não padrão.

Solicitação de permissões de câmera

O acesso à câmera requer permissão explícita do usuário em ambas as plataformas. No Android, a permissão CAMERA é adicionada ao manifesto e, a partir do Android 6.0, a permissão também deve ser solicitada em tempo de execução através de ActivityCompat.requestPermissions. No iOS, a chave NSCameraUsageDescription é adicionada ao Info.plist com uma descrição de por que a câmera é usada. Sem esta descrição, o aplicativo falhará ao tentar acessar a câmera. A partir do iOS 14, o diálogo de permissão exibe não apenas o nome do aplicativo, mas também o motivo especificado — a redação deve ser clara para o usuário.

Implementação no Android com CameraX

CameraX simplifica o trabalho com a câmera para apenas algumas linhas de código. Para iniciar uma visualização, você precisa criar uma instância de Preview, vinculá-la a um LifecycleOwner e obter um SurfaceProvider para exibição. Para captura de fotos, é usado ImageCapture com um destino de salvamento. Abaixo está um exemplo completo de inicialização da câmera e captura de foto usando CameraX em Kotlin.

Configuração de Preview e ImageCapture

val preview = Preview.Builder()
    .build()
    .also {
        it.surfaceProvider = viewFinder.surfaceProvider
    }

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

val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
cameraProviderFuture.addListener(Runnable {
    val cameraProvider = cameraProviderFuture.get()
    val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

    try {
        cameraProvider.unbindAll()
        cameraProvider.bindToLifecycle(
            this, cameraSelector, preview, imageCapture
        )
    } catch (e: Exception) {
        Log.e("CameraX", "Falha na vinculação", e)
    }
}, ContextCompact.getMainExecutor(this))

O método bindToLifecycle vincula a câmera ao ciclo de vida da Activity — quando a tela gira ou o aplicativo vai para segundo plano, a câmera é liberada automaticamente. CameraSelector.DEFAULT_BACK_CAMERA seleciona a câmera traseira; para a câmera frontal, é usado DEFAULT_FRONT_CAMERA. Após a vinculação, o Preview começa a exibir o feed da câmera no PreviewView, e o usuário vê a imagem da câmera na tela.

Capturando uma foto

val photoFile = File(
    externalMediaDirs.firstOrNull(),
    "IMG_${System.currentTimeMillis()}.jpg"
)
val outputOptions = ImageCapture.OutputFileOptions
    .Builder(photoFile)
    .build()

imageCapture.takePicture(
    outputOptions,
    ContextCompact.getMainExecutor(this),
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(output: ImageCapture.OutputFileResults) {
            Log.d("CameraX", "Photo saved: ${photoFile.absolutePath}")
        }
        override fun onError(exception: ImageCaptureException) {
            Log.e("CameraX", "Erro de captura", exception)
        }
    }
)

O método takePicture captura um quadro da câmera e o salva em um arquivo. OutputFileOptions suporta escrita em File, ContentResolver e MediaStore. No callback onImageSaved, o aplicativo recebe uma notificação de salvamento bem-sucedido e pode atualizar a UI. CAPTURE_MODE_MINIMIZE_LATENCY garante velocidade máxima do obturador ao reduzir o pós-processamento.

Implementação no iOS com AVFoundation

No iOS, o acesso à câmera é fornecido pelo framework AVFoundation através da classe AVCaptureSession. O desenvolvedor cria uma sessão de captura, adiciona as entradas necessárias (AVCaptureDeviceInput) e saídas (AVCapturePhotoOutput, AVCaptureVideoDataOutput) e inicia a sessão. AVCaptureVideoPreviewLayer é usado para exibir a visualização. Abaixo está um exemplo de configuração de uma sessão para captura de fotos em Swift.

import AVFoundation

let captureSession = AVCaptureSession()
captureSession.sessionPreset = .photo

guard let camera = AVCaptureDevice.default(
    for: .video
) else { return }

guard let input = try? AVCaptureDeviceInput(device: camera)
else { return }

let output = AVCapturePhotoOutput()
captureSession.addInput(input)
captureSession.addOutput(output)

DispatchQueue.global(qos: .userInitiated).async {
    captureSession.startRunning()
}

AVCaptureSessionPreset.photo define a resolução ideal para fotos (geralmente 12 MP em dispositivos modernos). A entrada é um AVCaptureDeviceInput criado para a câmera do dispositivo. Após adicionar a entrada e a saída, a sessão é iniciada em uma thread de fundo através de startRunning — iniciar a sessão pode levar até 200 ms em dispositivos mais antigos. Para capturar uma foto, capturePhoto(with:delegate:) é chamado, e o resultado é retornado através do AVCapturePhotoCaptureDelegate.

Recursos e limitações

Ao trabalhar com a câmera em dispositivos móveis, as limitações de hardware devem ser consideradas: aquecimento do dispositivo durante gravação prolongada, consumo de bateria ao trabalhar com alta resolução e qualidade de câmera variável em diferentes dispositivos. No Android, a fragmentação do ecossistema significa que a mesma configuração do CameraX pode se comportar de maneira diferente em modelos distintos. No iOS, as limitações dizem respeito principalmente ao licenciamento: usar a câmera em segundo plano requer uma permissão especial da Apple. Também é importante lembrar que os simuladores não têm acesso a uma câmera real — os testes só são possíveis em um dispositivo físico.

Compatibilidade com diferentes versões do SO

CameraX resolve o problema de fragmentação do Android através da camada de compatibilidade CameraXConfig — a biblioteca aplica automaticamente soluções alternativas para bugs conhecidos de fabricantes. No iOS, o AVFoundation funciona uniformemente em todos os dispositivos a partir do iOS 6, mas alguns recursos (como Modo Retrato ou LiDAR) estão disponíveis apenas no iPhone 12 e modelos mais novos. Ao desenvolver um aplicativo multiplataforma, é recomendado usar Flutter ou React Native com plugins de câmera — eles abstraem as diferenças de plataforma e fornecem uma API unificada para ambos os sistemas operacionais.