Kamera sa Mobile Development: ano ito, mga uri ng API at kung paano gamitin

Ano ang kamera sa mga mobile application

Ang mobile kamera — ay isang built-in na optical module na binubuo ng lens, matrix (sensor) at image processing processor (ISP). Ang developer ay nakakakuha ng access sa kamera sa pamamagitan ng operating system gamit ang mga espesyal na framework. Sa Android, ito ay Camera2 API (mababang antas) at CameraX (mataas na antas batay sa Camera2), sa iOS — AVFoundation at UIKit para sa mga simpleng sitwasyon. Ang bawat platform ay nagbibigay ng sarili nitong set ng mga tool, ngunit ang pangkalahatang konsepto ay pareho: ang application ay nag-initialize ng capture session, nag-configure ng mga parameter (resolution, focus, exposure) at tumatanggap ng stream ng mga frame o indibidwal na mga imahe.

Hardware capabilities ng modernong kamera

Ang modernong mobile camera ay sumusuporta sa maraming mode ng pagkuha: HDR, night mode, portrait na may blur na background, slow motion at pag-record sa RAW format. Para sa developer, available ang software settings: ISO (sensitivity ng matrix), exposure time, white balance, focus (awtomatiko at manwal) at image stabilization. Sa flagship device, available ang hanggang 4 na camera na may iba't ibang focal length, at maaaring pumili ang application ng partikular na camera ayon sa ID.

Mga uri ng API para sa paggamit ng kamera

Sa mga mobile platform, may ilang API para sa paggamit ng kamera na nagkakaiba sa antas ng abstraction at functionality. Ang pagpili ng partikular na API ay nakadepende sa mga kinakailangan ng proyekto: para sa simpleng pagkuha ng photo, sapat na ang CameraX o UIImagePickerController, para sa propesyonal na application, kailangan ang Camera2 o AVFoundation na may direktang kontrol ng sensor. Nasa ibaba ang paghahambing ng mga pangunahing API.

Kailan pumili ng CameraX

CameraX — pinakamainam na pagpili para sa karamihan ng Android application na nangangailangan ng kamera nang walang malalim na pag-customize. Awtomatikong pinamamahalaan ng library ang lifecycle ng Activity at Fragment, sumusuporta sa mga pahintulot at compatibility sa iba't ibang bersyon ng Android. Ginagarantiya ng CameraX ang parehong pag-uugali sa 95% ng Android device salamat sa compatibility layer. Kung kinakailangan ang preview ng kamera (Preview), pagkuha ng photo (ImageCapture) o stream analysis (ImageAnalysis) — kayang hawakan ng CameraX ang lahat ng tatlong sitwasyon nang hindi nagsusulat ng kumplikadong code.

Kailan pumili ng Camera2

Camera2 — mababang antas na API para sa propesyonal na sitwasyon: pag-record sa RAW, manwal na setting ng exposure, burst photography, sabay-sabay na pamamahala ng maraming camera. Ang Camera2 ay nangangailangan ng malalim na pag-unawa ng developer sa image capture pipeline, pamamahala ng StateMachine at pagproseso ng callback. Gamitin ang Camera2 lamang kung hindi natutugunan ng CameraX ang mga kinakailangan: halimbawa, para sa document scanning application na may manwal na focus o custom camera na may hindi standard na resolution.

Paghiling ng mga pahintulot sa pag-access ng kamera

Ang pag-access sa kamera ay nangangailangan ng tahasang pahintulot ng gumagamit sa parehong platform. Sa Android, ang CAMERA permission ay idinaragdag sa manifest, at simula sa Android 6.0, kinakailangan din hilingin ang pahintulot sa runtime sa pamamagitan ng ActivityCompat.requestPermissions. Sa iOS, ang key na NSCameraUsageDescription na may paglalarawan ng dahilan ng paggamit ng kamera ay idinaragdag sa Info.plist. Kung wala ang paglalarawang ito, ang application ay mag-crash kapag sinusubukang i-access ang kamera. Simula sa iOS 14, sa dialog ng pahintulot, hindi lamang ang pangalan ng application kundi pati na rin ang ibinigay na dahilan ay ipinapakita — ang pormulasyon ay dapat na nauunawaan ng gumagamit.

Implementasyon sa Android gamit ang CameraX

