Camera în dezvoltarea mobilă: ce este, tipuri de API și cum se utilizează

Ce este camera în aplicațiile mobile

Camera mobilă — este un modul optic integrat format din obiectiv, matrice (senzor) și procesor de procesare a imaginii (ISP). Dezvoltatorul obține acces la cameră prin sistemul de operare cu ajutorul unor framework-uri speciale. Pe Android acestea sunt Camera2 API (de nivel scăzut) și CameraX (de nivel înalt bazat pe Camera2), pe iOS — AVFoundation și UIKit pentru scenarii simple. Fiecare platformă oferă propriul set de instrumente, dar conceptul general este același: aplicația inițializează o sesiune de captare, configurează parametrii (rezoluție, focalizare, expunere) și primește un flux de cadre sau imagini individuale.

Capabilitățile hardware ale camerelor moderne

Camerele mobile moderne suportă multiple moduri de fotografiere: HDR, modul noapte, portret cu estomparea fundalului, mișcare lentă și înregistrare în format RAW. Pentru dezvoltator sunt disponibile setări software: ISO (sensibilitatea matricei), timp de expunere, balans de alb, focalizare (automată și manuală) și stabilizare a imaginii. Pe dispozitivele flagship sunt disponibile până la 4 camere cu distanțe focale diferite, iar aplicația poate selecta o cameră specifică după ID.

Tipuri de API pentru lucrul cu camera

Pe platformele mobile există mai multe API-uri pentru lucrul cu camera, care diferă prin nivelul de abstractizare și funcționalitate. Alegerea unui API specific depinde de cerințele proiectului: pentru captarea simplă a fotografiilor este suficient CameraX sau UIImagePickerController, pentru aplicații profesionale este necesar Camera2 sau AVFoundation cu control direct al senzorului. Mai jos este prezentată o comparație a API-urilor principale.

Când să alegeți CameraX

CameraX — alegerea optimă pentru majoritatea aplicațiilor Android care au nevoie de cameră fără personalizare avansată. Biblioteca gestionează automat ciclul de viață al Activity și Fragment, suportă permisiunile și compatibilitatea cu diferite versiuni Android. CameraX garantează același comportament pe 95% din dispozitivele Android datorită stratului de compatibilitate. Dacă este necesară previzualizarea camerei (Preview), captura foto (ImageCapture) sau analiza fluxului (ImageAnalysis) — CameraX se descurcă cu toate cele trei scenarii fără a scrie cod complex.

Când să alegeți Camera2

Camera2 — API de nivel scăzut pentru scenarii profesionale: înregistrare RAW, reglare manuală a expunerii, fotografiere în rafală (burst), gestionarea simultană a mai multor camere. Camera2 necesită de la dezvoltator o înțelegere profundă a pipeline-ului de captare a imaginilor, gestionarea StateMachine și procesarea callback-urilor. Utilizați Camera2 numai dacă CameraX nu acoperă cerințele: de exemplu, pentru aplicații de scanare a documentelor cu focalizare manuală sau camere personalizate cu rezoluție non-standard.

Solicitarea permisiunilor de acces la cameră

Accesul la cameră necesită acordul explicit al utilizatorului pe ambele platforme. Pe Android se adaugă permisiunea CAMERA în manifest, iar începând cu Android 6.0 este necesară și solicitarea permisiunii în timpul execuției prin ActivityCompat.requestPermissions. Pe iOS se adaugă cheia NSCameraUsageDescription în Info.plist cu o descriere a motivului utilizării camerei. Fără această descriere, aplicația se va bloca la încercarea de a accesa camera. Începând cu iOS 14, în dialogul de permisiuni se afișează nu doar numele aplicației, ci și motivul indicat — formularea trebuie să fie ușor de înțeles pentru utilizator.

Implementare pe Android cu CameraX

CameraX simplifică lucrul cu camera la câteva linii de cod. Pentru a porni previzualizarea, trebuie creată o instanță Preview, legată de LifecycleOwner și obținut un SurfaceProvider pentru afișare. Pentru captarea fotografiilor se utilizează ImageCapture cu o țintă de salvare. Mai jos este un exemplu complet de pornire a camerei și realizare a fotografiilor cu CameraX în Kotlin.

Configurarea Preview și 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", "Eroare de legare", e)
    }
}, ContextCompact.getMainExecutor(this))

Metoda bindToLifecycle leagă camera de ciclul de viață al Activity — la rotirea ecranului sau trecerea în fundal, camera este eliberată automat. CameraSelector.DEFAULT_BACK_CAMERA selectează camera din spate, pentru cea frontală se utilizează DEFAULT_FRONT_CAMERA. După legare, Preview începe să afișeze imaginea de la cameră în PreviewView, iar utilizatorul vede imaginea camerei pe ecran.

Captarea fotografiei

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", "Eroare de captură", exception)
        }
    }
)

Metoda takePicture realizează captura unui cadru de la cameră și îl salvează într-un fișier. OutputFileOptions suportă salvarea în File, ContentResolver și MediaStore. În callback-ul onImageSaved, aplicația primește o notificare despre salvarea reușită și poate actualiza UI. CAPTURE_MODE_MINIMIZE_LATENCY asigură viteza maximă de declanșare prin reducerea post-procesării.

Implementare pe iOS cu AVFoundation

Pe iOS, accesul la cameră este oferit de framework-ul AVFoundation prin clasa AVCaptureSession. Dezvoltatorul creează o sesiune de captare, adaugă intrările necesare (AVCaptureDeviceInput) și ieșirile (AVCapturePhotoOutput, AVCaptureVideoDataOutput) și pornește sesiunea. Pentru afișarea previzualizării se utilizează AVCaptureVideoPreviewLayer. Mai jos este un exemplu de configurare a sesiunii pentru captarea fotografiilor în 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 setează rezoluția optimă pentru fotografie (de obicei 12 MP pe dispozitivele moderne). Intrarea este AVCaptureDeviceInput creat pentru camera dispozitivului. După adăugarea intrării și ieșirii, sesiunea este pornită într-un thread de fundal prin startRunning — pornirea sesiunii poate dura până la 200 ms pe dispozitivele mai vechi. Pentru captarea fotografiei se apelează capturePhoto(with:delegate:), iar rezultatul este returnat prin delegatul AVCapturePhotoCaptureDelegate.

Caracteristici și limitări

La lucrul cu camera pe dispozitive mobile trebuie luate în considerare limitările hardware: încălzirea dispozitivului la fotografierea prelungită, descărcarea bateriei la lucrul cu rezoluție înaltă și calitatea diferită a camerelor pe diferite dispozitive. Pe Android, fragmentarea ecosistemului face ca aceeași configurație CameraX să funcționeze diferit pe diferite modele. Pe iOS, limitările se referă în principal la licențiere: utilizarea camerei în fundal necesită o permisiune separată de la Apple. De asemenea, este important de reținut că simulatoarele nu au acces la o cameră reală — testarea este posibilă doar pe un dispozitiv fizic.

Compatibilitatea cu diferite versiuni de sistem de operare

CameraX rezolvă problema fragmentării Android prin stratul de compatibilitate CameraXConfig — biblioteca aplică automat soluții de ocolire pentru bug-urile cunoscute ale producătorilor. Pe iOS, AVFoundation funcționează uniform pe toate dispozitivele începând cu iOS 6, dar unele funcții (de exemplu, Portrait Mode sau LiDAR) sunt disponibile doar pe modelele iPhone 12 și mai noi. La dezvoltarea unei aplicații cross-platform, se recomandă utilizarea Flutter sau React Native cu pluginuri de cameră — acestea abstractizează diferențele de platformă și oferă un API unificat pentru ambele sisteme de operare.