Menggunakan konteks yang diproyeksikan untuk mengakses hardware di kacamata audio dan kacamata tampilan

Perangkat XR yang kompatibel
Panduan ini membantu Anda membangun pengalaman untuk jenis perangkat XR ini.
Kacamata Pintar dengan Layar
& Audio

Setelah Anda meminta dan diberi izin yang diperlukan, aplikasi Anda dapat mengakses hardware di kacamata pintar audio atau kacamata pintar dengan layar. Kunci untuk mengakses hardware kacamata (bukan hardware ponsel) adalah menggunakan konteks yang diproyeksikan.

Ada dua cara utama untuk mendapatkan konteks yang diproyeksikan, bergantung pada tempat kode Anda dieksekusi:

Mendapatkan konteks yang diproyeksikan jika kode Anda berjalan dalam aktivitas yang diproyeksikan

Jika kode aplikasi Anda berjalan dari dalam aktivitas yang diproyeksikan, konteks aktivitasnya sudah menjadi konteks yang diproyeksikan. Dalam skenario ini, panggilan yang dilakukan dalam aktivitas tersebut sudah dapat mengakses hardware kacamata.

Mendapatkan konteks yang diproyeksikan untuk kode yang berjalan di komponen aplikasi Telepon

Jika bagian aplikasi Anda di luar aktivitas yang diproyeksikan (seperti aktivitas ponsel atau layanan) perlu mengakses hardware kacamata, bagian tersebut harus secara eksplisit mendapatkan konteks yang diproyeksikan. Untuk melakukannya, gunakan metode 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
        }
    }
}

Memeriksa validitas

Gabungkan panggilan createProjectedDeviceContext dalam ProjectedContext.isProjectedDeviceConnected. Meskipun metode ini menampilkan true, konteks yang diproyeksikan tetap valid untuk perangkat terhubung, dan aktivitas atau layanan aplikasi Telepon Anda (seperti CameraManager) dapat mengakses hardware kacamata.

Pembersihan saat koneksi terputus

Konteks yang diproyeksikan terkait dengan siklus proses perangkat terhubung, sehingga konteks tersebut akan dihancurkan saat perangkat terputus. Saat perangkat terputus, ProjectedContext.isProjectedDeviceConnected akan menampilkan false. Aplikasi Anda harus memproses perubahan ini dan membersihkan layanan sistem (seperti CameraManager) atau resource yang dibuat aplikasi Anda menggunakan konteks yang diproyeksikan tersebut.

Melakukan inisialisasi ulang saat terhubung kembali

Saat kacamata terhubung kembali, aplikasi Anda dapat memperoleh instance konteks yang diproyeksikan lainnya menggunakan createProjectedDeviceContext, lalu melakukan inisialisasi ulang layanan atau resource sistem apa pun menggunakan konteks yang diproyeksikan baru.

Merekam audio dengan mikrofon kacamata

Anda dapat merekam audio dari kacamata menggunakan Bluetooth Hands-Free Profile (HFP). Dalam mode ini, kacamata terhubung ke ponsel menggunakan profil Headset dan Advanced Audio Distribution Profile (A2DP) standar, yang berfungsi seperti periferal Bluetooth biasa. Jika aplikasi Anda sudah dirancang untuk perekaman Bluetooth standar, Anda dapat menggunakan metode ini untuk merekam audio dari kacamata tanpa pengembangan tambahan.

Merekam audio menggunakan HFP Bluetooth

Untuk merekam audio menggunakan Bluetooth HFP, pertama-tama minta izin runtime yang diperlukan, lalu rekam audio menggunakan API AudioManager, seperti yang dijelaskan di bagian berikut.

Meminta izin

Seperti perangkat audio Bluetooth standar, RECORD_AUDIO, BLUETOOTH_CONNECT, dan izin terkait lainnya dikontrol oleh ponsel, bukan perangkat terhubung (seperti kacamata pintar audio atau kacamata pintar dengan layar).

Ikuti langkah-langkah berikut untuk meminta izin:

  1. Deklarasikan izin berikut dalam file manifes aplikasi Anda:

  2. Minta izin RECORD_AUDIO dan BLUETOOTH_CONNECT saat runtime menggunakan alur izin Android standar.

Menggunakan AudioManager untuk mengarahkan audio

Setelah pengguna memberikan izin runtime yang diperlukan ke aplikasi Anda, gunakan API AudioManager untuk menyetel perangkat komunikasi ke TYPE_BLUETOOTH_SCO guna merutekan audio melalui Bluetooth HFP. Tindakan ini mengarahkan sistem untuk mengambil audio dari periferal Bluetooth.

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()
}

Mengambil gambar dengan kamera kacamata pintar

