Android Academy · Lezione

Registrare video

Acquisisca video con CameraX

Lezione 4 di 413 passaggi

Registrare video è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 4 lezioni in totale.

Registrare video con CameraX

CameRX registra video tramite il caso d'uso VideoCapture, basato su un Recorder. In questa lezione configurerà l'acquisizione video, avvierà e fermerà una registrazione e la salverà nella galleria, incluso l'audio.

Il flusso è simile a quello delle foto, ma aggiunge una sessione Recording di lunga durata, che viene avviata e poi fermata.

Recorder e qualità

Per prima cosa crei un Recorder, che definisce codifica e qualità. QualitySelector consente di richiedere una qualità target (ad esempio HD o FHD), con un'alternativa nel caso in cui il dispositivo non possa fornirla.

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

Creare VideoCapture

Racchiuda il Recorder in un caso d'uso VideoCapture usando la factory withOutput. Questo è l'oggetto da associare alla fotocamera, proprio come ImageCapture.

val videoCapture = VideoCapture.withOutput(recorder)

Associare anteprima e VideoCapture

Associ insieme l'anteprima e VideoCapture. Tenga presente che su molti dispositivi non è possibile associare contemporaneamente ImageCapture e VideoCapture; scelga quindi i casi d'uso necessari alla schermata.

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

Autorizzazione per l'audio

Per registrare l'audio è necessaria l'autorizzazione di runtime RECORD_AUDIO, oltre a CAMERA. Richieda entrambe prima di avviare una registrazione e abiliti l'audio solo se l'utente lo ha autorizzato.

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

Output tramite MediaStore

Come per le foto, salvi il video in MediaStore usando lo scoped storage. Crei ContentValues con un tipo MIME mp4 e crei 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()

Avviare una registrazione

Prepari la registrazione dal recorder, abiliti facoltativamente l'audio con withAudioEnabled(), quindi la avvii con start(). start() restituisce un oggetto Recording da conservare per poterlo fermare in seguito.

Passi anche un listener che riceve gli aggiornamenti 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
                }
            }
        }
    }

Reagire agli eventi di registrazione

Il listener trasmette il ciclo di vita della registrazione:

VideoRecordEvent.Start — la registrazione è iniziata (aggiorni l'interfaccia mostrando un pulsante di arresto).
VideoRecordEvent.Status — aggiornamenti periodici sulla durata e sulle dimensioni registrate.
VideoRecordEvent.Finalize — la registrazione è terminata; verifichi hasError().

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

Fermare la registrazione

Per terminare, chiami stop() sull'oggetto Recording salvato in precedenza. Questo attiva un evento Finalize, nel quale l'URI del video diventa disponibile.

Conservi la registrazione attiva nello state, così un unico pulsante può alternare avvio e arresto.

var activeRecording: Recording? = null

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

Mettere in pausa e riprendere

Un Recording può anche essere messo in pausa e ripreso senza essere fermato. È utile per consentire agli utenti di unire più clip in un unico file.

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

Interfaccia Compose per la registrazione

Faccia dipendere l'interfaccia dallo state. Tenga traccia del fatto che una registrazione sia attiva e sostituisca di conseguenza l'icona e l'azione del pulsante. Poiché il listener viene eseguito sul main executor, può aggiornare direttamente lo state di Compose.

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 rapida

Verifichi di aver compreso la registrazione video con CameraX.

Rispondi nella lezione interattiva

Riepilogo

Ora può registrare video con CameraX:

Crei un Recorder con un QualitySelector e lo racchiuda in VideoCapture.withOutput.
Lo associ all'anteprima e richieda RECORD_AUDIO per registrare l'audio.
Salvi tramite MediaStoreOutputOptions, quindi usi prepareRecording().start() per ottenere un Recording.
Reagisca agli eventi VideoRecordEvent; chiami stop() per finalizzare la registrazione e legga l'URI salvato.

Ha completato il corso su CameraX: anteprima, foto e video sono ora tutti a sua disposizione.

Gratis per iniziare

Impara Kotlin con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 36
Lezioni: 152

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Registrare video» è gratuita?

Sì — il testo completo di «Registrare video» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 4 lezioni in totale.

Cosa imparerò in «Registrare video»?

Acquisisca video con CameraX Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Android Academy?

Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Registrare video»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Android Academy?

Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Android Academy