Fotocamera nello sviluppo mobile: cos'è, tipi di API e come usarla

Cos'è una fotocamera nelle applicazioni mobili

Una fotocamera mobile è un modulo ottico integrato composto da un obiettivo, un sensore di immagine e un processore di segnale immagine (ISP). Lo sviluppatore accede alla fotocamera tramite il sistema operativo utilizzando framework specializzati. Su Android, questi sono Camera2 API (basso livello) e CameraX (alto livello, basato su Camera2), e su iOS — AVFoundation e UIKit per scenari semplici. Ogni piattaforma fornisce il proprio set di strumenti, ma il concetto generale è lo stesso: l'applicazione inizializza una sessione di acquisizione, configura i parametri (risoluzione, messa a fuoco, esposizione) e riceve un flusso di fotogrammi o immagini singole.

Capacità hardware delle fotocamere moderne

Le fotocamere mobili moderne supportano molte modalità di scatto: HDR, modalità notturna, ritratto con sfocatura dello sfondo, video al rallentatore e registrazione in formato RAW. Lo sviluppatore ha accesso alle impostazioni software: ISO (sensibilità del sensore), velocità dell'otturatore (esposizione), bilanciamento del bianco, messa a fuoco (automatica e manuale) e stabilizzazione dell'immagine. I dispositivi flagship possono avere fino a 4 fotocamere con diverse lunghezze focali e l'applicazione può selezionare una fotocamera specifica per ID.

Tipi di API per lavorare con la fotocamera

Le piattaforme mobili offrono diverse API per lavorare con la fotocamera, che variano per livello di astrazione e funzionalità. La scelta di un'API specifica dipende dai requisiti del progetto: per la semplice acquisizione di foto, CameraX o UIImagePickerController è sufficiente; per applicazioni professionali, è necessario Camera2 o AVFoundation con controllo diretto del sensore. Di seguito è riportato un confronto delle principali API.

Quando scegliere CameraX

CameraX è la scelta ottimale per la maggior parte delle applicazioni Android che necessitano di una fotocamera senza personalizzazione approfondita. La libreria gestisce automaticamente il ciclo di vita di Activity e Fragment, supporta le autorizzazioni e garantisce la compatibilità tra diverse versioni di Android. CameraX garantisce un comportamento coerente sul 95% dei dispositivi Android grazie al suo livello di compatibilità. Se hai bisogno di anteprima della fotocamera (Preview), acquisizione foto (ImageCapture) o analisi dei fotogrammi (ImageAnalysis) — CameraX gestisce tutti e tre gli scenari senza scrivere codice complesso.

Quando scegliere Camera2

Camera2 è un'API di basso livello per scenari professionali: registrazione RAW, regolazione manuale dell'esposizione, acquisizione burst e controllo simultaneo di più fotocamere. Camera2 richiede che lo sviluppatore abbia una profonda comprensione della pipeline di acquisizione immagini, della gestione della StateMachine e della gestione dei callback. Usa Camera2 solo se CameraX non copre i requisiti: ad esempio, applicazioni di scansione documenti con messa a fuoco manuale o fotocamere personalizzate con risoluzione non standard.

Richiesta di autorizzazioni per la fotocamera

L'accesso alla fotocamera richiede l'autorizzazione esplicita dell'utente su entrambe le piattaforme. Su Android, l'autorizzazione CAMERA viene aggiunta al manifest e, a partire da Android 6.0, l'autorizzazione deve essere richiesta anche in fase di esecuzione tramite ActivityCompat.requestPermissions. Su iOS, la chiave NSCameraUsageDescription viene aggiunta a Info.plist con una descrizione del motivo dell'utilizzo della fotocamera. Senza questa descrizione, l'applicazione si bloccherà quando tenta di accedere alla fotocamera. A partire da iOS 14, il dialogo delle autorizzazioni mostra non solo il nome dell'applicazione ma anche il motivo specificato — la formulazione deve essere chiara per l'utente.

Implementazione su Android con CameraX

CameraX semplifica il lavoro con la fotocamera a poche righe di codice. Per avviare un'anteprima, è necessario creare un'istanza di Preview, collegarla a un LifecycleOwner e ottenere un SurfaceProvider per la visualizzazione. Per l'acquisizione di foto, viene utilizzato ImageCapture con una destinazione di salvataggio. Di seguito è riportato un esempio completo di avvio della fotocamera e scatto di una foto utilizzando CameraX in Kotlin.

Configurazione di 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", "Associazione fallita", e)
    }
}, ContextCompact.getMainExecutor(this))

Il metodo bindToLifecycle collega la fotocamera al ciclo di vita dell'Activity — quando lo schermo ruota o l'applicazione va in background, la fotocamera viene automaticamente rilasciata. CameraSelector.DEFAULT_BACK_CAMERA seleziona la fotocamera posteriore; per la fotocamera anteriore, viene utilizzato DEFAULT_FRONT_CAMERA. Dopo il collegamento, Preview inizia a mostrare il flusso della fotocamera in PreviewView e l'utente vede l'immagine della fotocamera sullo schermo.

Scatto di una 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", "Errore di acquisizione", exception)
        }
    }
)

Il metodo takePicture cattura un fotogramma dalla fotocamera e lo salva in un file. OutputFileOptions supporta la scrittura su File, ContentResolver e MediaStore. Nel callback onImageSaved, l'applicazione riceve una notifica di salvataggio riuscito e può aggiornare l'interfaccia utente. CAPTURE_MODE_MINIMIZE_LATENCY garantisce la massima velocità dell'otturatore riducendo la post-elaborazione.

Implementazione su iOS con AVFoundation

Su iOS, l'accesso alla fotocamera è fornito dal framework AVFoundation tramite la classe AVCaptureSession. Lo sviluppatore crea una sessione di acquisizione, aggiunge gli input necessari (AVCaptureDeviceInput) e gli output (AVCapturePhotoOutput, AVCaptureVideoDataOutput) e avvia la sessione. AVCaptureVideoPreviewLayer viene utilizzato per visualizzare l'anteprima. Di seguito è riportato un esempio di configurazione di una sessione per l'acquisizione di foto in 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 imposta la risoluzione ottimale per le foto (solitamente 12 MP sui dispositivi moderni). L'input è un AVCaptureDeviceInput creato per la fotocamera del dispositivo. Dopo aver aggiunto input e output, la sessione viene avviata su un thread in background tramite startRunning — l'avvio della sessione può richiedere fino a 200 ms sui dispositivi più vecchi. Per scattare una foto, viene chiamato capturePhoto(with:delegate:) e il risultato viene restituito tramite AVCapturePhotoCaptureDelegate.

Caratteristiche e limitazioni

Quando si lavora con la fotocamera su dispositivi mobili, è necessario considerare le limitazioni hardware: riscaldamento del dispositivo durante la registrazione prolungata, consumo della batteria quando si lavora ad alta risoluzione e qualità della fotocamera variabile su diversi dispositivi. Su Android, la frammentazione dell'ecosistema significa che la stessa configurazione di CameraX può comportarsi in modo diverso su modelli differenti. Su iOS, le limitazioni riguardano principalmente le licenze: l'uso della fotocamera in background richiede un'autorizzazione speciale da Apple. È anche importante ricordare che i simulatori non hanno accesso a una fotocamera reale — i test sono possibili solo su un dispositivo fisico.

Compatibilità con diverse versioni del sistema operativo

CameraX risolve il problema della frammentazione di Android attraverso il livello di compatibilità CameraXConfig — la libreria applica automaticamente soluzioni alternative per bug noti dei produttori. Su iOS, AVFoundation funziona in modo uniforme su tutti i dispositivi a partire da iOS 6, ma alcune funzionalità (come la Modalità Ritratto o LiDAR) sono disponibili solo su iPhone 12 e modelli successivi. Quando si sviluppa un'applicazione multipiattaforma, si consiglia di utilizzare Flutter o React Native con plugin per la fotocamera — essi astraggono le differenze di piattaforma e forniscono un'API unificata per entrambi i sistemi operativi.