Untuk mengambil gambar dengan kamera kacamata, pantau konektivitas dengan monitorProjectedDeviceConnectivity untuk mendapatkan konteks perangkat yang diproyeksikan, buat LifecycleCameraProvider terisolasi yang terikat ke konteks tersebut, proses deteksi keberadaan kamera, dan ikat ImageCapture kasus penggunaan CameraX.

Pertama, pantau konektivitas perangkat dan lakukan inisialisasi LifecycleCameraProvider.createInstance dengan CameraXConfig.Builder streaming tunggal:

@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()
            }
        }
    }
}

Di CameraX 1.6.0 dan yang lebih tinggi, daftarkan CameraPresenceListener menggunakan addCameraPresenceListener untuk bereaksi saat kamera kacamata ditambahkan atau dihapus:

@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
}

Selanjutnya, pilih kamera kacamata dari availableCameraInfos menggunakan CameraIdentifier yang disediakan oleh pemroses dan ikat 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
    }
}

Poin penting tentang kode

  • Per perangkat LifecycleCameraProvider: Gunakan LifecycleCameraProvider.createInstance untuk membuat penyedia kamera terisolasi yang dicakupkan ke konteks yang diproyeksikan aktif. Karena deviceId konteks yang diproyeksikan dapat berubah saat kacamata terputus dan terhubung kembali saat proses aplikasi Anda tetap aktif, membuat penyedia per perangkat akan memastikan CameraX terikat ke perangkat terhubung yang aktif.
  • Memproses kehadiran kamera: Di CameraX 1.6.0 dan yang lebih tinggi, daftarkan CameraPresenceListener menggunakan cameraProvider.addCameraPresenceListener, bukan langsung membuka kamera saat kacamata terhubung. Penyiapan asinkron antara kacamata pintar dan host harus selesai sebelum OS selesai membuat ulang kamera kacamata pintar, dan kamera kacamata pintar juga dapat menghilang secara dinamis saat terhubung (seperti selama mitigasi termal).
    • Penambahan kamera (onCamerasAdded): Diaktifkan setelah availableCameraInfos diperbarui dengan kamera yang ditambahkan, sehingga menghindari masalah pengaturan waktu selama penyiapan.
    • Pelepasan kamera (onCamerasRemoved): Melacak keberadaan kamera, bukan status sedang digunakan, sehingga pelepasan binding di sana hanya akan melepaskan resource saat kamera kacamata dilepas, bukan bereaksi saat aplikasi Anda sendiri membuka kamera.
  • Pembersihan saat koneksi terputus: Penutupan pembersihan yang ditampilkan ke monitorProjectedDeviceConnectivity memanggil removeCameraPresenceListener dan unbindAll() saat koneksi kacamata terputus atau aktivitas dihancurkan.
  • Pemilihan kamera dinamis: Mencocokkan CameraIdentifier yang diteruskan ke onCamerasAdded dengan availableCameraInfos menggunakan isOf untuk memilih kamera kacamata pintar secara dinamis.
  • Resolusi kustom: Mem-build ResolutionSelector yang menargetkan contoh rasio aspek 16:9 dan resolusi pilihan Anda (kembali ke ukuran terendah yang didukung) untuk ImageCapture. Rasio aspek dan resolusi yang didukung bervariasi di berbagai perangkat dan mode kacamata (seperti 4:3 dan 16:9), jadi buat kueri StreamConfigurationMap jika Anda perlu memeriksa ukuran persis yang didukung.
  • Binding siklus proses: Mengikat ImageCapture ke LifecycleOwner, yang otomatis mengelola transisi buka dan tutup kamera dengan siklus proses aktivitas.
  • Mengonfigurasi untuk hardware streaming tunggal: Pipeline kamera kacamata dibatasi untuk satu streaming aktif dalam satu waktu. Saat ImageCapture terikat sendiri, CameraX akan melampirkan streaming berulang internal (MeteringRepeating) untuk fokus dan pengukuran secara default, yang menyebabkan pipeline streaming tunggal terhenti. Teruskan setRepeatingStreamForced(false) di CameraXConfig yang diteruskan ke LifecycleCameraProvider.createInstance sehingga ImageCapture dapat mengikat tanpa aliran pratinjau.

Setelah kamera kacamata disiapkan, Anda dapat mengambil gambar dengan class ImageCapture CameraX. Lihat dokumentasi CameraX untuk mempelajari cara menggunakan takePicture untuk mengambil gambar.

Merekam streaming dengan kamera kacamata pintar

Untuk mengambil streaming, bukan gambar, ganti komponen ImageCapture dari contoh pengambilan gambar dengan komponen VideoCapture atau ImageAnalysis dan ubah logika pengambilan.

Untuk mengetahui informasi selengkapnya tentang API ini dan cara menggunakannya, lihat dokumentasi perekaman video CameraX dan analisis gambar CameraX.

Memilih resolusi dan kecepatan frame

