Kamera dalam Pengembangan Seluler: apa itu, jenis API dan cara menggunakannya

Apa itu kamera dalam aplikasi seluler

Kamera seluler — adalah modul optik terintegrasi yang terdiri dari lensa, matriks (sensor) dan prosesor pemrosesan gambar (ISP). Pengembang mendapatkan akses ke kamera melalui sistem operasi menggunakan framework khusus. Di Android, ini adalah Camera2 API (tingkat rendah) dan CameraX (tingkat tinggi berbasis Camera2), di iOS — AVFoundation dan UIKit untuk skenario sederhana. Setiap platform menyediakan seperangkat alatnya sendiri, tetapi konsep umumnya sama: aplikasi menginisialisasi sesi penangkapan, mengonfigurasi parameter (resolusi, fokus, eksposur) dan menerima aliran bingkai atau gambar individual.

Kemampuan perangkat keras kamera modern

Kamera seluler modern mendukung banyak mode pemotretan: HDR, mode malam, potret dengan buram latar belakang, gerakan lambat dan perekaman dalam format RAW. Untuk pengembang tersedia pengaturan perangkat lunak: ISO (sensitivitas matriks), waktu pencahayaan (eksposur), keseimbangan putih, fokus (otomatis dan manual) dan stabilisasi gambar. Pada perangkat flagship tersedia hingga 4 kamera dengan jarak fokus berbeda, dan aplikasi dapat memilih kamera tertentu berdasarkan ID.

Jenis API untuk bekerja dengan kamera

Di platform seluler ada beberapa API untuk bekerja dengan kamera, yang berbeda dalam tingkat abstraksi dan fungsionalitas. Pemilihan API tertentu tergantung pada kebutuhan proyek: untuk pengambilan foto sederhana, CameraX atau UIImagePickerController sudah cukup, untuk aplikasi profesional diperlukan Camera2 atau AVFoundation dengan kontrol sensor langsung. Di bawah ini adalah perbandingan API utama.

Kapan memilih CameraX

CameraX — pilihan optimal untuk sebagian besar aplikasi Android yang membutuhkan kamera tanpa kustomisasi mendalam. Pustaka secara otomatis menangani siklus hidup Activity dan Fragment, mendukung izin dan kompatibilitas dengan berbagai versi Android. CameraX menjamin perilaku yang sama pada 95% perangkat Android berkat lapisan kompatibilitas. Jika diperlukan pratinjau kamera (Preview), pengambilan foto (ImageCapture) atau analisis aliran (ImageAnalysis) — CameraX menangani ketiga skenario tanpa menulis kode kompleks.

Kapan memilih Camera2

Camera2 — API tingkat rendah untuk skenario profesional: perekaman RAW, pengaturan eksposur manual, pemotretan burst, kontrol simultan beberapa kamera. Camera2 membutuhkan pemahaman mendalam tentang pipeline penangkapan gambar, manajemen StateMachine dan pemrosesan callback dari pengembang. Gunakan Camera2 hanya jika CameraX tidak memenuhi kebutuhan: misalnya, untuk aplikasi pemindaian dokumen dengan fokus manual atau kamera kustom dengan resolusi non-standar.

Meminta izin akses kamera

Akses ke kamera memerlukan persetujuan eksplisit pengguna di kedua platform. Di Android, izin CAMERA ditambahkan ke manifes, dan mulai Android 6.0 izin juga harus diminta saat runtime melalui ActivityCompat.requestPermissions. Di iOS, kunci NSCameraUsageDescription dengan deskripsi alasan penggunaan kamera ditambahkan ke Info.plist. Tanpa deskripsi ini, aplikasi akan crash saat mencoba mengakses kamera. Mulai iOS 14, dialog izin tidak hanya menampilkan nama aplikasi tetapi juga alasan yang diberikan — formulasinya harus dapat dipahami oleh pengguna.

Implementasi di Android dengan CameraX

