Kamera mobilfejlesztésben: mi ez, API-típusok és hogyan használható

Mi a kamera mobilalkalmazásokban

A mobil kamera — egy beépített optikai modul, amely lencséből, mátrixból (érzékelőből) és képfeldolgozó processzorból (ISP) áll. A fejlesztő speciális keretrendszereken keresztül az operációs rendszeren át éri el a kamerát. Androidon ez a Camera2 API (alacsony szintű) és a CameraX (magas szintű, a Camera2-re épülő), iOS-en az AVFoundation és az UIKit egyszerű forgatókönyvekhez. Minden platform saját eszközkészletet biztosít, de az általános koncepció ugyanaz: az alkalmazás inicializál egy rögzítési munkamenetet, beállítja a paramétereket (felbontás, fókusz, expozíció), és képkockák vagy egyedi képek adatfolyamát kapja.

A modern kamerák hardveres képességei

A modern mobil kamerák számos módot támogatnak: HDR, éjszakai mód, portré háttér elmosással, lassított felvétel és RAW formátumú rögzítés. A fejlesztő számára szoftveres beállítások állnak rendelkezésre: ISO (mátrix érzékenysége), záridő (expozíció), fehéregyensúly, fókusz (automatikus és kézi) és képstabilizálás. A zászlóshajó eszközökön akár 4 kamera is elérhető különböző gyújtótávolságokkal, és az alkalmazás ID alapján választhat ki egy adott kamerát.

API-típusok a kamerával való munkához

A mobil platformokon több API létezik a kamerával való munkához, amelyek az absztrakciós szintben és funkcionalitásban különböznek. Az adott API kiválasztása a projekt követelményeitől függ: egyszerű fotókészítéshez elegendő a CameraX vagy UIImagePickerController, professzionális alkalmazásokhoz a Camera2 vagy az AVFoundation szükséges közvetlen érzékelő-vezérléssel. Az alábbiakban a fő API-k összehasonlítása látható.

Mikor válasszuk a CameraX-et

CameraX — optimális választás a legtöbb Android-alkalmazáshoz, amelyek mély testreszabás nélkül igényelnek kamerát. A könyvtár automatikusan kezeli az Activity és Fragment életciklusát, támogatja az engedélyeket és a kompatibilitást a különböző Android-verziókkal. A CameraX a kompatibilitási rétegnek köszönhetően az Android-eszközök 95%-án garantálja az azonos viselkedést. Ha kamera előnézetre (Preview), fotókészítésre (ImageCapture) vagy adatfolyam-elemzésre (ImageAnalysis) van szükség — a CameraX mindhárom forgatókönyvet képes kezelni összetett kód írása nélkül.

Mikor válasszuk a Camera2-t

Camera2 — alacsony szintű API professzionális forgatókönyvekhez: RAW felvétel, kézi expozícióbeállítás, sorozatfelvétel (burst), több kamera egyidejű vezérlése. A Camera2 a fejlesztőtől a képrögzítési csővezeték, a StateMachine kezelés és a callback-ek feldolgozásának mély megértését követeli meg. Csak akkor használja a Camera2-t, ha a CameraX nem fedezi a követelményeket: például kézi fókuszú dokumentum szkennelő alkalmazásokhoz vagy nem szabványos felbontású egyedi kamerákhoz.

Kamerához való hozzáférési engedélyek kérése

A kamerához való hozzáférés mindkét platformon kifejezett felhasználói hozzájárulást igényel. Androidon a CAMERA engedélyt hozzá kell adni a manifest fájlhoz, és Android 6.0-tól kezdve az engedélyt futásidőben is kérni kell az ActivityCompat.requestPermissions segítségével. iOS-en az NSCameraUsageDescription kulcsot kell hozzáadni az Info.plist fájlhoz a kamera használatának okának leírásával. E leírás nélkül az alkalmazás összeomlik a kamera elérésére tett kísérletkor. iOS 14-től kezdve az engedély párbeszédpanel nemcsak az alkalmazás nevét, hanem a megadott okot is megjeleníti — a megfogalmazásnak érthetőnek kell lennie a felhasználó számára.

Implementáció Androidon CameraX-szel