Anda harus mengkueri perangkat untuk menemukan resolusi yang didukung dan kecepatan frame maksimum yang sesuai. Tabel berikut mencantumkan contoh nilai yang mungkin Anda lihat, bergantung pada kasus penggunaan aplikasi Anda. Untuk menghemat daya baterai dan mengurangi panas pada kacamata, pilih resolusi dan kecepatan frame terendah yang sesuai untuk kasus penggunaan Anda.

Kasus penggunaan Resolusi Kecepatan frame
Pengenalan teks (OCR) atau penginderaan dunia 1920 x 1080 1 FPS
Streaming video AI (asisten multimodal) 1024 x 768 1 FPS
Pelokalan dan pemosisian visual (VPS) 640x360 atau 640x480 10 FPS
Panggilan video 640x360 atau 640x480 24 FPS

Membuat kueri kecepatan frame maksimum untuk setiap resolusi

CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES melaporkan batas kecepatan frame perangkat secara keseluruhan, yang dapat lebih tinggi daripada kecepatan streaming yang didukung resolusi tertentu. Untuk mendapatkan nilai maksimum sebenarnya untuk setiap resolusi pada kacamata audio dan kacamata pintar dengan layar, baca durasi frame minimumnya dan konversikan ke FPS dengan 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
    }
}

Selanjutnya, gunakan nilai tersebut untuk menghitung batas minFps dan maxFps untuk rentang kecepatan frame target Anda. Batasi batas bawah (minFps) pada kecepatan frame streaming maksimum resolusi yang dihitung dari getOutputMinFrameDuration, dan tetapkan batas atas yang lebih tinggi (maxFps) sebagai jendela catch-up:

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

Poin penting tentang kode

  • Gunakan format yang sesuai dengan kasus penggunaan Anda. Untuk ImageAnalysis, harganya YUV_420_888.
  • Untuk VideoCapture, gunakan overload Class sebagai gantinya: getOutputSizes(MediaRecorder::class.java) dan getOutputMinFrameDuration(MediaRecorder::class.java, size).
  • Tentukan rentang dengan maxFps lebih besar dari minFps (seperti minFps*2), bukan menetapkan kedua batas ke nilai yang sama seperti Range(minFps, minFps). Batas bawah (minFps) menetapkan target kecepatan frame streaming dan harus maksimal sebesar nilai yang dihitung dari getOutputMinFrameDuration, sedangkan batas atas (maxFps) bertindak sebagai jendela catch-up untuk frame yang tertunda guna mencegah latensi persisten. Misalnya, [1,2] atau [1,3] untuk streaming 1 FPS, dan [24,30] atau [24,48] untuk streaming 24 FPS.

Mengonfigurasi kecepatan frame

Untuk mengonfigurasi rentang kecepatan frame berdasarkan kasus penggunaan CameraX Anda:

// 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()

Contoh ini menunjukkan konfigurasi untuk VideoCapture dan ImageAnalysis, tetapi Anda dapat menerapkan kasus penggunaan apa pun yang didukung aplikasi Anda.

Memahami perilaku streaming

Perhatikan perilaku sistem berikut saat menggunakan streaming perekaman:

  • Resolusi yang tidak didukung akan ditolak: Jika Anda meminta ukuran yang tidak ada dalam daftar, Camera2 akan menolak konfigurasi sebelum streaming dibuka.
  • Meminta kecepatan frame di atas batas maksimum: Jika Anda meminta kecepatan frame minimum di atas batas maksimum yang didukung untuk resolusi Anda, sesi akan tetap terbuka, tetapi kecepatan frame target dari kacamata akan dibatasi ke batas maksimum yang didukung, sementara batas atas akan terus bertindak sebagai batas kecepatan catch-up. Misalnya, meminta [30,60] pada 640 x 480 akan membatasi kecepatan frame target ke 24 FPS (berperilaku seperti [24,60]).
  • Throttling termal: Saat kacamata menjadi hangat, kecepatan frame akan turun, tetapi resolusinya tetap sama. Bangun aplikasi Anda untuk menangani kecepatan frame yang lebih rendah atau tidak merata, misalnya dengan memeriksa stempel waktu frame, bukan mengasumsikan kecepatan tetap.

Mengakses hardware ponsel dari aktivitas yang diproyeksikan

Aktivitas yang diproyeksikan juga dapat mengakses hardware ponsel (seperti kamera atau mikrofon) dengan menggunakan createHostDeviceContext(context) untuk mendapatkan konteks perangkat host (ponsel):

@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)
}

Saat mengakses hardware atau resource yang khusus untuk perangkat host (ponsel) di aplikasi hybrid (aplikasi yang berisi pengalaman seluler dan kacamata), Anda harus secara eksplisit memilih konteks yang benar untuk memastikan aplikasi dapat mengakses hardware yang benar: