Obsługa danych wejściowych z okularów audio i okularów z wyświetlaczem

Obsługiwane urządzenia z XR
Te wskazówki pomogą Ci tworzyć aplikacje na te typy urządzeń z XR.
Więcej informacji o typach urządzeń z XR →
Okulary z wyświetlaczem i &
dźwiękiem
Więcej informacji o typach urządzeń z XR →

Aby przechwytywać i przetwarzać dane wejściowe użytkownika, które są dostarczane do wyświetlanej aktywności aplikacji, lub aby implementować niestandardowe zachowania touchpada, użyj pośrednich danych wejściowych wskaźnika. Aby obsługiwać inne typy zdarzeń (np. działanie aparatu), zapoznaj się z tymi sekcjami tego przewodnika.

Obsługa działania aparatu

Gdy użytkownik naciśnie przycisk aparatu na urządzeniu, system dostarczy zdarzenie wejściowe do wyświetlanej aktywności aplikacji jako działanie ProjectedInputEvent.ProjectedInputAction.TOGGLE_APP_CAMERA. Twoja aplikacja może obserwować to działanie za pomocą specjalnego dyspozytora:

@OptIn(ExperimentalProjectedApi::class)
class CameraActionInputSnippetActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Observe hardware camera action events when RESUMED
        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.RESUMED) {
                withContext(Dispatchers.Default) {
                    try {
                        val projectedActivity = ProjectedActivityCompat.create(this@CameraActionInputSnippetActivity)
                        try {
                            projectedActivity.projectedInputEvents.collect { inputEvent ->
                                if (inputEvent.inputAction == TOGGLE_APP_CAMERA) {
                                    withContext(Dispatchers.Main) {
                                        onCameraActionTriggered()
                                    }
                                }
                            }
                        } finally {
                            projectedActivity.close()
                        }
                    } catch (e: CancellationException) {
                        throw e
                    } catch (e: Exception) {
                        Log.w("CameraActionSnippet", "ProjectedActivityCompat unavailable: ${e.message}")
                    }
                }
            }
        }

        setContent {
            GlimmerTheme {
                TouchpadInputSnippet(
                    onTap = { Log.i("CameraActionSnippet", "Touchpad tapped") }
                )
            }
        }
    }

    private fun onCameraActionTriggered() {
        Log.i("CameraActionSnippet", "Camera action button double-pressed!")
    }
}

Sprawdzanie ogólnych zdarzeń ruchu

Użyj dispatchGenericMotionEvent, aby sprawdzić ogólne zdarzenia ruchu dostarczane do wyświetlanej aktywności aplikacji. Ogólne zdarzenia ruchu są dostarczane na granicy aktywności i nie wymagają skupionego komponentu Jetpack Compose Glimmer.

MotionEvent może zawierać:

Nie każda wartość jest znacząca dla każdego działania. Zanim potraktujesz surowe zdarzenie jako ukończony gest, sprawdź działanie i źródło.

class MotionGestureInputSnippetActivity : ComponentActivity() {

    override fun dispatchGenericMotionEvent(ev: MotionEvent): Boolean {
        val actionName = when (ev.actionMasked) {
            MotionEvent.ACTION_DOWN -> "ACTION_DOWN" // First contact with the glasses touchpad
            MotionEvent.ACTION_MOVE -> "ACTION_MOVE" // Contact moving across the glasses touchpad
            MotionEvent.ACTION_UP -> "ACTION_UP"     // Contact lifted from the glasses touchpad
            else -> "ACTION_${ev.actionMasked}"
        }

        Log.d(
            "MotionGestureSnippet",
            "MotionEvent: action=$actionName x=${ev.x} y=${ev.y}"
        )

        // Delegate to super unless intentionally consuming the event
        return super.dispatchGenericMotionEvent(ev)
    }
}

Zwróć wartość true tylko wtedy, gdy aktywność celowo zużywa zdarzenie. W przeciwnym razie zwróć wartość super.dispatchGenericMotionEvent(ev), aby zdarzenie mogło być dalej przekazywane w normalny sposób.

Obsługa gestu cofania w systemie

Gdy ekran wymaga niestandardowego zachowania cofania, aplikacja powinna obsługiwać gest cofania w okularach za pomocą tych samych interfejsów API Androida, których używasz w przypadku innych aktywności, np. OnBackPressedDispatcher i OnBackPressedCallback.

Gest użytkownika zależy od typu okularów:

  • W przypadku okularów z wyświetlaczem przesunięcie palcem w dół po touchpadzie powoduje wykonanie gestu cofania w systemie.
  • W przypadku okularów audio przesunięcie palcem w lewo po touchpadzie powoduje wykonanie gestu cofania w systemie.

Zarejestruj wywołanie zwrotne cofania, gdy bieżący ekran musi przechwycić cofanie, np. zamknąć nakładkę lub wyświetlić potwierdzenie wyjścia.

class BackGestureInputSnippetActivity : ComponentActivity() {

    private val backCallback = object : OnBackPressedCallback(true) {
        override fun handleOnBackPressed() {
            onBackGestureReceived()
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Register back gesture callback with Activity's onBackPressedDispatcher
        onBackPressedDispatcher.addCallback(this, backCallback)
    }

    private fun onBackGestureReceived() {
        Log.i("BackGestureSnippet", "System back gesture intercepted")
    }
}

Wywołanie zwrotne powinno być włączone tylko wtedy, gdy aktywny ekran ma przechwytywać cofanie. Wyłącz lub usuń wywołanie zwrotne, gdy cofanie ma być obsługiwane przez domyślne zachowanie systemu lub nawigacji.

Dalsze kroki

Po zaimplementowaniu obsługi danych wejściowych dla tych zdarzeń możesz dowiedzieć się więcej o obsłudze innych typów zdarzeń wejściowych w tych tematach:

Wstecz
Przegląd
Dalej
Obsługa danych wejściowych audio za pomocą automatycznego rozpoznawania mowy