CameraX néhány sornyi kódra egyszerűsíti a kamerával való munkát. Az előnézet elindításához létre kell hozni egy Preview példányt, hozzá kell kötni a LifecycleOwner-hez, és le kell kérni a SurfaceProvider-t a megjelenítéshez. A fotók rögzítéséhez az ImageCapture használatos mentési céllal. Az alábbiakban egy teljes példa látható a kamera elindítására és fényképek készítésére a CameraX-szel Kotlinban.

Preview és ImageCapture konfiguráció

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", "Kötés sikertelen", e)
    }
}, ContextCompact.getMainExecutor(this))

A bindToLifecycle metódus a kamerát az Activity életciklusához köti — képernyőelforgatáskor vagy háttérbe lépéskor a kamera automatikusan felszabadul. A CameraSelector.DEFAULT_BACK_CAMERA a hátsó kamerát választja ki, az elülsőhöz a DEFAULT_FRONT_CAMERA használatos. A kötés után a Preview megkezdi a kamera képének megjelenítését a PreviewView-ban, és a felhasználó látja a kamera képét a képernyőn.

Fotó rögzítése

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", "Rögzítési hiba", exception)
        }
    }
)

A takePicture metódus rögzít egy képkockát a kameráról, és elmenti egy fájlba. Az OutputFileOptions támogatja a File, ContentResolver és MediaStore mentést. Az onImageSaved callback-ben az alkalmazás értesítést kap a sikeres mentésről, és frissítheti a felhasználói felületet. A CAPTURE_MODE_MINIMIZE_LATENCY a maximális zársebességet biztosítja az utófeldolgozás csökkentésével.

Implementáció iOS-en AVFoundation-nal

iOS-en a kamerához való hozzáférést az AVFoundation keretrendszer biztosítja az AVCaptureSession osztályon keresztül. A fejlesztő létrehoz egy rögzítési munkamenetet, hozzáadja a szükséges bemeneteket (AVCaptureDeviceInput) és kimeneteket (AVCapturePhotoOutput, AVCaptureVideoDataOutput), és elindítja a munkamenetet. Az előnézet megjelenítéséhez az AVCaptureVideoPreviewLayer használatos. Az alábbiakban egy példa látható a munkamenet konfigurálására fotók rögzítéséhez Swiftben.

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 beállítja az optimális felbontást a fotókhoz (általában 12 MP a modern eszközökön). A bemenet az eszköz kamerájához létrehozott AVCaptureDeviceInput. A bemenet és kimenet hozzáadása után a munkamenet a startRunning segítségével egy háttérszálon indul el — a munkamenet elindítása akár 200 ms-ig is tarthat régebbi eszközökön. A fotó rögzítéséhez a capturePhoto(with:delegate:) hívódik meg, és az eredmény az AVCapturePhotoCaptureDelegate delegált segítségével érkezik vissza.

Jellemzők és korlátozások

A kamerával mobil eszközökön végzett munka során figyelembe kell venni a hardveres korlátozásokat: az eszköz felmelegedése hosszú fotózás során, az akkumulátor lemerülése nagy felbontású munka esetén, valamint a kamerák eltérő minősége a különböző eszközökön. Androidon az ökoszisztéma fragmentációja ahhoz vezet, hogy ugyanaz a CameraX-konfiguráció eltérően működhet a különböző modelleken. iOS-en a korlátozások főként a licencelésre vonatkoznak: a kamera háttérben történő használatához külön Apple-engedély szükséges. Azt is fontos megjegyezni, hogy a szimulátorok nem férnek hozzá valódi kamerához — a tesztelés csak fizikai eszközön lehetséges.

Kompatibilitás különböző operációs rendszer verziókkal

CameraX a CameraXConfig kompatibilitási rétegen keresztül oldja meg az Android fragmentáció problémáját — a könyvtár automatikusan alkalmazza a gyártók ismert hibáinak megkerülő megoldásait. iOS-en az AVFoundation egységesen működik minden eszközön iOS 6-tól kezdve, de egyes funkciók (például Portrait Mode vagy LiDAR) csak iPhone 12 modelleken és újabbakon érhetők el. Többplatformos alkalmazás fejlesztésekor ajánlott a Flutter vagy React Native használata kamera plugin-ekkel — ezek elvonatkoztatják a platform különbségeket és egységes API-t biztosítanak mindkét operációs rendszer számára.