หลังจากที่คุณขอและได้รับสิทธิ์ที่จำเป็นแล้ว แอปจะเข้าถึงฮาร์ดแวร์ในแว่นตาที่มีระบบเสียงหรือแว่นตาที่มีจอแสดงผลได้ กุญแจสำคัญในการเข้าถึงฮาร์ดแวร์ของแว่นตา (แทนฮาร์ดแวร์ของโทรศัพท์) คือการใช้บริบทที่ฉายภาพ
การรับบริบทที่คาดการณ์มี 2 วิธีหลักๆ โดยขึ้นอยู่กับตำแหน่งที่โค้ดทำงาน ดังนี้
รับบริบทที่คาดการณ์ไว้หากโค้ดของคุณทำงานในกิจกรรมที่คาดการณ์ไว้
หากโค้ดของแอปทำงานจากภายในกิจกรรมที่ฉาย บริบทกิจกรรมของแอปเองจะเป็นบริบทที่ฉายอยู่แล้ว ในกรณีนี้ การเรียกที่ทำภายในกิจกรรมนั้นจะเข้าถึงฮาร์ดแวร์ของแว่นตาได้อยู่แล้ว
รับบริบทที่คาดการณ์ไว้สำหรับโค้ดที่ทำงานในคอมโพเนนต์ของแอปโทรศัพท์
หากส่วนหนึ่งของแอปที่อยู่นอกกิจกรรมที่ฉายภาพ (เช่น กิจกรรมหรือบริการในโทรศัพท์) จำเป็นต้องเข้าถึงฮาร์ดแวร์ของแว่นตา ส่วนนั้นจะต้องได้รับบริบทที่ฉายภาพอย่างชัดแจ้ง โดยใช้วิธีการ createProjectedDeviceContext ดังนี้
@RequiresApi(Build.VERSION_CODES.BAKLAVA) @OptIn(ExperimentalProjectedApi::class, ExperimentalCoroutinesApi::class) fun monitorProjectedDeviceConnectivity( context: Context, onConnected: suspend (projectedContext: Context) -> (() -> Unit)? ) { val lifecycleScope = (context as? LifecycleOwner)?.lifecycleScope ?: CoroutineScope(Dispatchers.Main + SupervisorJob()) lifecycleScope.launch { var cleanupAction: (() -> Unit)? = null try { // Before creating a projected context, verify that the projected device // is connected to the host device (phone). // While this flow collects true, the active projected context remains valid. ProjectedContext.isProjectedDeviceConnected(context, coroutineContext) .distinctUntilChanged() .collectLatest { isConnected -> // Clean up any previous session resources prior to state transitions. cleanupAction?.invoke() cleanupAction = null if (!isConnected) { Log.i(TAG, "Projected device disconnected. Cleaning up hardware resources...") return@collectLatest } // Inside a phone Activity or Service, create a projected context. // Note: If you are already inside a projected Activity, the default context // is already a projected context. val projectedContext = runCatching { ProjectedContext.createProjectedDeviceContext(context) }.onFailure { e -> Log.e(TAG, "Failed to create projected context", e) }.getOrNull() ?: return@collectLatest // Use the new, valid `projectedContext` to initialize system services (e.g., CameraManager). Log.i(TAG, "Projected device connected. Initializing hardware...") cleanupAction = onConnected(projectedContext) } } finally { // Guarantee final resource cleanup on Activity destruction or scope cancellation. cleanupAction?.invoke() cleanupAction = null } } }
ตรวจสอบความถูกต้อง
รวมการเรียก createProjectedDeviceContext ไว้ใน ProjectedContext.isProjectedDeviceConnected แม้ว่าเมธอดนี้จะแสดงผล true แต่บริบทที่คาดการณ์ไว้จะยังคงใช้ได้กับอุปกรณ์ที่เชื่อมต่อ และกิจกรรมหรือบริการของแอปโทรศัพท์ (เช่น CameraManager) จะเข้าถึงฮาร์ดแวร์ของแว่นตาได้
ล้างข้อมูลเมื่อยกเลิกการเชื่อมต่อ
บริบทที่ฉายจะเชื่อมโยงกับวงจรของอุปกรณ์ที่เชื่อมต่อ ดังนั้นระบบจะทำลายบริบทดังกล่าวเมื่ออุปกรณ์ยกเลิกการเชื่อมต่อ เมื่ออุปกรณ์ยกเลิกการเชื่อมต่อ
ProjectedContext.isProjectedDeviceConnected จะแสดงผลเป็น false แอปของคุณควรคอยฟังการเปลี่ยนแปลงนี้และล้างบริการของระบบ (เช่น CameraManager) หรือทรัพยากรที่แอปสร้างขึ้นโดยใช้บริบทที่ฉายภาพนั้น
เริ่มต้นใหม่เมื่อเชื่อมต่ออีกครั้ง
เมื่อแว่นตาเชื่อมต่ออีกครั้ง แอปจะรับอินสแตนซ์บริบทที่ฉายอีกรายการได้โดยใช้ createProjectedDeviceContext จากนั้นเริ่มต้นบริการหรือทรัพยากรระบบอีกครั้งโดยใช้บริบทที่ฉายใหม่
บันทึกเสียงด้วยไมโครโฟนของแว่นตา
คุณสามารถบันทึกเสียงจากแว่นตาโดยใช้โปรไฟล์แฮนด์ฟรี (HFP) ของบลูทูธได้ ในโหมดนี้ แว่นตาจะเชื่อมต่อกับโทรศัพท์โดยใช้โปรไฟล์ชุดหูฟังมาตรฐานและโปรไฟล์การกระจายเสียงขั้นสูง (A2DP) ซึ่งทำงานเหมือนกับอุปกรณ์ต่อพ่วงบลูทูธทั่วไป หากแอปของคุณออกแบบมาสำหรับการบันทึกเสียงผ่านบลูทูธมาตรฐานอยู่แล้ว คุณสามารถใช้วิธีนี้เพื่อบันทึกเสียงจากแว่นตาได้โดยไม่ต้องพัฒนาเพิ่มเติม
บันทึกเสียงโดยใช้บลูทูธ HFP
หากต้องการบันทึกเสียงโดยใช้ Bluetooth HFP ให้ขอสิทธิ์รันไทม์ที่จำเป็นก่อน แล้วจึงบันทึกเสียงโดยใช้ AudioManager API ตามที่อธิบายไว้ในส่วนต่อไปนี้
ขอสิทธิ์
เช่นเดียวกับอุปกรณ์เสียงบลูทูธมาตรฐานทั่วไป สิทธิ์ RECORD_AUDIO, BLUETOOTH_CONNECT และสิทธิ์อื่นๆ ที่เกี่ยวข้องจะควบคุมโดยโทรศัพท์ ไม่ใช่อุปกรณ์ที่เชื่อมต่อ (เช่น แว่นตาที่มีระบบเสียงหรือแว่นตาที่มีจอแสดงผล)
ทำตามขั้นตอนต่อไปนี้เพื่อขอสิทธิ์
ประกาศสิทธิ์ต่อไปนี้ในไฟล์ Manifest ของแอป
ขอทั้งสิทธิ์
RECORD_AUDIOและBLUETOOTH_CONNECTขณะรันไทม์โดยใช้ขั้นตอนการขอสิทธิ์ Android มาตรฐาน
ใช้ AudioManager เพื่อกำหนดเส้นทางเสียง
หลังจากที่ผู้ใช้ให้สิทธิ์รันไทม์ที่จำเป็นแก่แอปแล้ว ให้ใช้ API AudioManager เพื่อตั้งค่าอุปกรณ์สื่อสารเป็น TYPE_BLUETOOTH_SCO เพื่อกำหนดเส้นทางเสียงผ่าน Bluetooth HFP ซึ่งจะสั่งให้ระบบดึงข้อมูลเสียงจากอุปกรณ์ต่อพ่วงบลูทูธ
val audioManager = context.getSystemService(AudioManager::class.java) ?: return val hfpDevice = audioManager.availableCommunicationDevices .firstOrNull { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO } ?: return // HFP input is limited to 16 kHz, with mono or stereo channel configurations. val sampleRate = 16_000 val channelMask = AudioFormat.CHANNEL_IN_MONO val encoding = AudioFormat.ENCODING_PCM_16BIT // Use a small multiple of the minimum buffer size to keep chunks short for low latency. val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelMask, encoding) if (minBufferSize <= 0) return val audioRecord = AudioRecord.Builder() .setAudioSource(MediaRecorder.AudioSource.VOICE_COMMUNICATION) .setAudioFormat( AudioFormat.Builder() .setSampleRate(sampleRate) .setChannelMask(channelMask) .setEncoding(encoding) .build() ) .setBufferSizeInBytes(minBufferSize * 2) .build() try { // Route voice communication audio through the Bluetooth device. if (!audioManager.setCommunicationDevice(hfpDevice)) return audioRecord.startRecording() // Read audio with audioRecord.read() on a background thread. } finally { // Stop and release when done. if (audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING) audioRecord.stop() audioRecord.release() audioManager.clearCommunicationDevice() }
จับภาพด้วยกล้องของแว่นตา
หากต้องการจับภาพด้วยกล้องของแว่นตา ให้ตรวจสอบการเชื่อมต่อกับ monitorProjectedDeviceConnectivity เพื่อรับบริบทของอุปกรณ์ที่ฉายภาพ สร้าง LifecycleCameraProvider ที่แยกต่างหากซึ่งเชื่อมโยงกับบริบทนั้น ฟังการแสดงตนของกล้อง และเชื่อมโยงกรณีการใช้งาน ImageCapture ของ CameraX
ก่อนอื่น ให้ตรวจสอบการเชื่อมต่ออุปกรณ์และเริ่มต้น LifecycleCameraProvider.createInstance ด้วยสตรีมเดียว CameraXConfig.Builder:
@OptIn(ExperimentalCameraProviderConfiguration::class) @RequiresApi(Build.VERSION_CODES.BAKLAVA) @SuppressLint("RestrictedApi") fun setUpGlassesCamera(activity: ComponentActivity) { monitorProjectedDeviceConnectivity(activity) { projectedContext -> val cameraManager = projectedContext.getSystemService(CameraManager::class.java) ?: run { Log.e(TAG, "CameraManager not available on projected context") return@monitorProjectedDeviceConnectivity null } // `setRepeatingStreamForced()` is currently internal but will be public soon. val cameraConfig = CameraXConfig.Builder .fromConfig(Camera2Config.defaultConfig()) .setRepeatingStreamForced(false) .build() val cameraProvider = try { // Acquire CameraX provider specifically bound to the projected context. // If the device disconnects while suspending, collectLatest cancels this coroutine. LifecycleCameraProvider.createInstance(projectedContext, cameraConfig) } catch (e: IllegalStateException) { Log.e(TAG, "Failed to initialize projected camera services", e) return@monitorProjectedDeviceConnectivity null } // Set up the listener to react to camera availability changes asynchronously. val availabilityCallback = registerAvailabilityListener( cameraManager = cameraManager, cameraProvider = cameraProvider, executor = ContextCompat.getMainExecutor(activity), onCameraAvailable = { cameraId -> // Delegate camera selection, resolution querying, and use-case binding. bindGlassesImageCapture(cameraProvider, cameraId, activity) } ) // Return a clean-up closure invoked automatically by monitorProjectedDeviceConnectivity // on disconnect, coroutine cancellation, or Activity destruction. return@monitorProjectedDeviceConnectivity { Log.i(TAG, "Projected camera setup scope ended. Tearing down resources...") try { cameraManager.unregisterAvailabilityCallback(availabilityCallback) } finally { cameraProvider.unbindAll() } } } }
ใน CameraX 1.6.0 ขึ้นไป ให้ลงทะเบียน CameraPresenceListener โดยใช้ addCameraPresenceListener เพื่อตอบสนองเมื่อมีการเพิ่มหรือนำกล้องของแว่นตาออก
@OptIn(ExperimentalCameraProviderConfiguration::class) fun registerAvailabilityListener( cameraManager: CameraManager, cameraProvider: LifecycleCameraProvider, executor: Executor, onCameraAvailable: (cameraId: String) -> Unit ): CameraManager.AvailabilityCallback { val callback = object : CameraManager.AvailabilityCallback() { override fun onCameraAvailable(cameraId: String) { super.onCameraAvailable(cameraId) Log.i(TAG, "Glasses camera available (ID: $cameraId). Binding use case...") // Fires only after the OS finishes re-registering the glasses' camera. // Pass the fresh cameraId directly—never cache it, as it may change when recreated. onCameraAvailable(cameraId) } override fun onCameraUnavailable(cameraId: String) { super.onCameraUnavailable(cameraId) Log.i(TAG, "Glasses camera unavailable (ID: $cameraId). Releasing resources...") // Gracefully release the pipeline when the projected camera becomes unavailable. cameraProvider.unbindAll() } } cameraManager.registerAvailabilityCallback(executor, callback) return callback }
ถัดไป ให้เลือกกล้องของแว่นตาจาก availableCameraInfos โดยใช้ CameraIdentifier ที่ Listener ระบุไว้ แล้วเชื่อมโยง ImageCapture ดังนี้
/** * Selects the projected camera matching dynamic [cameraId] from * [LifecycleCameraProvider.availableCameraInfos], verifies availability, and binds an * [ImageCapture] use case targeting a 16:9 resolution to [lifecycleOwner]. * * Note: Depending on your application's needs, [ImageCapture] can be swapped out for other * standard CameraX use cases: * - Use [ImageAnalysis] for real-time streaming workloads (e.g., OCR, AI vision, or VPS). * - Use [VideoCapture] for video recording pipelines. */ @OptIn(ExperimentalCamera2Interop::class, ExperimentalCameraProviderConfiguration::class) fun bindGlassesImageCapture( cameraProvider: LifecycleCameraProvider, cameraId: String, lifecycleOwner: LifecycleOwner, preferredResolution: Size = Size(1920, 1080) ): ImageCapture? { return try { // Discover available cameras dynamically via `availableCameraInfos` // Narrow it down by the dynamic `cameraId` because the projected camera's ID may // change when recreated val cameraInfo = cameraProvider.availableCameraInfos.firstOrNull { info -> Camera2CameraInfo.from(info).cameraId == cameraId } // Pre-binding check: Verify the selected camera is registered and available on the device. // The projected camera may be unavailable (for example, if the user took off the glasses). if (cameraInfo == null) { Log.w(TAG, "Glasses camera (ID: $cameraId) is not currently available.") return null } val cameraSelector = cameraInfo.cameraSelector val resolutionSelector = ResolutionSelector.Builder() .setAspectRatioStrategy(AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY) .setResolutionStrategy( ResolutionStrategy( preferredResolution, ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER ) ) .build() // Initialize the ImageCapture use case. val imageCapture = ImageCapture.Builder() .setResolutionSelector(resolutionSelector) .build() // Unbind any previously bound use cases before rebinding to the lifecycle owner. cameraProvider.unbindAll() // Bind the configured use case. You can swap `imageCapture` out for an `ImageAnalysis` // (e.g., from `setupCameraStreamingFps`) or `VideoCapture` instance here to match your use case. // `bindToLifecycle()` can throw IllegalArgumentException if use cases // are incompatible, or IllegalStateException if the LifecycleOwner is destroyed. cameraProvider.bindToLifecycle( lifecycleOwner, cameraSelector, imageCapture ) Log.i(TAG, "ImageCapture successfully bound for camera ID $cameraId") imageCapture } catch (exc: CameraInfoUnavailableException) { Log.e(TAG, "Unable to access camera info for ID $cameraId", exc) null } catch (exc: IllegalArgumentException) { Log.e(TAG, "Invalid camera configuration or use case combination for ID $cameraId", exc) null } catch (exc: IllegalStateException) { Log.e(TAG, "Camera is already bound to another lifecycle or closed", exc) null } }
ประเด็นสำคัญเกี่ยวกับโค้ด
- ต่ออุปกรณ์
LifecycleCameraProvider: ใช้LifecycleCameraProvider.createInstanceเพื่อสร้างผู้ให้บริการกล้องที่แยกต่างหากซึ่งกำหนดขอบเขตไว้ในบริบทที่คาดการณ์ไว้ที่ใช้งานอยู่ เนื่องจากdeviceIdของบริบทที่ฉายภาพสามารถเปลี่ยนแปลงได้เมื่อแว่นตาตัดการเชื่อมต่อและเชื่อมต่อใหม่ขณะที่กระบวนการของแอปยังคงทำงานอยู่ การสร้างผู้ให้บริการต่ออุปกรณ์จะช่วยให้มั่นใจได้ว่า CameraX จะเชื่อมโยงกับอุปกรณ์ที่เชื่อมต่ออยู่ - ฟังการแสดงตนของกล้อง: ใน CameraX 1.6.0 ขึ้นไป ให้ลงทะเบียน
CameraPresenceListenerโดยใช้cameraProvider.addCameraPresenceListenerแทนการเปิดกล้องทันทีเมื่อแว่นตาเชื่อมต่อ การตั้งค่าแบบอะซิงโครนัสระหว่างแว่นตาและโฮสต์ต้องเสร็จสิ้นก่อนที่ระบบปฏิบัติการจะสร้างกล้องของแว่นตาขึ้นมาใหม่ และกล้องของแว่นตาอาจหายไปแบบไดนามิกขณะเชื่อมต่อ (เช่น ระหว่างการลดความร้อน)- การเพิ่มกล้อง (
onCamerasAdded): เริ่มทำงานหลังจากที่availableCameraInfosได้รับการอัปเดตด้วยกล้องที่เพิ่มเข้ามา เพื่อหลีกเลี่ยงการแย่งชิงทรัพยากรระหว่างการตั้งค่า - การนำกล้องออก (
onCamerasRemoved): ติดตามสถานะการมีอยู่ของกล้องแทนสถานะการใช้งาน ดังนั้นการเลิกเชื่อมโยงที่นั่นจะปล่อยทรัพยากรเมื่อนำกล้องของแว่นตาออกเท่านั้น แทนที่จะตอบสนองเมื่อแอปของคุณเปิดกล้อง
- การเพิ่มกล้อง (
- ล้างข้อมูลเมื่อยกเลิกการเชื่อมต่อ: การปิดล้างข้อมูลจะกลับไปเรียกใช้
monitorProjectedDeviceConnectivityremoveCameraPresenceListenerและunbindAll()เมื่อแว่นตายกเลิกการเชื่อมต่อหรือกิจกรรมถูกทำลาย - การเลือกกล้องแบบไดนามิก: จับคู่
CameraIdentifierที่ส่งไปยังonCamerasAddedกับavailableCameraInfosโดยใช้isOfเพื่อเลือกกล้องของแว่นตาแบบไดนามิก - ความละเอียดที่กำหนดเอง: สร้าง
ResolutionSelectorที่กำหนดเป้าหมายเป็นสัดส่วนภาพตัวอย่าง 16:9 และความละเอียดที่ต้องการ (กลับไปใช้ขนาดที่รองรับที่ต่ำกว่าซึ่งใกล้เคียงที่สุด) สำหรับImageCaptureสัดส่วนภาพและความละเอียดที่รองรับจะแตกต่างกันไปตามอุปกรณ์แว่นตาและโหมด (เช่น 4:3 และ 16:9) ดังนั้นให้ค้นหาStreamConfigurationMapหากต้องการตรวจสอบขนาดที่รองรับที่แน่นอน - การเชื่อมโยงวงจร: เชื่อมโยง
ImageCaptureกับLifecycleOwnerโดยจะจัดการการเปลี่ยนผ่านการเปิดและปิดกล้องโดยอัตโนมัติด้วยวงจรของกิจกรรม - การกำหนดค่าสำหรับฮาร์ดแวร์สตรีมเดียว: ไปป์ไลน์กล้องของแว่นตาถูกจำกัดให้มีสตรีมที่ใช้งานอยู่ได้ครั้งละ 1 สตรีมเท่านั้น เมื่อเชื่อมโยง
ImageCaptureเพียงอย่างเดียว CameraX จะแนบสตรีมที่ทำซ้ำภายใน (MeteringRepeating) สำหรับการโฟกัสและการวัดแสงโดยค่าเริ่มต้น ซึ่งทำให้ไปป์ไลน์สตรีมเดียวหยุดชะงัก ส่งsetRepeatingStreamForced(false)ในCameraXConfigที่ส่งไปยังLifecycleCameraProvider.createInstanceเพื่อให้ImageCaptureเชื่อมโยงได้โดยไม่ต้องมีสตรีมตัวอย่าง
หลังจากตั้งค่ากล้องของแว่นตาแล้ว คุณจะจับภาพได้ด้วยคลาส ImageCapture ของ CameraX โปรดดูเอกสารประกอบของ CameraX เพื่อดูข้อมูลเกี่ยวกับการใช้ takePicture เพื่อจับภาพ
จับภาพสตรีมด้วยกล้องของแว่นตา
หากต้องการจับภาพสตรีมแทนรูปภาพ ให้แทนที่คอมโพเนนต์ ImageCapture จากตัวอย่างการจับภาพด้วยคอมโพเนนต์ VideoCapture หรือ ImageAnalysis แล้วเปลี่ยนตรรกะการจับภาพ
ดูข้อมูลเพิ่มเติมเกี่ยวกับ API เหล่านี้และวิธีใช้ได้ในเอกสารประกอบเกี่ยวกับการบันทึกวิดีโอด้วย CameraX และการวิเคราะห์รูปภาพด้วย CameraX
เลือกความละเอียดและอัตราเฟรม
คุณควรค้นหาอุปกรณ์เพื่อดูความละเอียดที่รองรับและอัตราเฟรมสูงสุดที่สอดคล้องกัน ตารางต่อไปนี้แสดงตัวอย่างค่าที่คุณอาจเห็น โดยขึ้นอยู่กับกรณีการใช้งานของแอป หากต้องการประหยัดพลังงานแบตเตอรี่และลดความร้อนของแว่นตา ให้เลือกความละเอียดและอัตราเฟรมต่ำสุดที่เหมาะกับกรณีการใช้งานของคุณ
| กรณีการใช้งาน | ความละเอียด | อัตราเฟรม |
|---|---|---|
| การจดจำข้อความ (OCR) หรือการตรวจจับสภาพแวดล้อม | 1920 x 1080 | 1 FPS |
| สตรีมมิงวิดีโอ AI (ผู้ช่วยแบบหลายรูปแบบ) | 1024 x 768 | 1 FPS |
| การแปลและการกำหนดตำแหน่งภาพ (VPS) | 640 x 360 หรือ 640 x 480 | 10 FPS |
| วิดีโอคอล | 640 x 360 หรือ 640 x 480 | 24 FPS |
ค้นหาอัตราเฟรมสูงสุดสำหรับความละเอียดแต่ละรายการ
CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES จะรายงานขอบเขตอัตราเฟรมโดยรวมของอุปกรณ์ ซึ่งอาจสูงกว่าอัตราการสตรีมที่ความละเอียดหนึ่งๆ รองรับ หากต้องการดูค่าสูงสุดจริงสำหรับความละเอียดแต่ละรายการในแว่นตาที่มีเสียงและแว่นตาที่มีจอแสดงผล โปรดอ่านระยะเวลาเฟรมขั้นต่ำและแปลงเป็น FPS ด้วย StreamConfigurationMap.getOutputMinFrameDuration(format, size) ดังนี้
@androidx.annotation.OptIn(ExperimentalCamera2Interop::class) fun getMaxFpsBySize(cameraInfo: CameraInfo, format: Int): Map<Size, Int> { val map = Camera2CameraInfo.from(cameraInfo).getCameraCharacteristic( CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP ) ?: return emptyMap() return map.getOutputSizes(format).associateWith { size -> val minFrameDurationNs = map.getOutputMinFrameDuration(format, size) if (minFrameDurationNs > 0) (1_000_000_000L / minFrameDurationNs).toInt() else 0 } }
จากนั้นใช้ค่าดังกล่าวเพื่อคำนวณขอบเขต minFps และ maxFps สำหรับช่วงอัตราเฟรมเป้าหมาย จำกัดขอบเขตล่าง (minFps) ไว้ที่อัตราเฟรมสตรีมมิงสูงสุดของความละเอียดที่คำนวณจาก getOutputMinFrameDuration และตั้งค่าขอบเขตบนที่สูงขึ้น (maxFps) เป็นกรอบเวลาการไล่ตาม:
val maxFpsBySize = getMaxFpsBySize(cameraInfo, ImageFormat.YUV_420_888) val maxSupportedFps = maxFpsBySize[size] ?: return ImageAnalysis.Builder().build() // minFps is the target streaming frame rate and should be at most maxSupportedFps. val minFps = minOf(desiredFps, maxSupportedFps) // Set the upper bound to 2x minFps so the stream can catch up if frames are delayed. val maxFps = minFps * 2
ประเด็นสำคัญเกี่ยวกับโค้ด
- ใช้รูปแบบที่ตรงกับกรณีการใช้งานของคุณ สำหรับ
ImageAnalysisคือYUV_420_888 - สำหรับ
VideoCaptureให้ใช้โอเวอร์โหลดClassแทน ดังนี้getOutputSizes(MediaRecorder::class.java)และgetOutputMinFrameDuration(MediaRecorder::class.java, size) - ระบุช่วงที่
maxFpsมากกว่าminFps(เช่นminFps*2) แทนที่จะตั้งค่าขอบเขตทั้ง 2 เป็นค่าเดียวกัน เช่นRange(minFps, minFps)ขอบเขตล่าง (minFps) จะกำหนดอัตราเฟรมสตรีมมิงเป้าหมายและควรมีค่าไม่เกินค่าที่คำนวณจากgetOutputMinFrameDurationส่วนขอบเขตบน (maxFps) จะทำหน้าที่เป็นกรอบเวลาไล่ตามสำหรับเฟรมที่ล่าช้าเพื่อป้องกันเวลาในการตอบสนองที่ต่อเนื่อง เช่น [1,2] หรือ [1,3] สำหรับสตรีม 1 FPS และ [24,30] หรือ [24,48] สำหรับสตรีม 24 FPS
กำหนดค่าอัตราเฟรม
วิธีกำหนดค่าช่วงอัตราเฟรมตามกรณีการใช้งาน CameraX มีดังนี้
// Create and return the ImageAnalysis builder with proper frame rate ranges // ImageAnalysis: OCR, AI streaming, and VPS val analysisBuilder = ImageAnalysis.Builder() .setResolutionSelector(resolutionSelector) Camera2Interop.Extender(analysisBuilder) .setCaptureRequestOption( CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, Range(minFps, maxFps) ) return analysisBuilder.build()
ตัวอย่างนี้แสดงการกำหนดค่าสำหรับทั้ง VideoCapture และ ImageAnalysis แต่คุณสามารถใช้ Use Case ใดก็ได้ที่แอปรองรับ
ทำความเข้าใจลักษณะการทำงานของสตรีม
โปรดคำนึงถึงลักษณะการทำงานของระบบต่อไปนี้ขณะทำงานกับสตรีมการจับภาพ
- ระบบจะปฏิเสธความละเอียดที่ไม่รองรับ: หากคุณขอขนาดที่ไม่อยู่ในรายการ Camera2 จะปฏิเสธการกำหนดค่าก่อนที่สตรีมจะเปิดขึ้น
- การขออัตราเฟรมที่สูงกว่าค่าสูงสุด: หากคุณขออัตราเฟรมขั้นต่ำที่สูงกว่าค่าสูงสุดที่รองรับสำหรับความละเอียดของคุณ เซสชันจะยังคงเปิดอยู่ แต่อัตราเฟรมเป้าหมายจากแว่นตาจะถูกจำกัดไว้ที่ค่าสูงสุดที่รองรับ ในขณะที่ขอบเขตบนจะยังคงทำหน้าที่เป็นขีดจำกัดอัตราการไล่ตาม เช่น การขอ [30,60] ที่ 640 x 480 จะจำกัดอัตราเฟรมเป้าหมายไว้ที่ 24 FPS (ทำงานเหมือน [24,60])
- การควบคุมความร้อน: เมื่อแว่นตาเริ่มร้อน อัตราเฟรมจะลดลง แต่ความละเอียดยังคงเท่าเดิม สร้างแอปให้จัดการอัตราเฟรมที่ต่ำหรือไม่สม่ำเสมอได้ เช่น โดยการตรวจสอบการประทับเวลาของเฟรมแทนที่จะถือว่าอัตราเฟรมคงที่
เข้าถึงฮาร์ดแวร์ของโทรศัพท์จากกิจกรรมที่ฉายภาพ
กิจกรรมที่ฉายยังเข้าถึงฮาร์ดแวร์ของโทรศัพท์ (เช่น กล้องหรือไมโครโฟน) ได้ด้วยโดยใช้ createHostDeviceContext(context) เพื่อรับบริบทของอุปกรณ์โฮสต์ (โทรศัพท์) ดังนี้
@OptIn(ExperimentalProjectedApi::class) fun getHostDeviceContext(context: Context): Context { // Obtain the host device (phone) context. // The `context` argument passed in can be any context (projected, host, Service, or App). return ProjectedContext.createHostDeviceContext(context) }
เมื่อเข้าถึงฮาร์ดแวร์หรือทรัพยากรที่เฉพาะเจาะจงสำหรับอุปกรณ์โฮสต์ (โทรศัพท์) ในแอปแบบไฮบริด (แอปที่มีทั้งประสบการณ์การใช้งานบนอุปกรณ์เคลื่อนที่และแว่นตา) คุณต้องเลือกบริบทที่ถูกต้องอย่างชัดเจนเพื่อให้แอปเข้าถึงฮาร์ดแวร์ที่ถูกต้องได้ โดยทำดังนี้
- ใช้บริบท
Activityจากโทรศัพท์ActivityหรือProjectedContext.createHostDeviceContextเพื่อรับบริบทของโทรศัพท์ - อย่าใช้
getApplicationContextเนื่องจากบริบทของแอปพลิเคชันอาจแสดงผลบริบทของแว่นตาอย่างไม่ถูกต้องหากกิจกรรมที่ฉายภาพเป็นคอมโพเนนต์ที่เปิดล่าสุด