Menggunakan konteks yang diproyeksikan untuk mengakses hardware kacamata AI

Perangkat XR yang kompatibel

Panduan ini membantu Anda membangun pengalaman untuk jenis perangkat XR ini.

Mempelajari jenis perangkat XR →

Mempelajari jenis perangkat XR →

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

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

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

Jika kode aplikasi Anda berjalan dari dalam aktivitas kacamata AI, konteks aktivitasnya sendiri sudah merupakan 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 ponsel

Jika bagian aplikasi Anda di luar aktivitas kacamata AI (seperti aktivitas ponsel atau layanan) perlu mengakses hardware kacamata, aplikasi tersebut harus mendapatkan konteks yang diproyeksikan secara eksplisit. Untuk melakukannya, gunakan metode createProjectedDeviceContext():

@OptIn(ExperimentalProjectedApi::class)
private fun getGlassesContext(context: Context): Context? {
    return try {
        // From a phone Activity or Service, get a context for the AI glasses.
        ProjectedContext.createProjectedDeviceContext(context)
    } catch (e: IllegalStateException) {
        Log.e(TAG, "Failed to create projected device context", e)
        null
    }
}
ProjectedHardware.kt

Memeriksa validitas

Setelah membuat konteks yang diproyeksikan, pantau ProjectedContext.isProjectedDeviceConnected. Meskipun metode ini menampilkan true, konteks yang diproyeksikan tetap valid untuk perangkat yang terhubung, dan aktivitas atau layanan aplikasi ponsel Anda (seperti CameraManager) dapat mengakses hardware kacamata AI.

Membersihkan saat koneksi terputus

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

Menginisialisasi ulang saat terhubung kembali

Saat perangkat kacamata AI terhubung kembali, aplikasi Anda dapat memperoleh instance konteks yang diproyeksikan lain menggunakan createProjectedDeviceContext(), lalu menginisialisasi ulang layanan atau resource sistem menggunakan konteks yang diproyeksikan baru.

Mengakses audio menggunakan bluetooth

Saat ini, kacamata AI terhubung ke ponsel Anda sebagai perangkat audio Bluetooth standar. Headset dan profil A2DP (Advanced Audio Distribution Profile) didukung. Dengan menggunakan pendekatan ini, aplikasi Android apa pun yang mendukung input atau output audio dapat berfungsi di kacamata, meskipun aplikasi tersebut tidak dibuat secara khusus untuk mendukung kacamata. Dalam beberapa kasus, penggunaan Bluetooth mungkin berfungsi lebih baik untuk kasus penggunaan aplikasi Anda sebagai alternatif untuk mengakses hardware kacamata menggunakan konteks yang diproyeksikan.

Seperti perangkat audio Bluetooth standar lainnya, izin untuk memberikan izin RECORD_AUDIO dikontrol oleh ponsel, bukan kacamata.

Mengambil gambar dengan kamera kacamata AI

Untuk mengambil gambar dengan kamera kacamata AI, siapkan dan ikat ImageCapture kasus penggunaan CameraX ke kamera kacamata menggunakan konteks yang benar untuk aplikasi Anda:

private fun startCameraOnGlasses(activity: ComponentActivity) {
    // 1. Get the CameraProvider using the projected context.
    // When using the projected context, DEFAULT_BACK_CAMERA maps to the AI glasses' camera.
    val projectedContext = try {
        ProjectedContext.createProjectedDeviceContext(activity)
    } catch (e: IllegalStateException) {
        Log.e(TAG, "AI Glasses context could not be created", e)
        return
    }

    val cameraProviderFuture = ProcessCameraProvider.getInstance(projectedContext)

    cameraProviderFuture.addListener({
        val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
        val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

        // 2. Check for the presence of a camera.
        if (!cameraProvider.hasCamera(cameraSelector)) {
            Log.w(TAG, "The selected camera is not available.")
            return@addListener
        }

        // 3. Query supported streaming resolutions using Camera2 Interop.
        val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)
        val camera2CameraInfo = Camera2CameraInfo.from(cameraInfo)
        val cameraCharacteristics = camera2CameraInfo.getCameraCharacteristic(
            CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
        )

        // 4. Define the resolution strategy.
        val targetResolution = Size(1920, 1080)
        val resolutionStrategy = ResolutionStrategy(
            targetResolution,
            ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER
        )
        val resolutionSelector = ResolutionSelector.Builder()
            .setResolutionStrategy(resolutionStrategy)
            .build()

        // 5. If you have other continuous use cases bound, such as Preview or ImageAnalysis,
        // you can use  Camera2 Interop's CaptureRequestOptions to set the FPS
        val fpsRange = Range(30, 60)
        val captureRequestOptions = CaptureRequestOptions.Builder()
            .setCaptureRequestOption(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange)
            .build()

        // 6. Initialize the ImageCapture use case with options.
        val imageCapture = ImageCapture.Builder()
            // Optional: Configure resolution, format, etc.
            .setResolutionSelector(resolutionSelector)
            .build()

        try {
            // Unbind use cases before rebinding.
            cameraProvider.unbindAll()

            // Bind use cases to camera using the Activity as the LifecycleOwner.
            cameraProvider.bindToLifecycle(
                activity,
                cameraSelector,
                imageCapture
            )
        } catch (exc: Exception) {
            Log.e(TAG, "Use case binding failed", exc)
        }
    }, ContextCompat.getMainExecutor(activity))
}
ProjectedHardware.kt

Poin penting tentang kode

• Mendapatkan instance ProcessCameraProvider menggunakan konteks perangkat yang diproyeksikan.
• Dalam cakupan konteks yang diproyeksikan, kamera utama yang menghadap ke luar kacamata AI dipetakan ke DEFAULT_BACK_CAMERA saat memilih kamera.
• Pemeriksaan pra-binding menggunakan cameraProvider.hasCamera(cameraSelector) untuk memverifikasi bahwa kamera yang dipilih tersedia di perangkat sebelum melanjutkan.
• Menggunakan Interop Camera2 dengan Camera2CameraInfo untuk membaca CameraCharacteristics#SCALER_STREAM_CONFIGURATION_MAP yang mendasarinya, yang dapat berguna untuk pemeriksaan lanjutan pada resolusi yang didukung.
• ResolutionSelector kustom dibuat untuk mengontrol secara tepat resolusi gambar output untuk ImageCapture.
• Membuat kasus penggunaan ImageCapture yang dikonfigurasi dengan ResolutionSelector kustom.
• Mengikat kasus penggunaan ImageCapture ke siklus proses aktivitas. Tindakan ini akan otomatis mengelola pembukaan dan penutupan kamera berdasarkan status aktivitas (misalnya, menghentikan kamera saat aktivitas dijeda).

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

Merekam video dengan kamera kacamata pintar AI

Untuk merekam video, bukan gambar, dengan kamera kacamata AI, ganti komponen ImageCapture dengan komponen VideoCapture yang sesuai dan ubah logika eksekusi pengambilan.

Perubahan utama melibatkan penggunaan kasus penggunaan yang berbeda, pembuatan file output yang berbeda, dan memulai pengambilan menggunakan metode perekaman video yang sesuai. Untuk mengetahui informasi selengkapnya tentang VideoCapture API dan cara menggunakannya, lihat dokumentasi perekaman video CameraX.

Tabel berikut menunjukkan resolusi dan kecepatan frame yang direkomendasikan, bergantung pada kasus penggunaan aplikasi Anda:

Mengakses hardware ponsel dari aktivitas kacamata AI

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

@OptIn(ExperimentalProjectedApi::class)
private fun getPhoneContext(activity: ComponentActivity): Context? {
    return try {
        // From an AI glasses Activity, get a context for the phone.
        ProjectedContext.createHostDeviceContext(activity)
    } catch (e: IllegalStateException) {
        Log.e(TAG, "Failed to create host device context", e)
        null
    }
}
ProjectedHardware.kt

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

• Gunakan konteks Activity dari Activity ponsel atau ProjectedContext.createHostDeviceContext() untuk mendapatkan konteks ponsel.
• Jangan gunakan getApplicationContext() karena konteks aplikasi dapat salah menampilkan konteks kacamata AI jika aktivitas kacamata adalah komponen yang terakhir diluncurkan.