Android Academy · Aula

Gravando vídeo

Capture vídeo com CameraX.

Gravando vídeo é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 4 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.

Gravando vídeos com CameraX

CameRX grava vídeos por meio do caso de uso VideoCapture, apoiado por um Recorder. Nesta lição, você configurará a captura de vídeo, iniciará e interromperá uma gravação e a salvará na galeria — incluindo o áudio.

O fluxo é semelhante ao de fotos, mas acrescenta uma sessão de Recording de longa duração, que você inicia e interrompe posteriormente.

Recorder e qualidade

Primeiro, você cria um Recorder, que define a codificação e a qualidade. QualitySelector permite solicitar uma qualidade de destino (por exemplo, HD ou FHD), com uma alternativa caso o dispositivo não possa fornecê-la.

val recorder = Recorder.Builder()
    .setQualitySelector(
        QualitySelector.from(
            Quality.FHD,
            FallbackStrategy.lowerQualityOrHigherThan(Quality.SD)
        )
    )
    .build()

Criando VideoCapture

Envolva o Recorder em um caso de uso VideoCapture com a fábrica withOutput. Esse é o objeto que você vincula à câmera, assim como ImageCapture.

val videoCapture = VideoCapture.withOutput(recorder)

Vinculando visualização + VideoCapture

Vincule a visualização e o VideoCapture. Observe que, em muitos dispositivos, não é possível vincular ImageCapture e VideoCapture ao mesmo tempo; portanto, escolha os casos de uso de que sua tela precisa.

cameraProvider.unbindAll()
cameraProvider.bindToLifecycle(
    lifecycleOwner,
    CameraSelector.DEFAULT_BACK_CAMERA,
    preview,
    videoCapture
)

Permissão de áudio

Para gravar som, você precisa da permissão de tempo de execução RECORD_AUDIO, além de CAMERA. Solicite ambas antes de iniciar uma gravação e habilite o áudio somente se o usuário tiver concedido a permissão.

// Manifest declares both:
// <uses-permission android:name="android.permission.CAMERA" />
// <uses-permission android:name="android.permission.RECORD_AUDIO" />

val audioGranted = ContextCompat.checkSelfPermission(
    context, Manifest.permission.RECORD_AUDIO
) == PackageManager.PERMISSION_GRANTED

Saída via MediaStore

Assim como nas fotos, salve o vídeo em MediaStore usando o armazenamento com escopo. Crie ContentValues com um tipo MIME mp4 e crie MediaStoreOutputOptions.

val values = ContentValues().apply {
    put(MediaStore.MediaColumns.DISPLAY_NAME, "VID_${System.currentTimeMillis()}")
    put(MediaStore.MediaColumns.MIME_TYPE, "video/mp4")
    put(MediaStore.Video.Media.RELATIVE_PATH, "Movies/MyApp")
}

val outputOptions = MediaStoreOutputOptions
    .Builder(context.contentResolver, MediaStore.Video.Media.EXTERNAL_CONTENT_URI)
    .setContentValues(values)
    .build()

Iniciando uma gravação

Prepare a gravação a partir do gravador, habilite opcionalmente o áudio com withAudioEnabled() e, em seguida, chame start(). start() retorna um objeto Recording que você deve manter para poder interrompê-lo posteriormente.

Você também passa um listener que recebe atualizações de VideoRecordEvent.

val recording = videoCapture.output
    .prepareRecording(context, outputOptions)
    .apply { if (audioGranted) withAudioEnabled() }
    .start(ContextCompat.getMainExecutor(context)) { event ->
        when (event) {
            is VideoRecordEvent.Start -> { /* recording began */ }
            is VideoRecordEvent.Finalize -> {
                if (!event.hasError()) {
                    // event.outputResults.outputUri -> saved video
                }
            }
        }
    }

Reagindo aos eventos de gravação

O listener transmite o ciclo de vida da gravação:

VideoRecordEvent.Start — a gravação começou (atualize a interface para exibir um botão de interrupção).
VideoRecordEvent.Status — atualizações periódicas com a duração e o tamanho gravados.
VideoRecordEvent.Finalize — a gravação terminou; verifique hasError().

is VideoRecordEvent.Status -> {
    val seconds = event.recordingStats.recordedDurationNanos / 1_000_000_000
    // Update an on-screen timer.
}

Interrompendo a gravação

Para finalizar, chame stop() no Recording que você salvou anteriormente. Isso dispara um evento Finalize, no qual o URI do vídeo fica disponível.

Mantenha a gravação ativa no estado para que um único botão possa alternar entre iniciar e interromper.

var activeRecording: Recording? = null

// Toggle handler:
if (activeRecording == null) {
    activeRecording = startRecording()
} else {
    activeRecording?.stop()
    activeRecording = null
}

Pausar e retomar

Um Recording também pode ser pausado e retomado sem ser interrompido. Isso é útil para permitir que os usuários juntem clipes em um único arquivo.

activeRecording?.pause()
// ...later
activeRecording?.resume()
// Final stop writes the file:
activeRecording?.stop()

Interface do Compose para gravação

Controle a interface a partir do estado. Acompanhe se há uma gravação ativa e altere o ícone e a ação do botão conforme necessário. Como o listener é executado no executor principal, você pode atualizar o estado do Compose diretamente a partir dele.

var isRecording by remember { mutableStateOf(false) }

IconButton(onClick = { toggleRecording() }) {
    Icon(
        imageVector = if (isRecording) Icons.Default.Stop else Icons.Default.Videocam,
        contentDescription = if (isRecording) "Stop" else "Record"
    )
}

Verificação rápida

Confirme que você compreende a gravação de vídeos com CameraX.

Recapitulação

Agora você pode gravar vídeos com CameraX:

Crie um Recorder com um QualitySelector e envolva-o em VideoCapture.withOutput.
Vincule-o à visualização e solicite RECORD_AUDIO para gravar o som.
Salve usando MediaStoreOutputOptions e, em seguida, use prepareRecording().start() para obter um Recording.
Reaja aos VideoRecordEvent; chame stop() para finalizar e leia o URI salvo.

Você concluiu o curso de CameraX — visualização, fotos e vídeos agora fazem parte do seu conjunto de ferramentas.

Perguntas Frequentes

A aula “Gravando vídeo” é grátis?

Sim — o texto completo de “Gravando vídeo” é 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 “Gravando vídeo”?

Capture vídeo com CameraX. 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 4 de 4.

Quanto tempo leva a aula “Gravando vídeo”?

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