กล้องในการพัฒนามือถือ: คืออะไร ประเภท API และวิธีใช้งาน

กล้องในแอปพลิเคชันมือถือคืออะไร

กล้องมือถือคือโมดูลออปติคอลในตัวที่ประกอบด้วยเลนส์ เซ็นเซอร์ภาพ และตัวประมวลผลสัญญาณภาพ (ISP) นักพัฒนาเข้าถึงกล้องผ่านระบบปฏิบัติการโดยใช้เฟรมเวิร์กเฉพาะทาง บน Android ได้แก่ Camera2 API (ระดับต่ำ) และ CameraX (ระดับสูง สร้างบน Camera2) และบน iOS — AVFoundation และ UIKit สำหรับสถานการณ์ง่ายๆ แต่ละแพลตฟอร์มมีชุดเครื่องมือของตัวเอง แต่แนวคิดทั่วไปเหมือนกัน: แอปพลิเคชันเริ่มเซสชันการจับภาพ กำหนดค่าพารามิเตอร์ (ความละเอียด โฟกัส การเปิดรับแสง) และรับสตรีมเฟรมหรือภาพแต่ละภาพ

ความสามารถฮาร์ดแวร์ของกล้องสมัยใหม่

กล้องมือถือสมัยใหม่รองรับ โหมดถ่ายภาพมากมาย: HDR, โหมดกลางคืน, ภาพบุคคลพร่ามัวพื้นหลัง, วิดีโอสโลว์โมชัน และการบันทึกในรูปแบบ RAW นักพัฒนาสามารถเข้าถึงการตั้งค่าซอฟต์แวร์: ISO (ความไวเซ็นเซอร์), ความเร็วชัตเตอร์ (การเปิดรับแสง), สมดุลแสงขาว, โฟกัส (อัตโนมัติและปรับเอง) และการกันสั่นของภาพ อุปกรณ์เรือธงสามารถมีกล้องได้ถึง 4 ตัวที่มีความยาวโฟกัสต่างกัน และแอปพลิเคชันสามารถเลือกกล้องเฉพาะตาม ID

ประเภทของ API สำหรับการทำงานกับกล้อง

แพลตฟอร์มมือถือมี API หลายตัวสำหรับการทำงานกับกล้อง ซึ่งแตกต่างกันในระดับนามธรรมและฟังก์ชันการทำงาน การเลือก API ที่เฉพาะเจาะจงขึ้นอยู่กับความต้องการของโครงการ: สำหรับการจับภาพถ่ายง่ายๆ CameraX หรือ UIImagePickerController ก็เพียงพอ สำหรับแอปพลิเคชันระดับมืออาชีพ จำเป็นต้องใช้ Camera2 หรือ AVFoundation พร้อมการควบคุมเซ็นเซอร์โดยตรง ด้านล่างนี้คือการเปรียบเทียบ API หลัก

เมื่อใดควรเลือก CameraX

CameraX คือตัวเลือกที่ดีที่สุดสำหรับแอปพลิเคชัน Android ส่วนใหญ่ที่ต้องการกล้องโดยไม่ต้องปรับแต่งเชิงลึก ไลบรารีจะจัดการวงจรชีวิตของ Activity และ Fragment โดยอัตโนมัติ รองรับสิทธิ์ และรับประกันความเข้ากันได้ระหว่าง Android เวอร์ชันต่างๆ CameraX รับประกันพฤติกรรมที่สอดคล้องกันบนอุปกรณ์ Android 95% ด้วยเลเยอร์ความเข้ากันได้ หากคุณต้องการแสดงตัวอย่างกล้อง (Preview), จับภาพถ่าย (ImageCapture) หรือวิเคราะห์เฟรม (ImageAnalysis) — CameraX จัดการทั้งสามสถานการณ์โดยไม่ต้องเขียนโค้ดที่ซับซ้อน

เมื่อใดควรเลือก Camera2

