Ses gözlüklerindeki ve ekran gözlüklerindeki donanıma erişmek için yansıtılan bağlamı kullanma

Uygun XR cihazlar
Bu kılavuz, bu tür XR cihazlar için deneyimler geliştirmenize yardımcı olur.
Ses ve
Görüntü Arabirimli Gözlük

Gerekli izinleri isteyip aldıktan sonra uygulamanız, ses arabirimli gözlük veya görüntü arabirimli gözlükteki donanıma erişebilir. Telefonun donanımı yerine gözlüğün donanımına erişmek için yansıtılan bağlam kullanmanız gerekir.

Kodunuzun nerede yürütüldüğüne bağlı olarak, yansıtılan bağlamı elde etmenin iki temel yolu vardır:

Kodunuz öngörülen bir etkinlikte çalışıyorsa öngörülen bağlamı alma

Uygulamanızın kodu yansıtılan etkinliğinizin içinden çalışıyorsa kendi etkinlik bağlamı zaten yansıtılan bağlamdır. Bu senaryoda, söz konusu etkinlikte yapılan çağrılar gözlüğün donanımına zaten erişebilir.

Telefon uygulaması bileşeninde çalışan kod için öngörülen bağlamı alma

Uygulamanızın, yansıtılan etkinliğinizin dışında kalan bir bölümünün (ör. telefon etkinliği veya hizmet) gözlüğün donanımına erişmesi gerekiyorsa açıkça yansıtılan bir bağlam elde etmesi gerekir. Bunun için createProjectedDeviceContext yöntemini kullanın:

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

Geçerlilik kontrolü

createProjectedDeviceContext çağrısını ProjectedContext.isProjectedDeviceConnected içine alın. Bu yöntem true döndürürken yansıtılan bağlam, bağlı cihaz için geçerli kalır ve telefon uygulaması etkinliğiniz veya hizmetiniz (ör. CameraManager) gözlük donanımına erişebilir.

Bağlantı kesildiğinde temizle

Yansıtılan bağlam, bağlı cihazın yaşam döngüsüne bağlıdır. Bu nedenle, cihazın bağlantısı kesildiğinde yok edilir. Cihazın bağlantısı kesildiğinde ProjectedContext.isProjectedDeviceConnected, false değerini döndürür. Uygulamanız bu değişikliği dinlemeli ve sistem hizmetlerini (ör. CameraManager) veya uygulamanızın bu yansıtılan bağlamı kullanarak oluşturduğu kaynakları temizlemelidir.

Yeniden bağlanıldığında yeniden başlatma

Gözlük yeniden bağlandığında uygulamanız, createProjectedDeviceContext kullanarak başka bir yansıtılan bağlam örneği alabilir ve ardından yeni yansıtılan bağlamı kullanarak tüm sistem hizmetlerini veya kaynaklarını yeniden başlatabilir.

Gözlüğün mikrofonuyla ses kaydetme

Bluetooth Eller Serbest Profili'ni (HFP) kullanarak gözlükten ses kaydı yapabilirsiniz. Bu modda gözlük, standart mikrofonlu kulaklık ve Gelişmiş Ses Dağıtım Profili (A2DP) profillerini kullanarak telefona bağlanır ve tipik bir Bluetooth çevre birimi gibi çalışır. Uygulamanız standart Bluetooth kaydı için tasarlanmışsa ek bir geliştirme yapmadan gözlükten ses kaydetmek için bu yöntemi kullanabilirsiniz.

Bluetooth HFP kullanarak ses kaydetme

Bluetooth HFP kullanarak ses kaydetmek için önce gerekli çalışma zamanında istenen izinleri isteyin, ardından aşağıdaki bölümlerde açıklandığı gibi AudioManager API'yi kullanarak sesi kaydedin.

İzin iste

Tüm standart Bluetooth ses sistemlerinde olduğu gibi RECORD_AUDIO, BLUETOOTH_CONNECT ve diğer ilgili izinler, bağlı cihaz (ör. ses arabirimli gözlük veya görüntü arabirimli gözlük) tarafından değil, telefon tarafından kontrol edilir.

İzinleri istemek için aşağıdaki adımları uygulayın:

  1. Uygulamanızın manifest dosyasında aşağıdaki izinleri beyan edin:

  2. Standart Android izin akışını kullanarak çalışma zamanında hem RECORD_AUDIO hem de BLUETOOTH_CONNECT izinlerini isteyin.

Sesi yönlendirmek için AudioManager'ı kullanma

Kullanıcı, uygulamanıza gerekli çalışma zamanı izinlerini verdikten sonra, sesi Bluetooth HFP üzerinden yönlendirmek için AudioManager API'yi kullanarak iletişim cihazını TYPE_BLUETOOTH_SCO olarak ayarlayın. Bu, sisteme Bluetooth çevre biriminden ses alması talimatını verir.

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

Akıllı gözlüğün kamerasıyla fotoğraf çekme

Gözlüğün kamerasıyla görüntü yakalamak için monitorProjectedDeviceConnectivity ile bağlantıyı izleyerek yansıtılan bir cihaz bağlamı elde edin, bu bağlama bağlı izole bir LifecycleCameraProvider oluşturun, kameranın varlığını dinleyin ve CameraX'in ImageCapture kullanım alanını bağlayın.

Öncelikle cihaz bağlantısını izleyin ve tek bir akışla LifecycleCameraProvider.createInstance'yi başlatın 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 ve sonraki sürümlerde, gözlüğün kamerası eklendiğinde veya çıkarıldığında tepki vermek için addCameraPresenceListener kullanarak CameraPresenceListener kaydedin:

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

Ardından, dinleyici tarafından sağlanan CameraIdentifier kullanarak availableCameraInfos içinden gözlüğün kamerasını seçin ve ImageCapture bağlayın:

/**
 * 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
    }
}

Kodla ilgili önemli noktalar

  • Cihaz başına LifecycleCameraProvider: Etkin yansıtılan bağlam kapsamına alınmış izole bir kamera sağlayıcı oluşturmak için LifecycleCameraProvider.createInstance kullanın. Yansıtılan bağlamın deviceId değeri, uygulamanızın işlemi devam ederken gözlüğün bağlantısı kesilip yeniden bağlandığında değişebileceğinden, cihaz başına bir sağlayıcı oluşturmak CameraX'in etkin bağlı cihaza bağlanmasını sağlar.
  • Kameranın varlığını dinleme: CameraX 1.6.0 ve sonraki sürümlerde, gözlük bağlandığında kamerayı hemen açmak yerine cameraProvider.addCameraPresenceListener kullanarak CameraPresenceListener kaydedin. Gözlük ile ana makine arasındaki eşzamansız kurulum, OS gözlüğün kamerasını yeniden oluşturmayı tamamlamadan önce tamamlanmalıdır. Ayrıca gözlüğün kamerası, bağlıyken dinamik olarak kaybolabilir (ör. termal azaltma sırasında).
    • Kamera ekleme (onCamerasAdded): availableCameraInfos, eklenen kamerayla güncellendikten sonra tetiklenir ve kurulum sırasında zamanlama çakışmalarını önler.
    • Kamera çıkarma (onCamerasRemoved): Kullanım durumu yerine kameranın varlığını izler. Bu nedenle, burada bağlantıyı kaldırmak yalnızca gözlüğün kamerası çıkarıldığında kaynakları serbest bırakır, kendi uygulamanız kamerayı açtığında tepki vermez.
  • Bağlantı kesildiğinde temizle: Gözlüğün bağlantısı kesildiğinde veya etkinlik sonlandırıldığında temizleme işlemi monitorProjectedDeviceConnectivity çağrılarını removeCameraPresenceListener ve unbindAll() döndürür.
  • Dinamik kamera seçimi: Gözlüğün kamerasını dinamik olarak seçmek için isOf kullanarak onCamerasAdded'e iletilen CameraIdentifier ile availableCameraInfos'yı eşleştirir.
  • Özel çözünürlük: Örnek bir 16:9 en-boy oranını ve ImageCapture için tercih ettiğiniz çözünürlüğü (desteklenen en yakın alt boyuta geri dönerek) hedefleyen bir ResolutionSelector oluşturur. Desteklenen en boy oranları ve çözünürlükler, gözlük cihazları ve modları arasında farklılık gösterir (ör. 4:3 ve 16:9). Bu nedenle, desteklenen tam boyutları kontrol etmeniz gerekiyorsa StreamConfigurationMap sorgusunu kullanın.
  • Yaşam döngüsü bağlama: ImageCapture öğesini LifecycleOwner öğesine bağlayarak kameranın açılış ve kapanış geçişlerini etkinliğin yaşam döngüsüyle otomatik olarak yönetir.
  • Tek akışlı donanım için yapılandırma: Gözlüğün kamera ardışık düzeni, aynı anda tek bir etkin akışla sınırlıdır. ImageCapture tek başına bağlandığında CameraX, odaklama ve ölçüm için varsayılan olarak dahili bir tekrarlayan akış (MeteringRepeating) ekler. Bu da tek akışlı ardışık düzenin durmasına neden olur. LifecycleCameraProvider.createInstance öğesine iletilen CameraXConfig içinde setRepeatingStreamForced(false) değerini iletin. Böylece ImageCapture, önizleme akışı olmadan bağlanabilir.

Gözlüğün kamerası ayarlandıktan sonra CameraX'in ImageCapture sınıfıyla görüntü yakalayabilirsiniz. takePicture kullanarak görüntü yakalama hakkında bilgi edinmek için CameraX belgelerini inceleyin.

Gözlüğün kamerasıyla yayın kaydetme

Resim yerine akışları yakalamak için resim yakalama örneğindeki ImageCapture bileşenini VideoCapture veya ImageAnalysis bileşenleriyle değiştirin ve yakalama mantığını değiştirin.

Bu API'ler ve bunların nasıl kullanılacağı hakkında daha fazla bilgi için CameraX video yakalama ve CameraX görüntü analizi belgelerine bakın.

Çözünürlük ve kare hızı seçme

Desteklenen çözünürlükleri ve bunlara karşılık gelen maksimum kare hızlarını bulmak için cihazı sorgulamanız gerekir. Aşağıdaki tabloda, uygulamanızın kullanım alanına bağlı olarak görebileceğiniz değer örnekleri listelenmiştir. Pil gücünden tasarruf etmek ve gözlüğün ısınmasını azaltmak için kullanım alanınıza uygun en düşük çözünürlüğü ve kare hızını seçin.

Kullanım alanı Çözünürlük Kare hızı
Metin tanıma (OCR) veya dünya algılama 1920 x 1080 1 FPS
Yapay zeka video akışı (çok formatlı asistanlar) 1024 x 768 1 FPS
Yerelleştirme ve görsel konumlandırma (VPS) 640 x 360 veya 640 x 480 10 FPS
Görüntülü görüşme 640 x 360 veya 640 x 480 24 FPS

Her çözünürlük için maksimum kare hızını sorgulama

CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, cihazın genel kare hızı sınırlarını bildirir. Bu sınırlar, belirli bir çözünürlüğün desteklediği akış hızından daha yüksek olabilir. Sesli gözlük ve görüntülü gözlükte her çözünürlük için gerçek maksimum değeri elde etmek istiyorsanız minimum kare süresini okuyun ve StreamConfigurationMap.getOutputMinFrameDuration(format, size) ile FPS'ye dönüştürün:

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

Ardından, hedef kare hızı aralığınızın minFps ve maxFps sınırlarını hesaplamak için bu değeri kullanın. Alt sınırı (minFps), getOutputMinFrameDuration üzerinden hesaplanan çözünürlüğün maksimum akış kare hızıyla sınırlayın ve daha yüksek bir üst sınır (maxFps) belirleyerek aradaki farkı kapatın:

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

Kodla ilgili önemli noktalar

  • Kullanım alanınıza uygun biçimi kullanın. ImageAnalysis için bu tutar YUV_420_888.
  • VideoCapture için bunun yerine Class aşırı yüklemelerini kullanın: getOutputSizes(MediaRecorder::class.java) ve getOutputMinFrameDuration(MediaRecorder::class.java, size).
  • Her iki sınırı da Range(minFps, minFps) gibi aynı değere ayarlamak yerine maxFps değerinin minFps değerinden büyük olduğu bir aralık (ör. minFps*2) belirtin. Alt sınır (minFps), hedef yayın kare hızını belirler ve en fazla getOutputMinFrameDuration değerinden hesaplanan değer kadar olmalıdır. Üst sınır (maxFps) ise geciken kareler için bir yakalama penceresi görevi görerek kalıcı gecikmeyi önler. Örneğin, 1 FPS'lik bir yayın için [1,2] veya [1,3] ve 24 FPS'lik bir yayın için [24,30] veya [24,48].

Kare hızını yapılandırma

Kare hızı aralığını CameraX kullanım alanınıza göre yapılandırmak için:

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

Bu örnekte hem VideoCapture hem de ImageAnalysis için yapılandırma gösterilmektedir ancak uygulamanızın desteklediği kullanım alanlarını uygulayabilirsiniz.

Akışın nasıl davrandığını anlama

Yakalama akışlarıyla çalışırken aşağıdaki sistem davranışlarını göz önünde bulundurun:

  • Desteklenmeyen çözünürlükler reddedilir: Listede olmayan bir boyut isterseniz Camera2, akış açılmadan önce yapılandırmayı reddeder.
  • Maksimum değerin üzerinde kare hızı isteme: Çözünürlüğünüz için desteklenen maksimum değerin üzerinde bir minimum kare hızı isterseniz oturum yine de açılır ancak gözlükten gelen hedef kare hızı, desteklenen maksimum değerle sınırlanır ve üst sınır, yakalama hızı sıklık sınırlaması olarak kullanılmaya devam eder. Örneğin, 640 x 480 çözünürlükte [30,60] isteği, hedef kare hızını 24 FPS'ye sabitler ([24,60] gibi davranır).
  • Termal kısıtlama: Gözlük ısındığında kare hızı düşer ancak çözünürlük aynı kalır. Uygulamanızı, daha düşük veya düzensiz kare hızlarını işleyecek şekilde oluşturun. Örneğin, sabit bir hız varsaymak yerine kare zaman damgalarını kontrol edin.

Yansıtılan bir etkinlikten telefonun donanımına erişme

Yansıtılan etkinlik, ana makine cihazın (telefon) bağlamını almak için createHostDeviceContext(context) kullanarak telefonun donanımına (ör. kamera veya mikrofon) da erişebilir:

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

Karma bir uygulamada (hem mobil hem de gözlük deneyimleri içeren bir uygulama) ana cihaza (telefon) özgü donanıma veya kaynaklara erişirken uygulamanızın doğru donanıma erişebilmesi için doğru bağlamı açıkça seçmeniz gerekir: