Créer votre première application professionnelle XREAL Aura avec Android Studio

Créer votre première application professionnelle XREAL Aura avec Android Studio

Synthèse

Ce guide explique comment créer une application professionnelle XREAL Aura dans Android Studio avec Kotlin et le Jetpack XR SDK. Vous allez créer un projet, ajouter la bibliothèque d'interface spatiale, coller un petit exemple de panneau de tâches et l'exécuter dans l'émulateur XR Glasses avant de le tester sur le matériel Aura.

L'exemple affiche des instructions de travail et permet aux utilisateurs de confirmer chaque tâche. Il s'agit d'un point de départ pour une application professionnelle, sans enregistrement permanent du travail ni vérification qu'une tâche physique a bien été effectuée. Le code suit la documentation examinée, mais il n'a été ni compilé ni testé sur du matériel Aura.

Introduction

La création d'une application professionnelle XREAL Aura commence dans Android Studio, où vous écrivez du code Kotlin et utilisez le Jetpack XR SDK pour ajouter une interface spatiale. Ce guide vous accompagne de la création d'un projet jusqu'à son exécution dans un émulateur et à son test sur Aura. À titre d'exemple simple, vous allez créer un panneau qui affiche des instructions de travail et permet à un utilisateur de confirmer chaque tâche.

XREAL Aura associe des lunettes filaires à un boîtier de calcul (puck) Android XR. Suivez le flux de travail Android XR destiné aux lunettes XR filaires, et non le flux distinct prévu pour les lunettes audio et à affichage projetées depuis un téléphone. Pour le contexte matériel, consultez la présentation de XREAL Aura par VRX et la page officielle d'Aura de XREAL. [1]

Avant de commencer

· Utilisez un ordinateur approuvé par l'entreprise et disposant d'un accès à internet pour les premiers téléchargements

· Consultez la configuration système requise pour l'émulateur XR de Google, qui couvre actuellement des configurations Windows et macOS prises en charge [2]

· Pour les tests physiques, procurez-vous les lunettes Aura, leur boîtier de calcul et les instructions de connexion développeur du kit

Disponibilité : vérifiez l'approvisionnement dans votre région auprès de VR Expert. La page actuelle de XREAL donne la priorité aux États-Unis, au Canada, au Japon et à la Corée du Sud ; d'anciennes listes de réservation ne doivent pas être considérées comme une confirmation de livraison en Europe. [1]

Étape 1 Installer Android Studio et ses outils SDK

Commencez par installer Android Studio et les outils SDK nécessaires pour compiler l'application, exécuter un appareil XR simulé et vous connecter au matériel.

Google recommande Android Studio Canary pour le développement XR. Canary est une version préliminaire qui propose des outils plus récents et des fonctionnalités potentiellement inachevées ; vous pouvez l'installer à côté de votre version existante d'Android Studio.

· Ouvrez Android Studio Preview, téléchargez le programme d'installation approprié et suivez l'assistant d'installation jusqu'au bout.

· Sur l'écran d'accueil d'Android Studio, sélectionnez More Actions > SDK Manager. Si un projet est déjà ouvert, utilisez Tools > SDK Manager dans le menu supérieur.

· Dans la fenêtre de paramètres du SDK Manager, repérez les onglets SDK Platforms et SDK Tools, au-dessus de la liste des paquets installables. Les deux onglets font partie de la même fenêtre SDK Manager.

· Sélectionnez SDK Tools. Cochez Android SDK Build-Tools, Android Emulator et Android SDK Platform-Tools. Laissez-les sélectionnés s'ils sont déjà installés ; appliquez les mises à jour disponibles. Build-Tools prépare le fichier d'installation de l'application, Emulator exécute les appareils simulés et Platform-Tools comprend l'outil de connexion aux appareils ADB.

· Cliquez sur Apply, vérifiez les téléchargements sélectionnés, acceptez les licences requises et patientez pendant l'installation. Cliquez sur OK pour fermer la fenêtre.

L'onglet SDK Platforms installe la plateforme Android utilisée pour compiler l'application. La version requise dépend de la configuration du projet. Créez le projet à l'étape 2, puis utilisez son paramètre compileSdk pour sélectionner la plateforme correspondante. L'étape 6 traite de l'image système de l'émulateur XR, qui fournit le système d'exploitation de l'appareil simulé.

Point de contrôle : les trois outils SDK sont installés. Vous pouvez maintenant créer le projet. [3, 13]

Étape 2 Créer le projet d'application professionnelle XREAL Aura

Le modèle de projet XR crée les fichiers de départ et la configuration de compilation de l'application. Suivez les instructions de Google pour les projets Android XR correspondant à la version de Studio installée. [4]

· Dans Android Studio, revenez à l'écran d'accueil et cliquez sur New Project, ou choisissez File > New > New Project.

· Sélectionnez XR dans la liste des modèles, puis le modèle destiné aux casques XR et aux lunettes XR filaires. La page de projet de Google ne nomme plus les modèles (elle indique de choisir le modèle correspondant au type d'appareil XR pour lequel vous voulez développer) et les noms peuvent changer d'une version Canary à l'autre ; reprenez donc le nom exact affiché dans l'IDE pour la capture d'écran. Ne choisissez pas le modèle pour lunettes audio ou à affichage, qui crée une expérience projetée depuis un téléphone.

· Cliquez sur Next. Saisissez AuraTaskPanel dans Name. Dans Package name, saisissez com.example.aurataskpanel pour ce tutoriel. Sélectionnez Kotlin si un choix de langage apparaît. Le nom de package identifie le code de l'application et peut être personnalisé pour votre organisation. Il se saisit dans Android Studio sous la forme d'un identifiant séparé par des points, sans https:// ni chemin d'adresse web.

Conservez ensuite les paramètres de compilation générés par le modèle et cliquez sur Finish. Attendez la fin de la première synchronisation Gradle. La synchronisation permet à Android Studio de lire la configuration de compilation et de résoudre ses dépendances.

Ouvrez View > Tool Windows > Project, puis sélectionnez Android dans le sélecteur d'affichage du volet. Vous utiliserez les fichiers suivants :

· MainActivity.kt : app > kotlin+java > com.example.aurataskpanel. Ce fichier contient le point d'entrée et l'interface de l'application ; certaines versions nomment le dossier source java

· AndroidManifest.xml : app > manifests. Ce fichier déclare le point d'entrée, les autorisations et les paramètres de lancement de l'application

· build.gradle.kts (Module :app) : Gradle Scripts. Ce fichier configure la compilation et les bibliothèques de l'application

Installer la plateforme demandée par votre projet

Le paramètre compileSdk indique à Android Studio quel ensemble d'API Android utiliser pour compiler l'application. Installez la plateforme SDK correspondante ; ne la choisissez pas uniquement en fonction de la marque des lunettes.

· Dans le volet Project d'Android Studio, ouvrez Gradle Scripts > build.gradle.kts (Module :app). Dans le bloc android, repérez compileSdk. Une valeur telle que compileSdk = 36 signifie que le projet a besoin de Android API 36. Ce nombre est un exemple, et non une valeur obligatoire pour tout projet Aura.

· Si la valeur renvoie à une entrée du catalogue, comme libs.versions.compileSdk, ouvrez Gradle Scripts > libs.versions.toml et lisez la valeur référencée. Si le modèle utilise un nom de préversion ou une configuration compileSdk imbriquée, conservez ce paramètre et utilisez la plateforme correspondante.

· Ouvrez Tools > SDK Manager > SDK Platforms. Sélectionnez la ligne dont la colonne API Level correspond au paramètre du projet. Cliquez sur Apply, terminez le téléchargement, puis cliquez sur OK.

· Revenez au projet et sélectionnez File > Sync Project with Gradle Files, ou Sync Now si un bandeau le propose. La synchronisation Gradle lit les paramètres de compilation et télécharge les bibliothèques requises par le projet.

Conservez le paramètre de plateforme du modèle. Si Android Studio signale une plateforme manquante, installez-la plutôt que d'abaisser compileSdk pour éviter le téléchargement. L'image d'appareil XR utilisée pour les tests se sélectionne séparément à l'étape 6. [13]

Point de contrôle : la plateforme SDK requise est installée et la fenêtre d'outils Build ou Sync ne contient aucune erreur non résolue.

Étape 3 Ajouter la bibliothèque XR et vérifier la compatibilité Kotlin

Ajoutez Jetpack Compose for XR pour doter l'application de composants de panneaux spatiaux, et vérifiez la compatibilité Kotlin afin que le projet puisse compiler cette bibliothèque sans erreur de version. Cet exemple utilise XR Compose 1.0.0-beta02 (21-10-2026, toujours la version la plus récente), qui requiert Kotlin 2.2 selon les notes de version de Google. Ces mêmes notes indiquent que la beta02 dépend de SceneCore 1.0.0-rc01, qui présente une fuite de mémoire connue ; ajoutez donc implementation (“androidx.xr.scenecore:1.0.0”) ou une version plus récente à la ligne Compose de l'étape 3.

Vérifier une fois la version de Kotlin

· Dans Android Studio, développez Gradle Scripts, puis ouvrez libs.versions.toml. Lorsqu'il est présent, ce fichier constitue la liste centrale des versions de bibliothèques et de plugins du projet.

· Sous [versions], repérez l'entrée Kotlin, généralement kotlin = "2.2.0" ou une autre version 2.2.x. Conservez la version compatible fournie par le modèle actuel.

· Si le projet utilise le plugin org.jetbrains.kotlin.plugin.compose, sa version doit correspondre à celle de Kotlin. Les modèles font généralement pointer les deux vers la même entrée de version Kotlin ; préservez ce lien.

· S'il n'y a ni entrée Kotlin ni catalogue, examinez le fichier build.gradle.kts de premier niveau pour repérer des plugins Kotlin déclarés explicitement. Certaines configurations de compilation plus récentes gèrent Kotlin via l'outillage de compilation Android. Dans ce cas, conservez la configuration générée et vérifiez la compatibilité Kotlin de la chaîne d'outils si une erreur de compilation apparaît ; n'ajoutez pas un second plugin Kotlin uniquement pour créer une entrée de version.

Si le modèle fournit déjà un outillage Kotlin compatible, ne changez rien. Si une compilation signale que Kotlin est trop ancien pour la bibliothèque XR, mettez à jour ensemble l'outillage Kotlin du projet et, le cas échéant, le plugin de compilateur Compose correspondant, en utilisant la configuration prise en charge pour ce modèle. Évitez de modifier des paramètres de compilation sans rapport.

Ajouter la dépendance d'interface spatiale

· Ouvrez Gradle Scripts > build.gradle.kts (Module :app).

· Repérez le bloc dependencies { ... } existant.

· Recherchez une dépendance XR Compose, écrite directement ou via un alias tel que implementation(libs.androidx.xr.compose). Si un alias existe déjà, définissez la version XR Compose à laquelle il renvoie sur 1.0.0-beta02 dans libs.versions.toml. N'ajoutez pas deux fois la même bibliothèque.

· Si XR Compose est absent, ajoutez cette ligne dans le bloc dependencies existant :

implementation("androidx.xr.compose:compose:1.0.0-beta02")

Conservez les autres dépendances du modèle. En particulier, le code ci-dessous utilise la bibliothèque standard Material 3, qui fournit ses boutons, son texte et son thème, ainsi que Activity Compose, qui héberge le contenu Compose dans une Activity Android.

Synchroniser et poursuivre

Cliquez sur Sync Now dans le bandeau de l'éditeur, ou sur File > Sync Project with Gradle Files. Attendez la fin du téléchargement et de la configuration.

Point de contrôle : la synchronisation se termine sans erreur de dépendance ni de compatibilité Kotlin. Si elle réussit, conservez les autres paramètres de compilation générés, puis ouvrez MainActivity.kt pour ajouter l'interface. Si la synchronisation signale une erreur de dépendance, comparez le composant indiqué avec la page de configuration du Jetpack XR SDK de Google. [6]

Étape 4 Créer le panneau de tâches en Kotlin

L'interface affiche le texte de la tâche avec un bouton Mark complete et un bouton Restart demo. Les instructions d'exemple pourront ensuite être remplacées par une procédure de travail approuvée.

Toujours dans Android Studio, dans MainActivity.kt, conservez la ligne package si votre package est différent, puis remplacez le reste du fichier par le code ci-dessous. Supprimez de ce fichier les anciennes fonctions d'exemple et de prévisualisation du modèle afin qu'il n'y ait qu'une seule MainActivity. Une Activity est un point d'entrée Android qui héberge une interface. L'exemple ci-dessous inclut l'Activity et ses imports.

package com.example.aurataskpanel
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.xr.compose.platform.LocalSpatialCapabilities
import androidx.xr.compose.spatial.Subspace
import androidx.xr.compose.subspace.SpatialPanel
import androidx.xr.compose.subspace.layout.SubspaceModifier
import androidx.xr.compose.subspace.layout.height
import androidx.xr.compose.subspace.layout.width
class MainActivity : ComponentActivity() {
	override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    	setContent {
            MaterialTheme(colorScheme = darkColorScheme()) {
                TaskApp()
        	}
    	}
	}
}
@Composable
private fun TaskApp() {
	val steps = listOf(
    	"Check that the training area is clear.",
        "Confirm the training device is charged.",
    	"Open the approved training application."
	)
	var completed by rememberSaveable { mutableIntStateOf(0) }
	val content: @Composable () -> Unit = {
    	TaskPanel(
        	steps = steps,
            completed = completed,
            onComplete = {
            	if (completed < steps.size) completed++
        	},
            onRestart = { completed = 0 }
    	)
	}
	if (LocalSpatialCapabilities.current.isSpatialUiEnabled) {
    	Subspace {
            SpatialPanel(
                modifier = SubspaceModifier
                    .width(640.dp)
                    .height(540.dp)
        	) {
                content()
        	}
    	}
	} else {
    	content()
	}
}
@Composable
private fun TaskPanel(
	steps: List<String>,
	completed: Int,
	onComplete: () -> Unit,
	onRestart: () -> Unit
) {
	val finished = completed >= steps.size
    Surface(modifier = Modifier.fillMaxSize()) {
    	Column(
            modifier = Modifier
                .fillMaxSize()
                .verticalScroll(rememberScrollState())
                .padding(24.dp),
            verticalArrangement = Arrangement.spacedBy(16.dp)
    	) {
            Text("Training station preparation", fontSize = 28.sp)
            Text("Demo procedure v1.0", fontSize = 18.sp)
        	Text(
                "$completed of ${steps.size} tasks acknowledged",
                fontSize = 20.sp
        	)
        	Text(
            	if (finished) "Checklist complete"
                else "Task ${completed + 1}: ${steps[completed]}",
                fontSize = 26.sp
        	)
        	Text(
                "Your confirmation does not verify physical work.",
                fontSize = 18.sp
        	)
        	Button(
                onClick = onComplete,
                enabled = !finished,
                modifier = Modifier
                    .fillMaxWidth()
                    .heightIn(min = 64.dp)
        	) {
                Text("Mark complete", fontSize = 22.sp)
        	}
            OutlinedButton(
                onClick = onRestart,
                modifier = Modifier
                    .fillMaxWidth()
                    .heightIn(min = 64.dp)
        	) {
                Text("Restart demo", fontSize = 22.sp)
        	}
    	}
	}
}

Ce que fait le code

· steps contient le texte des instructions

· completed compte les confirmations et empêche d'aller au-delà de la dernière tâche

· rememberSaveable conserve cette petite valeur lors des recréations d'écran et des restaurations d'état prises en charge par Android ; il ne s'agit pas d'un stockage permanent

· LocalSpatialCapabilities vérifie si l'interface spatiale est disponible [7]

· Subspace crée une zone pour le contenu spatial, et SpatialPanel y place l'interface [8]

· La branche de repli affiche le même contenu dans une fenêtre normale lorsque l'interface spatiale n'est pas disponible

L'unité dp adapte les dimensions de mise en page à la densité de l'écran ; sp adapte le texte et respecte les préférences de taille de police. Le conteneur défilant garde accessibles les instructions plus longues. Considérez la taille du panneau comme un point de départ et vérifiez la lisibilité sur Aura.

Point de contrôle : Android Studio reconnaît les imports et n'affiche aucune erreur de syntaxe Kotlin. Si la bibliothèque installée exige une activation explicite (opt-in) d'API expérimentale, utilisez l'annotation exacte indiquée par le diagnostic du compilateur et consultez la référence API de cette version.

Étape 5 Vérifier le démarrage de l'application dans Android XR

Configurez le mode de lancement afin qu'Android XR puisse ouvrir l'application avec la disposition spatiale utilisée dans cet exemple.

Sur les lunettes Aura, Home Space et Full Space sont déjà intégrés à Android XR et déterminent la façon dont les applications en cours d'exécution s'affichent. L'émulateur XR Glasses fournit ces modes pour le développement ; aucune installation séparée n'est donc nécessaire.

Dans le volet Project d'Android Studio, ouvrez app > manifests > AndroidManifest.xml et examinez l'entrée MainActivity. Conservez son filtre d'intention MAIN et LAUNCHER, son paramètre exported et le thème généré. Pour un Full Space géré par Compose, la propriété concernée figure ci-dessous. Si le modèle déclare déjà une propriété de lancement au niveau de l'application ou de l'Activity, modifiez la valeur existante concernée au lieu de la dupliquer. [9]

<!-- À l'intérieur de l'élément MainActivity existant -->
<property
    android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
    android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />

Un Full Space géré signifie qu'Android gère la scène spatiale de l'Activity. La valeur UNMANAGED est destinée aux applications dont le rendu passe par OpenXR, une interface XR multiplateforme ; cet exemple Compose ne l'utilise pas. Consultez la référence des constantes du manifeste lorsque vous comparez des modèles. [9]

Dans l'élément application existant, conservez ou ajoutez également android:enableOnBackInvokedCallback="true" afin que le panneau spatial reçoive les événements de retour, comme le documente le guide de Google sur les panneaux ; son exemple le définit sur l'élément activity, mais il est également valable sur l'élément application. N'ajoutez pas d'autorisations de caméra, de microphone ou de compréhension de la scène pour cette liste de contrôle statique. Elle ne lit pas la pièce et n'identifie pas d'objets. [8]

