Gdy poprosisz o niezbędne uprawnienia i je uzyskasz, Twoja aplikacja będzie mieć dostęp do hardware okularów audio lub okularów z wyświetlaczem. Kluczem do uzyskania dostępu do hardware okularów (zamiast hardware telefonu) jest użycie prognozowanego kontekstu.
Istnieją 2 główne sposoby uzyskiwania prognozowanego kontekstu, w zależności od tego, gdzie jest wykonywany kod:
Jak uzyskać prognozowany kontekst, jeśli kod jest uruchamiany w prognozowanej aktywności
Jeśli kod aplikacji jest uruchamiany w ramach prognozowanej aktywności, własny kontekst aktywności jest już prognozowanym kontekstem. W takim przypadku połączenia wykonywane w ramach tej aktywności mogą już korzystać z hardware okularów.
Jak uzyskać prognozowany kontekst dla kodu uruchamianego w komponencie aplikacji na telefon
Jeśli część aplikacji poza prognozowaną aktywnością (np. aktywność na telefonie lub usługa) musi mieć dostęp do hardware okularów, musi wyraźnie uzyskać prognozowany kontekst. Aby tak się stało, użyj metody 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 } } }
Sprawdzanie ważności
Umieść wywołanie createProjectedDeviceContext w ProjectedContext.isProjectedDeviceConnected. Chociaż ta metoda zwraca true, wyświetlany kontekst pozostaje ważny dla połączonego urządzenia, a aktywność lub usługa aplikacji na telefonie (np. CameraManager) może uzyskać dostęp do sprzętu okularów.
Czyszczenie po rozłączeniu
Wyświetlany kontekst jest powiązany z cyklem życia połączonego urządzenia, więc jest niszczony, gdy urządzenie się rozłączy. Gdy urządzenie się rozłączy, ProjectedContext.isProjectedDeviceConnected zwraca false. Aplikacja powinna nasłuchiwać tej zmiany i czyścić wszystkie usługi systemowe (takie jak CameraManager) lub zasoby utworzone przez aplikację przy użyciu tego kontekstu projekcji.
Ponowna inicjalizacja po ponownym połączeniu
Gdy okulary ponownie się połączą, aplikacja może uzyskać kolejną instancję wyświetlanego kontekstu za pomocą metody createProjectedDeviceContext, a następnie ponownie zainicjować usługi systemowe lub zasoby przy użyciu nowego wyświetlanego kontekstu.
Nagrywanie dźwięku za pomocą mikrofonu okularów
Możesz nagrywać dźwięk z okularów, korzystając z profilu Bluetooth Hands-Free (HFP). W tym trybie okulary łączą się z telefonem za pomocą standardowych profili zestawu słuchawkowego i A2DP (Advanced Audio Distribution Profile), działając jak typowe urządzenie peryferyjne Bluetooth. Jeśli Twoja aplikacja jest już zaprojektowana do standardowego nagrywania przez Bluetooth, możesz użyć tej metody do nagrywania dźwięku z okularów bez konieczności wprowadzania dodatkowych zmian.
Nagrywanie dźwięku za pomocą profilu Bluetooth HFP
Aby nagrywać dźwięk za pomocą profilu Bluetooth HFP, najpierw poproś o wymagane uprawnienia w czasie działania aplikacji, a następnie nagraj dźwięk za pomocą interfejsu API AudioManager, jak opisano w sekcjach poniżej.
Wyślij prośbę o uprawnienia
Podobnie jak w przypadku każdego standardowego urządzenia audio Bluetooth, uprawnienia RECORD_AUDIO, BLUETOOTH_CONNECT i inne powiązane uprawnienia są kontrolowane przez telefon, a nie przez połączone urządzenie (takie jak okulary audio lub okulary z wyświetlaczem).
Aby poprosić o uprawnienia, wykonaj te czynności:
Zadeklaruj te uprawnienia w pliku manifestu aplikacji:
Poproś o uprawnienia
RECORD_AUDIOiBLUETOOTH_CONNECTw czasie działania aplikacji, korzystając ze standardowego procesu przyznawania uprawnień na Androidzie.
Używanie klasy AudioManager do kierowania dźwięku
Gdy użytkownik przyzna aplikacji niezbędne uprawnienia w czasie działania, użyj interfejsu API AudioManager, aby ustawić urządzenie komunikacyjne na TYPE_BLUETOOTH_SCO i przekierować dźwięk przez Bluetooth HFP. Spowoduje to, że system będzie pobierać dźwięk z urządzenia peryferyjnego 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() }
Robienie zdjęć aparatem okularów
Aby zrobić zdjęcie aparatem okularów, monitoruj połączenie za pomocą monitorProjectedDeviceConnectivity, aby uzyskać prognozowany kontekst urządzenia, utwórz odizolowany LifecycleCameraProvider powiązany z tym kontekstem, nasłuchuj obecności aparatu i powiąż przypadek użycia ImageCapture CameraX.
Najpierw sprawdź połączenie urządzenia i zainicjuj LifecycleCameraProvider.createInstance z pojedynczym strumieniem 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() } } } }
W CameraX w wersji 1.6.0 lub nowszej zarejestruj CameraPresenceListener za pomocą addCameraPresenceListener, aby reagować na dodanie lub usunięcie kamery okularów:
@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 }
Następnie wybierz aparat w okularach z availableCameraInfos, używając CameraIdentifier dostarczonego przez detektor, i powiąż 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 } }
Najważniejsze informacje o kodzie
- Na urządzenie
LifecycleCameraProvider: użyjLifecycleCameraProvider.createInstance, aby utworzyć odizolowanego dostawcę kamery ograniczonego do aktywnego prognozowanego kontekstu.deviceIdwyświetlanego kontekstu może się zmienić, gdy okulary zostaną odłączone i ponownie połączone, podczas gdy proces aplikacji pozostanie aktywny. Utworzenie dostawcy dla każdego urządzenia gwarantuje, że CameraX połączy się z aktywnym połączonym urządzeniem. - Nasłuchiwanie obecności aparatu: w CameraX w wersji 1.6.0 lub nowszej zarejestruj
CameraPresenceListenerza pomocącameraProvider.addCameraPresenceListener, zamiast otwierać aparat natychmiast po połączeniu okularów. Asynchroniczna konfiguracja między okularami a urządzeniem hosta musi zostać zakończona, zanim system operacyjny zakończy odtwarzanie kamery w okularach. Kamera w okularach może też dynamicznie znikać podczas połączenia (np. podczas ograniczania temperatury).- Dodanie kamery (
onCamerasAdded): uruchamia się po zaktualizowaniuavailableCameraInfoso dodany aparat, co pozwala uniknąć problemów z synchronizacją podczas konfiguracji. - Usunięcie kamery (
onCamerasRemoved): śledzi obecność kamery, a nie stan jej użycia, więc odłączenie zwalnia zasoby tylko wtedy, gdy kamera okularów zostanie usunięta, a nie gdy aplikacja otworzy kamerę.
- Dodanie kamery (
- Czyszczenie po rozłączeniu: zamknięcie czyszczenia zwrócone do
monitorProjectedDeviceConnectivitywywołujeremoveCameraPresenceListeneriunbindAll(), gdy okulary zostaną odłączone lub aktywność zostanie zniszczona. - Dynamiczny wybór kamery: dopasowuje
CameraIdentifierprzekazany doonCamerasAddeddoavailableCameraInfosza pomocąisOf, aby dynamicznie wybrać kamerę okularów. - Niestandardowa rozdzielczość: tworzy
ResolutionSelectorkierowany na przykładowy format obrazu 16:9 i preferowaną rozdzielczość (z powrotem do najbliższego niższego obsługiwanego rozmiaru) dlaImageCapture. Obsługiwane formaty obrazu i rozdzielczości różnią się w zależności od urządzenia i trybu (np. 4:3 i 16:9), więc jeśli chcesz sprawdzić dokładne obsługiwane rozmiary, wyślij zapytanie doStreamConfigurationMap. - Wiązanie cyklu życia: wiąże
ImageCapturezLifecycleOwner, automatycznie zarządzając otwieraniem i zamykaniem aparatu w ramach cyklu życia aktywności. - Konfigurowanie sprzętu do obsługi pojedynczego strumienia: potok kamery okularów jest ograniczony do jednego aktywnego strumienia naraz. Gdy
ImageCapturejest powiązany samodzielnie, CameraX domyślnie dołącza wewnętrzny strumień powtarzający się (MeteringRepeating) na potrzeby ustawiania ostrości i pomiaru, co powoduje zatrzymanie potoku strumieniowego pojedynczego strumienia. PrzekażsetRepeatingStreamForced(false)wCameraXConfigdoLifecycleCameraProvider.createInstance, abyImageCapturemógł się powiązać bez strumienia podglądu.
Po skonfigurowaniu aparatu w okularach możesz zrobić zdjęcie za pomocą klasy ImageCapture CameraX. Więcej informacji o używaniu takePicture do robienia zdjęć znajdziesz w dokumentacji CameraX.
Nagrywanie transmisji aparatem okularów
Aby przechwytywać strumienie zamiast obrazu, zastąp komponent ImageCapture z przykładu przechwytywania obrazu komponentami VideoCapture lub ImageAnalysis i zmień logikę przechwytywania.
Więcej informacji o tych interfejsach API i sposobie ich używania znajdziesz w dokumentacji dotyczącej nagrywania filmów w CameraX i analizy obrazu w CameraX.
Wybieranie rozdzielczości i liczby klatek
Należy wysłać zapytanie do urządzenia, aby znaleźć obsługiwane rozdzielczości i odpowiadające im maksymalne liczby klatek. W tabeli poniżej znajdziesz przykłady wartości, które mogą się wyświetlać w zależności od przypadku użycia aplikacji. Aby oszczędzać baterię i zmniejszyć nagrzewanie się okularów, wybierz najniższą rozdzielczość i liczbę klatek, które sprawdzą się w Twoim przypadku.
| Przypadek użycia | Rozdzielczość | Liczba klatek |
|---|---|---|
| rozpoznawanie tekstu (OCR) lub wykrywanie świata, | 1920 x 1080 | 1 kl./s |
| Strumieniowe przesyłanie filmów wygenerowanych przez AI (asystenci multimodalni) | 1024 × 768 | 1 kl./s |
| Lokalizacja i system pozycjonowania wizualnego (VPS) | 640 x 360 lub 640 x 480 | 10 kl./s |
| Rozmowy wideo | 640 x 360 lub 640 x 480 | 24 kl./s |
Sprawdzanie maksymalnej liczby klatek dla każdej rozdzielczości
CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES podaje ogólne granice liczby klatek na urządzeniu, które mogą być wyższe niż szybkość strumieniowania obsługiwana przez daną rozdzielczość. Aby uzyskać rzeczywistą maksymalną liczbę klatek na sekundę dla każdej rozdzielczości na okularach z wyświetlaczem i okularach audio, odczytaj minimalny czas trwania klatki i przekonwertuj go na klatki na sekundę za pomocą wzoru 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 } }
Następnie użyj tej wartości, aby obliczyć granice minFps i maxFps dla docelowego zakresu liczby klatek. Ustaw dolną granicę (minFps) na maksymalną liczbę klatek strumieniowania w danej rozdzielczości obliczoną na podstawie getOutputMinFrameDuration i ustaw wyższą górną granicę (maxFps) jako okno nadrabiania zaległości:
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
Najważniejsze informacje o kodzie
- Użyj formatu, który pasuje do Twojego przypadku użycia. W przypadku
ImageAnalysisjest toYUV_420_888. - W przypadku
VideoCaptureużyj tych przeciążeńClass:getOutputSizes(MediaRecorder::class.java)igetOutputMinFrameDuration(MediaRecorder::class.java, size). - Określ zakres, w którym
maxFpsjest większe niżminFps(np.minFps*2), zamiast ustawiać obie granice na tę samą wartość, np.Range(minFps, minFps). Dolna granica (minFps) określa docelową liczbę klatek strumieniowania i powinna być co najwyżej równa wartości obliczonej na podstawiegetOutputMinFrameDuration, natomiast górna granica (maxFps) działa jako okno nadrabiania opóźnionych klatek, aby zapobiec utrzymującym się opóźnieniom. Na przykład [1,2] lub [1,3] w przypadku strumienia 1 kl./s oraz [24,30] lub [24,48] w przypadku strumienia 24 kl./s.
Konfigurowanie liczby klatek
Aby skonfigurować zakres liczby klatek na podstawie przypadku użycia 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()
Ten przykład pokazuje konfigurację zarówno dla VideoCapture, jak i ImageAnalysis, ale możesz wdrożyć dowolne przypadki użycia obsługiwane przez Twoją aplikację.
Jak zachowuje się strumień
Podczas pracy ze strumieniami przechwytywania pamiętaj o tych zachowaniach systemu:
- Nieobsługiwane rozdzielczości są odrzucane: jeśli poprosisz o rozmiar, którego nie ma na liście, Camera2 odrzuci konfigurację przed otwarciem strumienia.
- Żądanie liczby klatek powyżej wartości maksymalnej: jeśli poprosisz o minimalną liczbę klatek powyżej maksymalnej obsługiwanej dla danej rozdzielczości, sesja nadal się otworzy, ale docelowa liczba klatek z okularów zostanie ograniczona do tej obsługiwanej wartości maksymalnej, a górna granica będzie nadal działać jako limit liczby klatek w trybie nadrabiania. Na przykład żądanie [30,60] przy 640 x 480 ogranicza docelową liczbę klatek do 24 FPS (zachowując się jak [24,60]).
- Ograniczanie termiczne: gdy okulary się nagrzewają, liczba klatek spada, ale rozdzielczość pozostaje taka sama. Zaprojektuj aplikację tak, aby obsługiwała niższe lub nierówne liczby klatek, na przykład przez sprawdzanie sygnatur czasowych klatek, zamiast zakładania stałej liczby klatek.
Dostęp do sprzętu telefonu z poziomu wyświetlanej aktywności
Aktywność wyświetlana może też uzyskać dostęp do hardware telefonu (np. aparatu lub mikrofonu) za pomocą createHostDeviceContext(context), aby zdobyć kontekst urządzenia hosta (telefonu):
@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) }
Gdy w aplikacji hybrydowej (zawierającej zarówno funkcje mobilne, jak i funkcje na okulary) uzyskujesz dostęp do hardware lub zasobów, które są specyficzne dla urządzenia hosta (telefonu), musisz wyraźnie wybrać odpowiedni kontekst, aby aplikacja mogła mieć dostęp do właściwego hardware:
- Aby uzyskać kontekst telefonu, użyj kontekstu
ActivityzActivitytelefonu lubProjectedContext.createHostDeviceContext. - Nie używaj
getApplicationContext, ponieważ kontekst aplikacji może nieprawidłowo zwracać kontekst okularów, jeśli ostatnio uruchomionym komponentem była aktywność prognozowana.