CameraX ay pinapasimple ang paggamit ng kamera sa ilang linya ng code. Upang simulan ang preview, kailangan lumikha ng instance ng Preview, i-bind ito sa LifecycleOwner at kumuha ng SurfaceProvider para sa display. Para sa pagkuha ng photo, ginagamit ang ImageCapture na may target na pag-save. Nasa ibaba ang kumpletong halimbawa ng pagsisimula ng kamera at pagkuha ng photo gamit ang CameraX sa Kotlin.

Config ng Preview at 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", "Nabigong mag-bind", e)
    }
}, ContextCompact.getMainExecutor(this))

Ang metodo bindToLifecycle ay nagba-bind ng kamera sa lifecycle ng Activity — sa pag-ikot ng screen o pagpunta sa background, ang kamera ay awtomatikong nire-release. Pinipili ng CameraSelector.DEFAULT_BACK_CAMERA ang rear camera, para sa front camera ginagamit ang DEFAULT_FRONT_CAMERA. Pagkatapos ng pag-bind, ang Preview ay nagsisimulang magpakita ng imahe mula sa kamera sa PreviewView at nakikita ng gumagamit ang imahe ng kamera sa screen.

Pagkuha ng photo

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", "Error sa pagkuha", exception)
        }
    }
)

Ang metodo takePicture ay kumukuha ng frame mula sa kamera at sine-save ito sa isang file. Sinusuportahan ng OutputFileOptions ang pag-save sa File, ContentResolver at MediaStore. Sa callback na onImageSaved, ang application ay tumatanggap ng notification ng matagumpay na pag-save at maaaring mag-update ng UI. Tinitiyak ng CAPTURE_MODE_MINIMIZE_LATENCY ang maximum na bilis ng shutter sa pamamagitan ng pagbawas ng post-processing.

Implementasyon sa iOS gamit ang AVFoundation

Sa iOS, ang access sa kamera ay ibinibigay ng framework na AVFoundation sa pamamagitan ng klase na AVCaptureSession. Ang developer ay lumilikha ng capture session, nagdaragdag ng mga kinakailangang input (AVCaptureDeviceInput) at output (AVCapturePhotoOutput, AVCaptureVideoDataOutput) at sinisimulan ang session. Para sa pagpapakita ng preview, ginagamit ang AVCaptureVideoPreviewLayer. Nasa ibaba ang halimbawa ng pag-configure ng session para sa pagkuha ng photo sa 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 ay nagtatakda ng optimal na resolution para sa photo (karaniwan ay 12 MP sa modernong device). Ang input ay AVCaptureDeviceInput na ginawa para sa camera ng device. Pagkatapos idagdag ang input at output, ang session ay sinisimulan sa background thread sa pamamagitan ng startRunning — ang pagsisimula ng session ay maaaring tumagal ng hanggang 200 ms sa mas lumang device. Para sa pagkuha ng photo, tinatawag ang capturePhoto(with:delegate:), at ang resulta ay ibinabalik sa pamamagitan ng delegate na AVCapturePhotoCaptureDelegate.

Mga Tampok at Limitasyon

Sa paggamit ng kamera sa mobile device, kailangan isaalang-alang ang hardware limitations: pag-init ng device sa mahabang pagkuha, pag-drain ng baterya sa paggamit ng mataas na resolution at iba't ibang kalidad ng camera sa iba't ibang device. Sa Android, ang fragmentation ng ecosystem ay nagdudulot na ang parehong CameraX configuration ay maaaring gumana nang iba sa iba't ibang modelo. Sa iOS, ang mga limitasyon ay pangunahing nauukol sa licensing: ang paggamit ng kamera sa background ay nangangailangan ng espesyal na pahintulot mula sa Apple. Mahalaga ring tandaan na ang mga simulator ay walang access sa totoong kamera — ang pag-test ay posible lamang sa pisikal na device.

Compatibility sa iba't ibang bersyon ng OS

CameraX ay nilulutas ang problema ng Android fragmentation sa pamamagitan ng compatibility layer na CameraXConfig — awtomatikong nag-aapply ang library ng mga workaround para sa mga kilalang bug ng mga manufacturer. Sa iOS, ang AVFoundation ay gumagana nang pare-pareho sa lahat ng device simula sa iOS 6, ngunit ang ilang function (halimbawa Portrait Mode o LiDAR) ay available lamang sa iPhone 12 models at mas bago. Sa pag-develop ng cross-platform application, inirerekomenda ang paggamit ng Flutter o React Native na may camera plugins — ini-abstract nila ang mga pagkakaiba ng platform at nagbibigay ng unified API para sa parehong operating system.