CameraX menyederhanakan pekerjaan dengan kamera menjadi beberapa baris kode. Untuk memulai pratinjau, perlu membuat instance Preview, mengikatnya ke LifecycleOwner dan mendapatkan SurfaceProvider untuk ditampilkan. Untuk pengambilan foto digunakan ImageCapture dengan target penyimpanan. Di bawah ini adalah contoh lengkap memulai kamera dan mengambil foto menggunakan CameraX di Kotlin.

Konfigurasi Preview dan 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", "Gagal mengikat", e)
    }
}, ContextCompact.getMainExecutor(this))

Metode bindToLifecycle mengikat kamera ke siklus hidup Activity — saat rotasi layar atau masuk ke latar belakang, kamera secara otomatis dilepaskan. CameraSelector.DEFAULT_BACK_CAMERA memilih kamera belakang, untuk kamera depan digunakan DEFAULT_FRONT_CAMERA. Setelah pengikatan, Preview mulai menampilkan gambar dari kamera di PreviewView dan pengguna melihat gambar kamera di layar.

Pengambilan 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", "Kesalahan pengambilan", exception)
        }
    }
)

Metode takePicture melakukan penangkapan bingkai dari kamera dan menyimpannya ke file. OutputFileOptions mendukung penyimpanan ke File, ContentResolver dan MediaStore. Di callback onImageSaved, aplikasi menerima pemberitahuan tentang penyimpanan berhasil dan dapat memperbarui UI. CAPTURE_MODE_MINIMIZE_LATENCY memastikan kecepatan rana maksimum dengan mengurangi pasca-pemrosesan.

Implementasi di iOS dengan AVFoundation

Di iOS, akses ke kamera disediakan oleh framework AVFoundation melalui kelas AVCaptureSession. Pengembang membuat sesi penangkapan, menambahkan input yang diperlukan (AVCaptureDeviceInput) dan output (AVCapturePhotoOutput, AVCaptureVideoDataOutput) dan memulai sesi. Untuk menampilkan pratinjau digunakan AVCaptureVideoPreviewLayer. Di bawah ini adalah contoh konfigurasi sesi untuk pengambilan foto di 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 menetapkan resolusi optimal untuk foto (biasanya 12 MP pada perangkat modern). Inputnya adalah AVCaptureDeviceInput yang dibuat untuk kamera perangkat. Setelah menambahkan input dan output, sesi dimulai di thread latar belakang melalui startRunning — memulai sesi dapat memakan waktu hingga 200 ms pada perangkat lama. Untuk pengambilan foto, capturePhoto(with:delegate:) dipanggil dan hasilnya dikembalikan melalui delegate AVCapturePhotoCaptureDelegate.

Fitur dan Keterbatasan

Saat bekerja dengan kamera di perangkat seluler, perlu mempertimbangkan keterbatasan perangkat keras: pemanasan perangkat saat pemotretan lama, pengosongan baterai saat bekerja dengan resolusi tinggi dan kualitas kamera yang berbeda pada perangkat yang berbeda. Di Android, fragmentasi ekosistem menyebabkan konfigurasi CameraX yang sama dapat bekerja berbeda pada model yang berbeda. Di iOS, keterbatasan terutama terkait dengan lisensi: penggunaan kamera di latar belakang memerlukan izin khusus dari Apple. Juga penting untuk diingat bahwa simulator tidak memiliki akses ke kamera nyata — pengujian hanya mungkin dilakukan pada perangkat fisik.

Kompatibilitas dengan berbagai versi OS

CameraX memecahkan masalah fragmentasi Android melalui lapisan kompatibilitas CameraXConfig — pustaka secara otomatis menerapkan solusi untuk bug terkenal dari produsen. Di iOS, AVFoundation bekerja seragam di semua perangkat mulai dari iOS 6, tetapi beberapa fitur (misalnya Portrait Mode atau LiDAR) hanya tersedia di model iPhone 12 dan lebih baru. Saat mengembangkan aplikasi lintas platform, disarankan menggunakan Flutter atau React Native dengan plugin kamera — mereka mengabstraksi perbedaan platform dan menyediakan API terpadu untuk kedua sistem operasi.