Créer votre première activité pour les lunettes d'IA

Appareils XR concernés
Ces conseils vous aident à créer des expériences pour ces types d'appareils XR.
En savoir plus sur les types d'appareils XR →
Lunettes IA
En savoir plus sur les types d'appareils XR →

L'expérience des lunettes d'IA repose sur le framework Activity et l'API Android existants, et inclut des concepts supplémentaires pour prendre en charge les aspects uniques des lunettes d'IA. Contrairement aux casques XR qui exécutent un APK complet sur l'appareil, les lunettes IA utilisent une activité dédiée qui s'exécute dans l'application existante de votre téléphone. Cette activité est projetée de l'appareil hôte vers les lunettes IA.

Pour créer l'expérience de lunettes IA de votre application, vous devez étendre votre application mobile existante en créant un Activity projeté pour les lunettes IA. Cette activité sert de point d'entrée principal pour le lancement de votre application sur des lunettes IA. Cette approche simplifie le développement, car vous pouvez partager et réutiliser la logique métier entre vos expériences sur téléphone et sur lunettes d'IA.

Compatibilité des versions

Consultez les exigences de compatibilité du SDK Android pour le SDK Jetpack XR.

Dépendances

Ajoutez les dépendances de bibliothèque suivantes pour les lunettes IA :

Groovy

dependencies {
    implementation "androidx.xr.runtime:runtime:1.0.0-alpha11"
    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-alpha11")
    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")
}

Déclarer votre activité dans le fichier manifeste de votre application

Comme pour les autres types d'activités, vous devez déclarer votre activité dans le fichier manifeste de votre application pour que le système puisse la voir et l'exécuter.

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

Points clés concernant le code

  • Spécifie xr_projected pour l'attribut android:requiredDisplayCategory afin d'indiquer au système que cette activité doit utiliser un contexte projeté pour accéder au matériel d'un appareil connecté.

Créer votre activité

Ensuite, vous allez créer une petite activité qui peut afficher quelque chose sur les lunettes d'IA chaque fois que l'écran est allumé.

@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

Points clés concernant le code

Implémenter le composable

L'activité que vous avez créée fait référence à une fonction composable HomeScreen que vous devez implémenter. Le code suivant utilise Jetpack Compose Glimmer pour définir un composable qui peut afficher du texte sur l'écran des lunettes d'IA :

@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

Points clés concernant le code

  • Comme vous l'avez défini précédemment dans votre activité, la fonction HomeScreen inclut le contenu composable que l'utilisateur voit lorsque l'écran des lunettes IA est allumé.
  • Le composant Glimmer Text de Jetpack Compose affiche le texte "Hello, AI Glasses!" sur l'écran des lunettes.
  • Le Button Glimmer de Jetpack Compose ferme l'activité en appelant finish() via onClose dans l'activité des lunettes d'IA.

Vérifier si les lunettes IA sont connectées

Pour déterminer si les lunettes IA d'un utilisateur sont connectées à son téléphone avant de lancer votre activité, utilisez la méthode ProjectedContext.isProjectedDeviceConnected. Cette méthode renvoie un Flow<Boolean> que votre application peut observer pour obtenir des informations en temps réel sur l'état de la connexion.

Démarrer votre activité

Maintenant que vous avez créé une activité de base, vous pouvez la lancer sur vos lunettes. Pour accéder au matériel des lunettes, votre application doit démarrer votre activité avec des options spécifiques qui indiquent au système d'utiliser un contexte projeté, comme indiqué dans le code suivant :

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

PhoneMainActivity.kt

La méthode createProjectedActivityOptions dans ProjectedContext génère les options nécessaires pour démarrer votre activité dans un contexte projeté. Le paramètre context peut être un contexte provenant du téléphone ou des lunettes.

Étapes suivantes

Maintenant que vous avez créé votre première activité pour les lunettes IA, découvrez d'autres façons d'étendre leurs fonctionnalités :

Précédent
Aperçu
Suivant
Prévoir la compatibilité avec différents types de lunettes IA