ใช้บริบทที่คาดการณ์ไว้เพื่อเข้าถึงฮาร์ดแวร์ในแว่นตาเสียงและแว่นตาแสดงผล

อุปกรณ์ XR ที่รองรับ
คำแนะนำนี้จะช่วยคุณสร้างประสบการณ์การใช้งานสำหรับอุปกรณ์ XR ประเภทเหล่านี้
แว่นตาที่มีจอแสดงผล
และเสียง

หลังจากที่คุณขอและได้รับสิทธิ์ที่จำเป็นแล้ว แอปจะเข้าถึงฮาร์ดแวร์ในแว่นตาที่มีระบบเสียงหรือแว่นตาที่มีจอแสดงผลได้ กุญแจสำคัญในการเข้าถึงฮาร์ดแวร์ของแว่นตา (แทนฮาร์ดแวร์ของโทรศัพท์) คือการใช้บริบทที่ฉายภาพ

การรับบริบทที่คาดการณ์มี 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 และสิทธิ์อื่นๆ ที่เกี่ยวข้องจะควบคุมโดยโทรศัพท์ ไม่ใช่อุปกรณ์ที่เชื่อมต่อ (เช่น แว่นตาที่มีระบบเสียงหรือแว่นตาที่มีจอแสดงผล)

ทำตามขั้นตอนต่อไปนี้เพื่อขอสิทธิ์

  1. ประกาศสิทธิ์ต่อไปนี้ในไฟล์ Manifest ของแอป

  2. ขอทั้งสิทธิ์ 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): ติดตามสถานะการมีอยู่ของกล้องแทนสถานะการใช้งาน ดังนั้นการเลิกเชื่อมโยงที่นั่นจะปล่อยทรัพยากรเมื่อนำกล้องของแว่นตาออกเท่านั้น แทนที่จะตอบสนองเมื่อแอปของคุณเปิดกล้อง
  • ล้างข้อมูลเมื่อยกเลิกการเชื่อมต่อ: การปิดล้างข้อมูลจะกลับไปเรียกใช้ monitorProjectedDeviceConnectivity removeCameraPresenceListener และ 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 เนื่องจากบริบทของแอปพลิเคชันอาจแสดงผลบริบทของแว่นตาอย่างไม่ถูกต้องหากกิจกรรมที่ฉายภาพเป็นคอมโพเนนต์ที่เปิดล่าสุด