Étape 6 Créer un émulateur de lunettes XR et exécuter l'application

Exécutez l'application sur un appareil de lunettes XR simulé avant de connecter Aura. Un émulateur simule un appareil sur votre ordinateur ; un AVD en est la configuration enregistrée.

· Dans Android Studio, ouvrez Tools > Device Manager. Cliquez sur la commande d'ajout d'appareil et choisissez Create Virtual Device.

· Sous Form Factor, choisissez XR, puis XR Glasses. Cliquez sur Next.

· Sélectionnez l'image système Preview API requise pour le profil XR Glasses et téléchargez-la si vous y êtes invité. Choisissez l'architecture d'image prise en charge qui correspond à votre ordinateur. Terminez la configuration.

· Démarrez l'AVD à l'aide de sa commande de lecture. Attendez que l'environnement Android XR ait fini de se charger.

· Dans la barre d'outils supérieure d'Android Studio, sélectionnez la configuration d'exécution app et l'appareil XR Glasses en cours d'exécution. Cliquez sur Run, le triangle vert.

L'émulateur installe et ouvre l'application. Utilisez ses commandes de saisie pour activer Mark complete. Si le panneau reste en Home Space, vérifiez le manifeste et les commandes Full Space de l'environnement avant de modifier la mise en page Kotlin. Consultez les instructions officielles relatives aux AVD.

Effectuez ce test d'acceptation :

· Le premier écran indique zéro tâche confirmée sur trois ainsi que la première instruction

· Chaque activation de Mark complete fait avancer d'exactement une instruction

· La troisième activation affiche Checklist complete et désactive Mark complete

· Restart demo rétablit la première instruction et zéro confirmation

· Le texte plus long reste accessible par défilement

· Le contenu s'affiche toujours lorsque l'interface spatiale n'est pas disponible

Un test réussi dans l'émulateur valide une partie de la logique et de la mise en page de l'application. Il ne valide ni l'optique d'Aura, ni la fiabilité de la saisie, ni l'adéquation au poste de travail.

Étape 7 Déployer sur du matériel Aura autorisé

Les étapes ci-dessous suivent la procédure de débogage Android standard. Les menus et options de connexion d'Aura peuvent varier selon la version logicielle ; suivez donc les instructions propres au kit lorsqu'elles diffèrent.

Connecter Aura et exécuter l'application

· Démarrez Aura avec les lunettes connectées et ouvrez l'application Settings d'Aura

· Sur Aura, dans l'interface des paramètres, activez les Developer options et le débogage en suivant les instructions du kit ; procurez-vous le guide de configuration développeur si ces commandes ne sont pas disponibles

· Connectez l'ordinateur au port de charge (Charging Port, côté gauche) du boîtier de calcul à l'aide d'un câble USB de données et laissez les lunettes branchées sur le port des lunettes (Glasses Port, côté droit) ; si cela ne fonctionne pas, branchez-le sur le port de droite pour bénéficier de la prise en charge complète d'ADB.

· Acceptez l'invite d'autorisation de débogage de l'appareil ; un appareil géré peut nécessiter l'approbation d'un administrateur

· Dans la barre d'outils supérieure d'Android Studio, sélectionnez Aura dans la liste déroulante des appareils et cliquez sur Run

· Sur Aura, répétez les vérifications du panneau de tâches de l'étape 6, y compris l'avancement des tâches et le redémarrage de la liste de contrôle

Résoudre les problèmes de connexion de l'appareil

Si Aura n'apparaît pas dans le sélecteur de cible d'Android Studio, vérifiez la connexion à l'aide d'ADB :

  1. Ouvrez View > Tool Windows > Terminal dans Android Studio.
  1. Exécutez la commande suivante :
adb devices -l

Vérifiez le résultat :

· Si votre appareil apparaît avec la mention device, il est connecté et autorisé.

· S'il affiche unauthorized, mettez les lunettes et acceptez l'invite de débogage USB à l'écran.

· Si la liste est vide, vérifiez à nouveau le câble USB de données, assurez-vous que le boîtier de calcul est allumé et vérifiez que le débogage USB est toujours activé dans Settings.

Conclusion

La création d'une première application professionnelle XREAL Aura commence avec Android Studio, Kotlin et le Jetpack XR SDK, puis passe d'un simple panneau d'instructions de travail aux tests dans l'émulateur et au déploiement sur du matériel autorisé. Cette approche offre aux entreprises un moyen ciblé d'évaluer si des instructions spatiales améliorent un flux de travail réel avant d'investir dans des intégrations et un déploiement à l'échelle de la flotte. Une fois le panneau lisible, utilisable et validé sur Aura, l'étape suivante consiste à relier des procédures approuvées et des enregistrements de travail fiables aux systèmes de l'entreprise.

Contactez VR Expert pour parler de la disponibilité d'Aura et des exigences en matière de matériel, de développement logiciel et d'assistance pour votre projet pilote en entreprise.

João Noronha

Rédigé par

João Noronha

Spécialiste XR et contenu immersif chez VR Expert

João Noronha est spécialiste XR et contenu immersif chez VR Expert, avec un fort intérêt pour les technologies émergentes et leurs applications concrètes. Il se concentre sur la transformation des évolutions complexes en VR, AR, lunettes IA et technologies immersives en contenus clairs et pratiques destinés aux entreprises et professionnels qui explorent le secteur XR.

Questions fréquentes

Cet article

Oui. Commencez avec l'émulateur Android XR Glasses pour développer l'interface et l'enchaînement des tâches. Des tests physiques sur Aura restent nécessaires avant un projet pilote sur le lieu de travail.

Non. Android Studio, Kotlin et Jetpack Compose for XR conviennent à cet exemple axé sur l'interface. Unity est un moteur de développement distinct, qui peut convenir à des projets comportant beaucoup de contenu 3D interactif.

Non. Il fournit des fonctionnalités XR. Votre équipe doit encore mettre en œuvre et valider les exigences en matière de sécurité, de stockage des données, d'identité, de distribution, de support et d'intégration.

Non. Elle affiche du texte stocké localement et enregistre les confirmations dans l'état de l'interface utilisateur. La reconnaissance d'équipements, la compréhension de la scène et des enregistrements de travail vérifiés nécessitent une conception et une mise en œuvre supplémentaires.

Cet exemple n'implémente pas d'ancre physique persistante. Une ancre est une référence spatiale utilisée pour positionner du contenu par rapport à un emplacement ; un placement propre à une machine nécessite un flux d'ancrage supplémentaire pris en charge ainsi qu'une validation sur l'appareil.