Android Academy · Lezione

Panoramica di CameraX

Scopra perché preferire CameraX alle vecchie API della fotocamera

Panoramica di CameraX è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Perché CameraX?

Aggiungere una fotocamera a un'app Android era un'operazione complessa. La vecchia API android.hardware.camera2 è potente, ma estremamente prolissa e si comporta in modo diverso sulle migliaia di dispositivi disponibili.

CameraX è una libreria Jetpack che si basa su Camera2 e offre un'API semplice, coerente e consapevole del ciclo di vita. In questo corso utilizzerà CameraX per mostrare un'anteprima dal vivo, scattare foto e registrare video.

Che cosa risolve CameraX

CameraX è stato progettato intorno a tre obiettivi:

Semplicità d'uso — molto meno codice ripetitivo rispetto a Camera2.
Coerenza — Google lo testa su un ampio laboratorio di dispositivi, così anche quelli più problematici si comportano in modo prevedibile.
Consapevolezza del ciclo di vita — la fotocamera si avvia e si arresta automaticamente in base al ciclo di vita della schermata, evitando di lasciarla attiva involontariamente.

Descriva che cosa desidera (un'anteprima, una foto o un video) e CameraX determinerà come realizzarlo sul dispositivo in uso.

I tre casi d'uso principali

CameraX si basa sui casi d'uso. Un caso d'uso è una funzionalità della fotocamera autonoma. I tre principali sono:

Preview — mostra sullo schermo ciò che vede la fotocamera.
ImageCapture — scatta una foto.
VideoCapture — registra un video.

Crei i casi d'uso necessari e li associ alla fotocamera.

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

Aggiunta delle dipendenze

CameraX viene distribuito come diversi artifact. Li aggiunga al file build.gradle.kts del modulo. Una configurazione tipica include la libreria principale, il backend camera2, l'integrazione con il ciclo di vita e gli strumenti per le viste.

Mantenga tutti gli artifact di CameraX sulla stessa versione per evitare conflitti.

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")
}

Dichiarazione delle autorizzazioni

Per usare la fotocamera deve dichiarare l'autorizzazione CAMERA nel file AndroidManifest.xml. Se registra anche video, potrebbe aver bisogno di RECORD_AUDIO.

Si tratta di autorizzazioni a runtime: dichiararle non è sufficiente; deve anche richiederle durante l'esecuzione (come spiegato nelle lezioni successive).

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

Il CameraProvider

Il punto di accesso a CameraX è ProcessCameraProvider. Questo collega i casi d'uso alla fotocamera e al ciclo di vita della schermata.

Lo ottenga in modo asincrono con getInstance(), che restituisce un ListenableFuture. Da Kotlin può usare await() al suo interno in una coroutine.

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

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

Associazione dei casi d'uso a un ciclo di vita

Una volta ottenuto il provider, associ i casi d'uso a un LifecycleOwner e a un CameraSelector (fotocamera anteriore o posteriore).

Poiché l'associazione tiene conto del ciclo di vita, CameraX apre automaticamente la fotocamera quando la schermata è visibile e la chiude quando non lo è: non è necessaria alcuna pulizia manuale.

val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

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

Scelta della fotocamera

Un CameraSelector indica a CameraX quale fotocamera fisica usare. Le due più comuni sono la fotocamera posteriore predefinita e quella anteriore predefinita.

Può anche creare un selettore personalizzato per richiedere caratteristiche specifiche, ma le impostazioni predefinite sono adatte a quasi tutte le app.

// 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: la superficie di visualizzazione

CameraX esegue il rendering dell'anteprima dal vivo in una PreviewView. È una normale View Android che gestisce automaticamente superficie, ridimensionamento e rotazione.

In Jetpack Compose la incorpori con AndroidView, che consente di inserire una View classica all'interno di un composable. Completerà questa configurazione nella prossima lezione.

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

Il ciclo di vita in azione

Il principale vantaggio pratico di CameraX è la consapevolezza del ciclo di vita. Con Camera2 doveva aprire manualmente la fotocamera in onResume e rilasciarla in onPause; dimenticare di farlo causava arresti anomali o lasciava la fotocamera bloccata.

Con CameraX, dopo aver usato bindToLifecycle, il framework gestisce tutto questo. Quando l'utente cambia schermata, la fotocamera viene rilasciata automaticamente; quando torna indietro, viene riaperta.

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

Il modello mentale

Tenga presente questo schema per il resto del corso:

Ottenga un ProcessCameraProvider.
Crei i casi d'uso necessari (Preview, ImageCapture, VideoCapture).
Scelga un CameraSelector.
Usi bindToLifecycle per collegare tutto.

Ogni funzionalità di CameraX è semplicemente una variante di questi quattro passaggi.

Verifica rapida

Verifichi la Sua comprensione dei fondamenti di CameraX.

Riepilogo

Ora conosce il quadro generale di CameraX:

CameraX racchiude Camera2 in un'API più semplice, coerente e consapevole del ciclo di vita.
Si basa sui casi d'uso: Preview, ImageCapture e VideoCapture.
Aggiunga gli artifact di CameraX, dichiari l'autorizzazione CAMERA, ottenga un ProcessCameraProvider e usi bindToLifecycle.
Un CameraSelector sceglie la fotocamera anteriore o posteriore, mentre una PreviewView mostra il flusso.

Nella prossima lezione configurerà una vera anteprima dal vivo sullo schermo.

Domande Frequenti

La lezione «Panoramica di CameraX» è gratuita?

Sì — il testo completo di «Panoramica di CameraX» è 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 «Panoramica di CameraX»?

Scopra perché preferire CameraX alle vecchie API della fotocamera 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 1 di 4.

Quanto tempo richiede la lezione «Panoramica di CameraX»?

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