Camera2 คือ API ระดับต่ำสำหรับสถานการณ์ระดับมืออาชีพ: การบันทึก RAW, การปรับการเปิดรับแสงด้วยตนเอง, การถ่ายต่อเนื่อง และการควบคุมกล้องหลายตัวพร้อมกัน Camera2 ต้องการให้นักพัฒนามีความเข้าใจอย่างลึกซึ้งเกี่ยวกับไปป์ไลน์การจับภาพ การจัดการ StateMachine และการจัดการ Callback ใช้ Camera2 เฉพาะเมื่อ CameraX ไม่ครอบคลุมความต้องการ: ตัวอย่างเช่น แอปพลิเคชันสแกนเอกสารที่โฟกัสแบบปรับเองหรือกล้องที่กำหนดเองที่มีความละเอียดไม่มาตรฐาน

การขอสิทธิ์เข้าถึงกล้อง

การเข้าถึงกล้องต้องได้รับอนุญาตอย่างชัดแจ้งจากผู้ใช้บนทั้งสองแพลตฟอร์ม บน Android มีการเพิ่มสิทธิ์ CAMERA ใน Manifest และตั้งแต่ Android 6.0 เป็นต้นไป จะต้องขอสิทธิ์ขณะรันไทม์ผ่าน ActivityCompat.requestPermissions เช่นกัน บน iOS มีการเพิ่มคีย์ NSCameraUsageDescription ใน Info.plist พร้อมคำอธิบายเหตุผลในการใช้กล้อง หากไม่มีคำอธิบายนี้ แอปพลิเคชันจะหยุดทำงานเมื่อพยายามเข้าถึงกล้อง ตั้งแต่ iOS 14 เป็นต้นไป ไดอะล็อกการขอสิทธิ์จะแสดงไม่เพียงแต่ชื่อแอปพลิเคชันเท่านั้น แต่ยังแสดงเหตุผลที่ระบุด้วย — ถ้อยคำต้องชัดเจนสำหรับผู้ใช้

การใช้งานบน Android ด้วย CameraX

CameraX ทำให้การทำงานกับกล้องง่ายขึ้นเหลือเพียงโค้ดไม่กี่บรรทัด ในการเริ่มแสดงตัวอย่าง คุณต้องสร้างอินสแตนซ์ของ Preview ผูกกับ LifecycleOwner และรับ SurfaceProvider สำหรับแสดงผล สำหรับการจับภาพถ่าย จะใช้ ImageCapture พร้อมเป้าหมายการบันทึก ด้านล่างนี้คือตัวอย่างสมบูรณ์ของการเริ่มกล้องและถ่ายภาพด้วย CameraX ใน Kotlin

การตั้งค่า Preview และ 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", "การผูกล้มเหลว", e)
    }
}, ContextCompact.getMainExecutor(this))

เมธอด bindToLifecycle จะผูกกล้องเข้ากับวงจรชีวิตของ Activity — เมื่อหน้าจอหมุนหรือแอปพลิเคชันเข้าสู่พื้นหลัง กล้องจะถูกปล่อยโดยอัตโนมัติ CameraSelector.DEFAULT_BACK_CAMERA เลือกกล้องหลัง สำหรับกล้องหน้า ใช้ DEFAULT_FRONT_CAMERA หลังจากการผูก Preview จะเริ่มแสดงฟีดกล้องใน PreviewView และผู้ใช้จะเห็นภาพจากกล้องบนหน้าจอ

การถ่ายภาพ

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", "ข้อผิดพลาดในการจับภาพ", exception)
        }
    }
)

เมธอด takePicture จะจับภาพเฟรมจากกล้องและบันทึกลงในไฟล์ OutputFileOptions รองรับการเขียนลงใน File, ContentResolver และ MediaStore ใน callback onImageSaved แอปพลิเคชันจะได้รับการแจ้งเตือนว่าบันทึกสำเร็จและสามารถอัปเดต UI ได้ CAPTURE_MODE_MINIMIZE_LATENCY ช่วยให้มั่นใจถึงความเร็วชัตเตอร์สูงสุดโดยลดการประมวลผลภายหลัง

การใช้งานบน iOS ด้วย AVFoundation

บน iOS การเข้าถึงกล้องนั้นจัดเตรียมโดยเฟรมเวิร์ก AVFoundation ผ่านคลาส AVCaptureSession นักพัฒนาสร้างเซสชันการจับภาพ เพิ่มอินพุตที่จำเป็น (AVCaptureDeviceInput) และเอาต์พุต (AVCapturePhotoOutput, AVCaptureVideoDataOutput) และเริ่มเซสชัน AVCaptureVideoPreviewLayer ใช้สำหรับแสดงตัวอย่าง ด้านล่างนี้คือตัวอย่างการตั้งค่าเซสชันสำหรับการจับภาพใน 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 ตั้งค่าความละเอียดที่เหมาะสมที่สุดสำหรับภาพถ่าย (โดยปกติ 12 MP บนอุปกรณ์สมัยใหม่) อินพุตคือ AVCaptureDeviceInput ที่สร้างขึ้นสำหรับกล้องของอุปกรณ์ หลังจากเพิ่มอินพุตและเอาต์พุตแล้ว เซสชันจะเริ่มบนเธรดพื้นหลังผ่าน startRunning — การเริ่มเซสชันอาจใช้เวลาถึง 200 มิลลิวินาทีบนอุปกรณ์รุ่นเก่า ในการถ่ายภาพ จะเรียก capturePhoto(with:delegate:) และผลลัพธ์จะถูกส่งกลับผ่าน AVCapturePhotoCaptureDelegate

คุณสมบัติและข้อจำกัด

เมื่อทำงานกับกล้องบนอุปกรณ์มือถือ ต้องพิจารณาข้อจำกัดของฮาร์ดแวร์: อุปกรณ์ร้อนขึ้นเมื่อบันทึกเป็นเวลานาน การใช้แบตเตอรี่เมื่อทำงานที่ความละเอียดสูง และคุณภาพกล้องที่แตกต่างกันในอุปกรณ์ต่างๆ บน Android การแตกแยกของระบบนิเวศหมายความว่าการกำหนดค่า CameraX เดียวกันอาจทำงานแตกต่างกันบนรุ่นต่างๆ บน iOS ข้อจำกัดส่วนใหญ่เกี่ยวข้องกับการอนุญาตสิทธิ์: การใช้กล้องในพื้นหลังต้องได้รับอนุญาตพิเศษจาก Apple สิ่งสำคัญที่ต้องจำไว้คือซิมูเลเตอร์ไม่สามารถเข้าถึงกล้องจริงได้ — การทดสอบทำได้เฉพาะบนอุปกรณ์จริงเท่านั้น

ความเข้ากันได้กับระบบปฏิบัติการเวอร์ชันต่างๆ

CameraX แก้ปัญหาการแตกแยกของ Android ผ่านเลเยอร์ความเข้ากันได้ของ CameraXConfig — ไลบรารีจะใช้วิธีแก้ปัญหาชั่วคราวสำหรับบั๊กที่ทราบของผู้ผลิตโดยอัตโนมัติ บน iOS AVFoundation ทำงานเหมือนกันบนอุปกรณ์ทั้งหมดตั้งแต่ iOS 6 แต่บางฟังก์ชัน (เช่น โหมดภาพบุคคลหรือ LiDAR) มีให้ใช้เฉพาะใน iPhone 12 และรุ่นใหม่กว่าเท่านั้น เมื่อพัฒนาแอปพลิเคชันข้ามแพลตฟอร์ม ขอแนะนำให้ใช้ Flutter หรือ React Native พร้อมปลั๊กอินกล้อง — ปลั๊กอินเหล่านี้จะซ่อนความแตกต่างของแพลตฟอร์มและจัดเตรียม API ที่เป็นหนึ่งเดียวสำหรับทั้งสองระบบปฏิบัติการ