Android Academy · Aula

Visão geral do CameraX

Por que usar CameraX em vez das APIs antigas de câmera.

Visão geral do CameraX é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

Por que usar CameraX?

Adicionar uma câmera a um aplicativo Android costumava ser difícil. A antiga API android.hardware.camera2 é poderosa, mas extremamente detalhada, e se comporta de maneira diferente nos milhares de dispositivos disponíveis.

CameraX é uma biblioteca Jetpack que funciona sobre a Camera2 e oferece uma API simples, consistente e ciente do ciclo de vida. Neste curso, você usará CameraX para mostrar uma visualização ao vivo, tirar fotos e gravar vídeos.

O que a CameraX resolve

A CameraX foi criada com três objetivos:

Facilidade de uso — muito menos código repetitivo do que na Camera2.
Consistência — o Google a testa em um grande laboratório de dispositivos, para que dispositivos com comportamentos incomuns funcionem de maneira previsível.
Consciência do ciclo de vida — a câmera inicia e para automaticamente com o ciclo de vida da sua tela, evitando que você deixe a câmera aberta.

Você descreve o que deseja (uma visualização, uma foto ou um vídeo), e a CameraX determina como fazer isso no dispositivo atual.

Os três principais casos de uso

A CameraX é estruturada em torno de casos de uso. Um caso de uso é uma parte independente da funcionalidade da câmera. Os três principais são:

Preview — mostra na tela o que a câmera vê.
ImageCapture — tira uma foto.
VideoCapture — grava um vídeo.

Você cria os casos de uso necessários e os associa à câmera.

// You create the use cases you need:
val preview = Preview.Builder().build()
val imageCapture = ImageCapture.Builder().build()
// Later you bind them to a lifecycle and a camera.

Adicionando as dependências

A CameraX é distribuída como vários artefatos. Você os adiciona ao build.gradle.kts do seu módulo. Uma configuração típica inclui a biblioteca principal, o backend camera2, a integração com o ciclo de vida e auxiliares de visualização.

Mantenha todos os artefatos da CameraX na mesma versão para evitar conflitos.

dependencies {
    val cameraxVersion = "1.3.4"
    implementation("androidx.camera:camera-core:$cameraxVersion")
    implementation("androidx.camera:camera-camera2:$cameraxVersion")
    implementation("androidx.camera:camera-lifecycle:$cameraxVersion")
    implementation("androidx.camera:camera-view:$cameraxVersion")
    implementation("androidx.camera:camera-video:$cameraxVersion")
}

Declarando permissões

Para usar a câmera, você deve declarar a permissão CAMERA no arquivo AndroidManifest.xml. Se também gravar vídeos, talvez precise de RECORD_AUDIO.

Essas são permissões em tempo de execução — declará-las não é suficiente; você também deve solicitá-las ao usuário em tempo de execução (isso será abordado em lições posteriores).

<!-- AndroidManifest.xml -->
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-feature
    android:name="android.hardware.camera.any"
    android:required="false" />

O CameraProvider

O ponto de entrada da CameraX é o ProcessCameraProvider. Ele conecta os casos de uso à câmera e ao ciclo de vida da sua tela.

Você o obtém de forma assíncrona com getInstance(), que retorna um ListenableFuture. No Kotlin, você pode usar await() dentro de uma corrotina.

import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.core.ExperimentalGetImage

suspend fun Context.getCameraProvider(): ProcessCameraProvider {
    return ProcessCameraProvider.getInstance(this).await()
}

Associando casos de uso a um ciclo de vida

Depois de obter o provedor, você associa seus casos de uso a um LifecycleOwner e a um CameraSelector (a câmera frontal ou traseira).

Como a associação considera o ciclo de vida, a CameraX abre automaticamente a câmera quando sua tela está visível e a fecha quando deixa de estar — não é necessária nenhuma limpeza manual.

val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

cameraProvider.unbindAll()
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    cameraSelector,
    preview,
    imageCapture
)

Escolhendo uma câmera

Um CameraSelector informa à CameraX qual câmera física usar. As duas opções mais comuns são a câmera traseira padrão e a câmera frontal padrão.

Você também pode criar um seletor personalizado para exigir características específicas, mas os padrões atendem a praticamente todos os aplicativos.

// Back camera (most common for photos)
val back = CameraSelector.DEFAULT_BACK_CAMERA

// Front camera (selfies, video calls)
val front = CameraSelector.DEFAULT_FRONT_CAMERA

// Toggle between them by swapping the selector and re-binding.

PreviewView: a superfície de exibição

A CameraX renderiza a visualização ao vivo em uma PreviewView. Ela é uma View comum do Android que gerencia a superfície, o dimensionamento e a rotação para você.

No Jetpack Compose, você a incorpora com AndroidView, que permite colocar uma View clássica dentro de um componente composable. Você configurará isso completamente na próxima lição.

AndroidView(
    factory = { context ->
        PreviewView(context).apply {
            scaleType = PreviewView.ScaleType.FILL_CENTER
        }
    },
    modifier = Modifier.fillMaxSize()
)

A consciência do ciclo de vida em ação

O maior benefício prático da CameraX é considerar o ciclo de vida. Com a Camera2, você precisava abrir manualmente a câmera em onResume e liberá-la em onPause, e esquecer de fazer isso causava falhas ou deixava a câmera travada.

Com a CameraX, depois que você usa bindToLifecycle, a estrutura cuida de tudo isso. Quando o usuário sai da tela, a câmera é liberada automaticamente; quando ele retorna, ela é aberta novamente.

// No manual open/close needed.
// bindToLifecycle ties the camera to the screen's
// lifecycle, so it follows onStart/onStop for you.
cameraProvider.bindToLifecycle(lifecycleOwner, selector, preview)

Seu modelo mental

Tenha esta visão em mente durante o restante do curso:

Obtenha um ProcessCameraProvider.
Crie os casos de uso necessários (Preview, ImageCapture, VideoCapture).
Escolha um CameraSelector.
Use bindToLifecycle para conectar tudo.

Todo recurso da CameraX é apenas uma variação dessas quatro etapas.

Verificação rápida

Teste sua compreensão dos fundamentos da CameraX.

Recapitulação

Agora você entende a visão geral da CameraX:

A CameraX encapsula a Camera2 com uma API mais simples, consistente e ciente do ciclo de vida.
Ela é estruturada em torno de casos de uso: Preview, ImageCapture e VideoCapture.
Você adiciona os artefatos da CameraX, declara a permissão CAMERA, obtém um ProcessCameraProvider e usa bindToLifecycle.
Um CameraSelector escolhe entre a câmera frontal e a traseira; uma PreviewView exibe a transmissão.

Em seguida, você configurará uma visualização ao vivo real na tela.

Perguntas Frequentes

A aula “Visão geral do CameraX” é grátis?

Sim — o texto completo de “Visão geral do CameraX” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Visão geral do CameraX”?

Por que usar CameraX em vez das APIs antigas de câmera. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Visão geral do CameraX”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy