Tworzenie pierwszego działania na potrzeby okularów AI

Odpowiednie urządzenia XR
Te wskazówki pomogą Ci tworzyć aplikacje na te typy urządzeń XR.
Więcej informacji o typach urządzeń XR
Okulary AI
Więcej informacji o typach urządzeń XR

Funkcje okularów AI są oparte na istniejącym Activityframeworku API Androida i obejmują dodatkowe koncepcje, które uwzględniają unikalne aspekty okularów AI. W przeciwieństwie do zestawów XR, które uruchamiają na urządzeniu pełny plik APK, okulary AI korzystają z dedykowanej aktywności uruchamianej w ramach istniejącej aplikacji na telefonie. Ta aktywność jest wyświetlana z urządzenia hosta na okularach AI.

Aby utworzyć funkcję okularów AI w aplikacji, rozszerz istniejącą aplikację na telefon, tworząc nowy projekt Activity dla okularów AI. To działanie jest głównym punktem wejścia do aplikacji na okularach z AI. To podejście upraszcza proces programowania, ponieważ możesz udostępniać i ponownie wykorzystywać logikę biznesową w aplikacjach na telefon i okulary AI.

Zgodność wersji

Sprawdź wymagania dotyczące zgodności pakietu SDK na Androida w przypadku pakietu Jetpack XR SDK.

Zależności

Dodaj te zależności bibliotek dotyczące okularów z AI:

Groovy

dependencies {
    implementation "androidx.xr.runtime:runtime:1.0.0-alpha10"
    implementation "androidx.xr.glimmer:glimmer:1.0.0-alpha06"
    implementation "androidx.xr.projected:projected:1.0.0-alpha04"
    implementation "androidx.xr.arcore:arcore:1.0.0-alpha10"
}

Kotlin

dependencies {
    implementation("androidx.xr.runtime:runtime:1.0.0-alpha10")
    implementation("androidx.xr.glimmer:glimmer:1.0.0-alpha06")
    implementation("androidx.xr.projected:projected:1.0.0-alpha04")
    implementation("androidx.xr.arcore:arcore:1.0.0-alpha10")
}

Zadeklaruj aktywność w pliku manifestu aplikacji

Podobnie jak w przypadku innych typów aktywności musisz zadeklarować aktywność w pliku manifestu aplikacji, aby system mógł ją zobaczyć i uruchomić.

<application>
  <activity
      android:name="com.example.xr.projected.GlassesMainActivity"
      android:exported="true"
      android:requiredDisplayCategory="xr_projected"
      android:label="Example AI Glasses activity">
      <intent-filter>
          <action android:name="android.intent.action.MAIN" />
      </intent-filter>
  </activity>
</application>

Najważniejsze informacje o kodzie

  • Określa xr_projected dla atrybutu android:requiredDisplayCategory, aby poinformować system, że ta aktywność powinna używać prognozowanego kontekstu do uzyskiwania dostępu do sprzętu z połączonego urządzenia.

Tworzenie aktywności

Następnie utworzysz małą aktywność, która będzie wyświetlać coś na okularach z AI, gdy tylko wyświetlacz będzie włączony.

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

    private var displayController: ProjectedDisplayController? = null
    private var isVisualUiSupported by mutableStateOf(false)
    private var areVisualsOn by mutableStateOf(true)

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

        lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onDestroy(owner: LifecycleOwner) {
                displayController?.close()
                displayController = null
            }
        })

        lifecycleScope.launch {
            // Check device capabilities
            val projectedDeviceController = ProjectedDeviceController.create(this@GlassesMainActivity)
            isVisualUiSupported = projectedDeviceController.capabilities.contains(CAPABILITY_VISUAL_UI)

            val controller = ProjectedDisplayController.create(this@GlassesMainActivity)
            displayController = controller
            val observer = GlassesLifecycleObserver(
                context = this@GlassesMainActivity,
                controller = controller,
                onVisualsChanged = { visualsOn -> areVisualsOn = visualsOn }
            )
            lifecycle.addObserver(observer)
        }

        setContent {
            GlimmerTheme {
                HomeScreen(
                    areVisualsOn = areVisualsOn,
                    isVisualUiSupported = isVisualUiSupported,
                    onClose = { finish() }
                )
            }
        }
    }
}
GlassesMainActivity.kt

Najważniejsze informacje o kodzie

Implementowanie funkcji typu „composable”

Utworzone działanie odwołuje się do HomeScreen funkcji kompozycyjnej, którą musisz wdrożyć. Poniższy kod używa Jetpack Compose Glimmer do zdefiniowania funkcji kompozycyjnej, która może wyświetlać tekst na wyświetlaczu okularów AI:

@Composable
fun HomeScreen(
    areVisualsOn: Boolean,
    isVisualUiSupported: Boolean,
    onClose: () -> Unit,
    modifier: Modifier = Modifier
) {
    Box(
        modifier = modifier
            .surface(focusable = false)
            .fillMaxSize(),
        contentAlignment = Alignment.Center
    ) {
        if (isVisualUiSupported) {
            Card(
                title = { Text("Android XR") },
                action = {
                    Button(onClick = onClose) {
                        Text("Close")
                    }
                }
            ) {
                if (areVisualsOn) {
                    Text("Hello, AI Glasses!")
                } else {
                    Text("Display is off. Audio guidance active.")
                }
            }
        } else {
            Text("Audio Guidance Mode Active")
        }
    }
}
GlassesMainActivity.kt

Najważniejsze informacje o kodzie

  • Zgodnie z definicją podaną wcześniej w aktywności funkcja HomeScreen obejmuje treści, które użytkownik widzi, gdy wyświetlacz okularów AI jest włączony.
  • Komponent Jetpack Compose Glimmer Text wyświetla na ekranie okularów tekst „Hello, AI Glasses!”.
  • Glimmer Jetpack Compose Button zamyka aktywność, wywołując finish() przez onClose w aktywności na okularach AI.

Sprawdzanie, czy okulary AI są połączone

Aby przed uruchomieniem aktywności sprawdzić, czy okulary AI użytkownika są połączone z telefonem, użyj metody ProjectedContext.isProjectedDeviceConnected. Ta metoda zwraca Flow<Boolean>, które aplikacja może obserwować, aby otrzymywać aktualizacje stanu połączenia w czasie rzeczywistym.

Rozpocznij aktywność

Po utworzeniu podstawowej aktywności możesz ją uruchomić na okularach. Aby uzyskać dostęp do sprzętu okularów, aplikacja musi uruchomić aktywność z określonymi opcjami, które informują system o użyciu prognozowanego kontekstu, jak pokazano w tym kodzie:

val options = ProjectedContext.createProjectedActivityOptions(context)
val intent = Intent(context, GlassesMainActivity::class.java)
context.startActivity(intent, options.toBundle())

PhoneMainActivity.kt

Metoda createProjectedActivityOptions w ProjectedContext generuje opcje niezbędne do rozpoczęcia aktywności w przewidywanym kontekście. Parametr context może być kontekstem z telefonu lub okularów.

Dalsze kroki

Po utworzeniu pierwszej aktywności na okulary AI możesz poznać inne sposoby rozszerzania ich funkcjonalności:

Wstecz
Przegląd
Dalej
Planowanie obsługi różnych typów okularów AI