Synthèse
Pour connecter XREAL Aura à un système métier, exécutez une application d'entreprise autorisée sur son boîtier de calcul Android XR et laissez cette application demander les données à l'API du système. Une API est une connexion logicielle qui permet à une application de récupérer des informations auprès d'une autre. Ce guide construit une petite application qui récupère un ordre de travail et affiche ses instructions sur Aura.
Un ordre de travail de maintenance constitue une bonne première intégration, car il réunit un numéro d'enregistrement, des informations sur l'équipement et des instructions pratiques. L'application récupère ces champs via une connexion autorisée et les présente dans une fenêtre lisible. La même approche peut être adaptée à d'autres enregistrements métier lorsque leurs API et leurs règles d'accès le permettent.
Comment fonctionne l'intégration métier de XREAL Aura
XREAL Aura associe des lunettes filaires à un boîtier de calcul, le petit ordinateur qui exécute Android XR et votre application. L'application se connecte au système de l'entreprise via le Wi-Fi et un chemin réseau approuvé ; les lunettes affichent les informations renvoyées. [1]
Un ordre de travail décrit une intervention et les instructions pour la réaliser. Un employé saisit le numéro de l'ordre dans l'application Aura et sélectionne Load work order. L'application demande cet enregistrement au système métier, puis affiche le nom de l'équipement, la version de la procédure et les instructions détaillées. Les boutons Next et Previous permettent à l'employé de parcourir les instructions, tandis que l'enregistrement source reste inchangé.
Si votre entreprise dispose déjà d'une application Android qui affiche ces enregistrements, demandez à son développeur de vérifier qu'elle fonctionne correctement sous Android XR avant d'en créer une autre. Google prend en charge les interfaces Android standard (comme une application Android 2D pour mobile ou grand écran) affichées dans un panneau système XR, sous la forme d'une fenêtre 2D présentée dans l'environnement XR. Une application existante nécessite tout de même des tests de compatibilité et d'accès. [4]
Pour le contexte matériel, consultez notre page produit XREAL Aura. Vérifiez la disponibilité actuelle et l'assistance proposée dans votre pays, car les informations de lancement évoluent. [2]
Étape 1 Obtenir un ordre de travail de test et ses informations de connexion
Votre application Aura a besoin d'un enregistrement à afficher et de l'autorisation de le récupérer depuis le système de votre entreprise. Un ordre de travail est un enregistrement d'intervention contenant un numéro d'ordre, des informations sur l'équipement et des instructions, par exemple les étapes d'inspection d'une machine.
· Avant d'écrire le code, assurez-vous de disposer d'un point de terminaison HTTPS, d'un jeton d'accès de test et d'un numéro d'ordre de travail d'exemple (par ex. WO-1001) correspondant au schéma JSON décrit dans la référence développeur.
· Demandez à votre équipe informatique l'adresse de l'API qui récupère cet ordre ainsi qu'un jeton d'accès de test temporaire. L'adresse de l'API indique à l'application où demander l'enregistrement ; le jeton l'autorise à lire les données. Demandez au service informatique de confirmer que les deux fonctionnent et si un accès au réseau de l'entreprise est nécessaire.
· Transmettez au service informatique la référence développeur figurant à la fin de cet article afin qu'il vérifie que les données renvoyées correspondent à l'application d'exemple. En cas de différence, modifiez le code de l'étape 3 pour lire les noms de champs de votre système. S'il n'existe aucune API adaptée, le service informatique doit d'abord en fournir une.
Gardez ces trois éléments à portée de main : l'adresse de l'API s'insère dans le code à l'étape 3 ; le jeton et le numéro d'ordre de travail se saisissent dans l'application en cours d'exécution à l'étape 4. Ensemble, ils permettent à l'application de récupérer l'intervention et d'afficher ses instructions sur Aura.
Étape 2 Ouvrir Android Studio et préparer l'application
Étape 2.1 Créer le projet sur votre ordinateur
· Dans le navigateur de votre ordinateur, ouvrez la page de téléchargement officielle d'Android Studio. Installez Android Studio et terminez sa configuration. Si vous avez besoin des outils XR dédiés de Google, suivez son guide de configuration d'Android Studio pour XR, qui recommande actuellement une version Canary, c'est-à-dire une version de développement précoce. [5]
· Ouvrez Android Studio. Sur l'écran d'accueil, sélectionnez New Project. Si un autre projet est ouvert, sélectionnez File > New > New Project dans le menu supérieur d'Android Studio.
· Dans la fenêtre du projet, sélectionnez Phone and Tablet > Empty Activity. Sélectionnez Next.
· Définissez Name sur AuraWorkOrders et Package name sur com.example.auraworkorders. Choisissez Kotlin lorsqu'une option de langage apparaît, conservez les paramètres SDK du modèle et sélectionnez Finish.
· Attendez qu'Android Studio termine la synchronisation Gradle. Gradle est l'outil de build qui prépare les bibliothèques et les paramètres du projet. Corrigez les éventuelles erreurs dans la fenêtre Build ou Sync avant de continuer.
Étape 2.2 Autoriser l'application à accéder au réseau
Le manifeste est le fichier Android qui déclare ce dont l'application a besoin, notamment l'autorisation d'accès au réseau.
· Dans le volet Project, à gauche dans Android Studio, sélectionnez la vue Android dans sa liste déroulante. Si le volet est masqué, sélectionnez View > Tool Windows > Project.
· Dans ce volet, développez app > manifests et ouvrez AndroidManifest.xml.
· À l'intérieur de l'élément manifest, au-dessus de l'élément application, ajoutez cette ligne. Conservez le reste du fichier généré.
<uses-permission android:name="android.permission.INTERNET" />· Dans le même fichier, repérez la balise d'ouverture application. Ajoutez android:usesCleartextTraffic="false" comme attribut à l'intérieur de cette balise. Android bloque déjà le HTTP non chiffré pour les applications qui ciblent Android 9 ou une version ultérieure ; cette ligne rend donc l'intention explicite.
L'autorisation INTERNET est accordée lors de l'installation ; elle ne déclenche pas de fenêtre de demande d'accès lorsque l'application s'exécute. [6] L'exemple utilise les outils réseau et JSON intégrés à Android ; vous n'avez donc pas besoin d'ajouter Retrofit ni une autre bibliothèque réseau.
Étape 3 Ajouter le code qui récupère et affiche l'ordre de travail
Ce code connecte l'application à l'adresse obtenue à l'étape 1, lit la réponse et affiche une instruction à la fois. La requête réseau s'exécute séparément de l'interface afin que l'écran reste réactif.
Étape 3.1 Ouvrir le bon fichier dans Android Studio
· Dans le volet Project, à gauche dans Android Studio, développez app > kotlin+java > com.example.auraworkorders. Dans certaines versions, le dossier source s'appelle java.
· Ouvrez MainActivity.kt. Ce fichier contrôle l'écran d'ouverture de l'application.
· Remplacez son contenu par le code ci-dessous. Si votre nom de package est différent, modifiez la première ligne pour qu'elle corresponde au package créé à l'étape 2.
package com.example.auraworkorders
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.ui.Modifier
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import org.json.JSONObject
import java.net.URL
import java.util.concurrent.Executors
import javax.net.ssl.HttpsURLConnection
data class WorkStep(
val number: Int, val title: String,
val instruction: String, val expectedResult: String
)
data class WorkOrder(
val id: String, val asset: String,
val revision: String, val steps: List<WorkStep>
)
fun fetchOrder(id: String, token: String): WorkOrder {
require(Regex("[A-Za-z0-9-]{1,40}").matches(id))
// Replace only this origin with your approved API origin.
val url = URL("https://api.your-company.example/work-orders/$id")
val c = url.openConnection() as HttpsURLConnection
try {
c.requestMethod = "GET"
c.instanceFollowRedirects = false
c.connectTimeout = 10000
c.readTimeout = 10000
c.setRequestProperty("Authorization", "Bearer $token")
c.setRequestProperty("Accept", "application/json")
val status = c.responseCode
check(status == 200) { "HTTP $status" }
val text = c.inputStream.bufferedReader().use { it.readText() }
val obj = JSONObject(text)
check(obj.getString("id") == id) { "Order ID mismatch" }
val array = obj.getJSONArray("steps")
check(array.length() > 0) { "No instructions available" }
val steps = (0 until array.length()).map { index ->
val s = array.getJSONObject(index)
WorkStep(s.getInt("number"), s.getString("title"),
s.getString("instruction"), s.getString("expectedResult"))
}.sortedBy { it.number }
return WorkOrder(obj.getString("id"), obj.getString("asset"),
obj.getString("revision"), steps)
} finally {
c.disconnect()
}
}
class MainActivity : ComponentActivity() {
private val worker = Executors.newSingleThreadExecutor()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MaterialTheme {
WorkOrderScreen { id, token, done ->
worker.execute {
val result = runCatching { fetchOrder(id, token) }
runOnUiThread {
if (!isDestroyed) done(result)
}
}
}
}
}
}
override fun onDestroy() {
worker.shutdownNow()
super.onDestroy()
}
}
@Composable
fun WorkOrderScreen(
load: (String, String, (Result<WorkOrder>) -> Unit) -> Unit
) {
var id by remember { mutableStateOf("WO-1001") }
var token by remember { mutableStateOf("") }
var order by remember { mutableStateOf<WorkOrder?>(null) }
var index by remember { mutableStateOf(0) }
var busy by remember { mutableStateOf(false) }
var message by remember { mutableStateOf("Enter test credentials.") }
Surface(Modifier.fillMaxSize()) {
Column(Modifier.padding(24.dp)
.verticalScroll(rememberScrollState()),
verticalArrangement = Arrangement.spacedBy(16.dp)) {
Text("Work instructions", style = MaterialTheme.typography.headlineMedium)
OutlinedTextField(value = id, onValueChange = { id = it },
label = { Text("Work order ID") },
singleLine = true, enabled = !busy)
OutlinedTextField(value = token, onValueChange = { token = it },
label = { Text("Sandbox access token") }, singleLine = true,
visualTransformation = PasswordVisualTransformation(),
enabled = !busy)
Button(enabled = !busy && token.isNotBlank() &&
Regex("[A-Za-z0-9-]{1,40}").matches(id), onClick = {
busy = true
order = null
index = 0
message = "Loading work order..."
load(id, token) { result ->
busy = false
result.onSuccess {
order = it
message = "Read-only instructions loaded."
}.onFailure {
message = "Could not load order. Check access and network."
}
}
}) { Text(if (busy) "Loading..." else "Load work order") }
Text(message)
order?.let { current ->
Text("${current.id} | ${current.asset}")
Text("Procedure revision ${current.revision}")
val step = current.steps[index]
Text("Step ${index + 1} of ${current.steps.size}",
style = MaterialTheme.typography.titleLarge)
Text(step.title, style = MaterialTheme.typography.headlineSmall)
Text(step.instruction, style = MaterialTheme.typography.bodyLarge)
Text("Expected result: ${step.expectedResult}")
Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
Button(enabled = index > 0,
onClick = { index-- }) { Text("Previous") }
Button(enabled = index < current.steps.lastIndex,
onClick = { index++ }) { Text("Next") }
}
Text("Navigation does not record task completion.")
}
}
}
}Étape 3.2 Saisir l'adresse de l'API de votre entreprise
· Restez dans MainActivity.kt dans Android Studio. Appuyez sur Ctrl+F sous Windows ou Linux, ou sur Command+F sous macOS, et recherchez api.your-company.example.
· Remplacez l'URL d'exemple de la ligne URL(...) par le modèle de point de terminaison de votre entreprise obtenu à l'étape 1. Conservez $id à l'emplacement du numéro d'ordre de travail. Par exemple, si le serveur attend /api/jobs/WO-1001, le code doit interroger https://YOUR-APPROVED-HOST/api/jobs/$id .· Ne placez pas le jeton dans ce fichier. L'application propose un champ de test temporaire pour le saisir lorsque vous l'exécutez.
· Si la réponse de votre API diffère de la référence développeur, modifiez les noms de champs et la structure lus par fetchOrder avant l'exécution. Dans cette fonction, JSONObject lit la réponse et getJSONArray("steps") ouvre sa liste d'instructions.
· Dans Android Studio, sélectionnez Build > Make Project si cette commande est disponible dans votre version, ou utilisez le bouton Run de la barre d'outils à l'étape 4 pour compiler le projet. Corrigez les éventuelles erreurs de compilation dans la fenêtre Build.
Résultat attendu : le projet se compile et l'URL dans MainActivity.kt pointe vers votre véritable service de test. L'adresse d'exemple se terminant par .example ne permettra pas de se connecter à un système métier.
Étape 4 Tester la connexion sur votre ordinateur
Un émulateur est un appareil Android virtuel affiché sur votre ordinateur. Utilisez-le d'abord pour vérifier l'adresse de l'API, le jeton et les instructions renvoyées avant de diagnostiquer un appareil physique.
Étape 4.1 Lancer l'application depuis Android Studio
· Dans le menu supérieur d'Android Studio, sélectionnez Tools > Device Manager.
· Si un appareil virtuel Android adapté existe déjà, sélectionnez son bouton de démarrage. Sinon, sélectionnez Create Device ou le bouton plus, choisissez un profil de téléphone, sélectionnez une image système disponible, téléchargez-la si nécessaire et terminez l'assistant. Démarrez le nouvel appareil.
· De retour dans la barre d'outils supérieure d'Android Studio, sélectionnez cet appareil en cours d'exécution dans la liste déroulante des appareils. Laissez app sélectionné comme configuration d'exécution, puis sélectionnez le bouton vert Run.
· Attendez que l'application s'ouvre dans l'émulateur. Vous devez voir Work instructions, Work order ID, Sandbox access token et Load work order.
Étape 4.2 Demander l'enregistrement métier
· Dans l'application en cours d'exécution dans l'émulateur, sélectionnez Work order ID et saisissez le numéro d'ordre de test obtenu à l'étape 1.
· Dans la même application, sélectionnez Sandbox access token et collez le jeton temporaire fourni par le service informatique. Collez uniquement sa valeur, sans le mot Bearer.
· Sélectionnez Load work order. Lorsque la requête aboutit, l'application affiche Read-only instructions loaded, suivi du numéro d'ordre, du nom de l'équipement, de la révision de la procédure et de la première instruction.
· Sélectionnez Next pour lire l'instruction suivante. Sélectionnez Previous pour revenir en arrière. Faites défiler l'application si une instruction dépasse le bas de la fenêtre.
Résultat attendu : l'enregistrement affiché correspond à celui que vous avez ouvert dans l'application métier à l'étape 1. S'il ne se charge pas, consultez la section de dépannage avant de passer à Aura.
Étape 5 Exécuter la même application connectée sur XREAL Aura
Étape 5.1 Préparer Aura pour le développement
· Allumez Aura à l'aide de son boîtier de calcul. Dans l'application Settings d'Aura, connectez-vous à un réseau Wi-Fi qui permet d'atteindre l'API de l'étape 1. Demandez au service informatique de confirmer les éventuelles exigences liées au réseau privé.
· Suivez la procédure d'intégration pour le développement actuellement fournie par XREAL afin d'activer le débogage et de connecter le boîtier de calcul à votre ordinateur. Commencez par la FAQ Aura de XREAL (tutorials.xreal.com/docs/aura/troubleshooting/faq/) : elle contient l'entrée consacrée aux ressources pour les développeurs ; partez de là si vous avez besoin des instructions actuelles.
· Dans l'application Settings d'Aura, ouvrez Developer options et activez la méthode de débogage prise en charge par votre appareil, en suivant cette procédure d'intégration. Autorisez votre ordinateur de développement si Aura affiche une invite. Le guide des appareils matériels de Google explique la procédure Android générale. [7]
Les libellés exacts des menus d'Aura et la configuration des câbles dépendent du matériel et du firmware. Selon la FAQ de XREAL Aura, les deux ports USB-C du boîtier de calcul prennent en charge le débogage ADB standard avec Android Studio ; connectez donc l'ordinateur au port de charge (Charging Port) à gauche et laissez les lunettes branchées sur le port des lunettes (Glasses Port) à droite. Le tableau des spécifications n'indique une prise en charge complète d'ADB que pour le Glasses Port ; essayez donc ce port si celui de gauche n'est pas reconnu, et suivez les instructions actuelles de XREAL pour activer l'accès développeur. [1]
Étape 5.2 Installer l'application depuis Android Studio
· Sur votre ordinateur, revenez au projet AuraWorkOrders dans Android Studio.
· Ouvrez la liste déroulante des appareils dans la barre d'outils supérieure d'Android Studio. Sélectionnez votre appareil de développement Aura connecté plutôt que l'émulateur.
· Si l'appareil n'apparaît pas, sélectionnez Tools > Troubleshoot Device Connections dans Android Studio et suivez l'assistant de connexion. Vérifiez l'autorisation de débogage et la méthode de connexion à l'aide de la procédure d'intégration de XREAL.
· Une fois l'appareil affiché, laissez app sélectionné comme configuration d'exécution et sélectionnez le bouton vert Run. Android Studio compile, installe et lance l'application sur l'appareil sélectionné.
Étape 5.3 Récupérer l'enregistrement dans les lunettes
· Mettez Aura et repérez la fenêtre de l'application Work instructions lancée par Android Studio.
· Dans cette fenêtre, saisissez le même numéro d'ordre de test et le même jeton temporaire qu'à l'étape 4. Utilisez les méthodes de saisie disponibles sur votre appareil ; les claviers et souris Bluetooth standard fonctionnent avec Aura (Settings > Connected Devices > Pair new device), et un clavier Bluetooth compatible peut faciliter la saisie lors des tests. [1]
· Sélectionnez Load work order, puis utilisez Next, Previous et le défilement pour lire ses instructions.
· Comparez le numéro d'ordre, le nom de l'équipement et le texte des instructions avec l'enregistrement d'origine dans votre application métier. S'ils correspondent, vous avez démontré que l'application Aura peut récupérer et afficher cet enregistrement métier.
Problèmes courants et points à vérifier
· L'application ne se compile pas : dans Android Studio, ouvrez View > Tool Windows > Build et lisez la première erreur signalée. Vérifiez le nom du package et que le projet Empty Activity utilise bien Compose et Material 3.
· L'application ne parvient pas à charger l'ordre : dans MainActivity.kt, dans Android Studio, vérifiez que le nom d'hôte d'exemple a bien été remplacé. Demandez au service informatique de vérifier que le point de terminaison est accessible depuis le réseau de l'émulateur ou d'Aura.
· L'API renvoie 401 : l'API n'a pas accepté l'identifiant. Demandez au service informatique de vérifier la validité du jeton et le service auquel il est destiné, ou obtenez un nouveau jeton de test.
· L'API renvoie 403 : le compte ne dispose pas de l'autorisation nécessaire. Demandez à l'administrateur du système métier d'accorder les droits d'accès appropriés.
· L'API renvoie 404 : vérifiez le numéro d'ordre et que le point de terminaison pointe bien vers le bon environnement de test.
· L'API renvoie des données mais l'application échoue : demandez au développeur de l'API de comparer la réponse avec la référence développeur. L'exemple exige une liste steps non vide et un id correspondant à l'ordre demandé.
· Fonctionne dans l'émulateur mais pas sur Aura : vérifiez le chemin réseau d'Aura et l'accès à l'API, puis contrôlez l'application sur l'appareil. Ne désactivez pas la vérification des certificats HTTPS pour contourner une erreur de connexion.
L'exemple affiche un message d'échec générique à l'utilisateur. Pour connaître le statut exact renvoyé par l'API, demandez à l'administrateur d'examiner les journaux du serveur sans exposer les jetons ni les ordres de travail complets. Pour les erreurs de l'application, utilisez View > Tool Windows > Logcat dans Android Studio ; Logcat affiche les journaux de l'application.
Référence développeur pour l'API d'exemple
Utilisez cette section pour vérifier la réponse à l'étape 1 ou pour adapter fetchOrder à l'étape 3. Elle décrit le contrat de cette application d'exemple, et non un point de terminaison fourni par XREAL.
Requête : GET https://api.your-company.example/work-orders/WO-1001
En-têtes de la requête : Authorization: Bearer <jeton d'accès de courte durée> et Accept: application/json
Réponse attendue en cas de succès : HTTP 200 avec cette structure JSON
{
"id": "WO-1001",
"asset": "Training station A",
"revision": "3",
"steps": [
{
"number": 1,
"title": "Confirm the training station",
"instruction": "Match the station label to this work order. Stop if the labels differ.",
"expectedResult": "The station label matches Training station A."
},
{
"number": 2,
"title": "Review the reference label",
"instruction": "Read the sample label and compare it with the training reference sheet.",
"expectedResult": "The sample label matches the approved reference."
}
]
}Le champ id identifie l'ordre de travail, asset identifie son équipement et revision identifie la version de la procédure. Chaque entrée de steps comporte un number, un title, une instruction complète et un expectedResult. L'exemple trie les étapes par numéro.
Utilisez des instructions approuvées pour les interventions réelles ; l'exemple décrit un poste de formation inactif. Avant la mise en production, validez la taille de la réponse et la longueur des champs, rejetez les données de procédure invalides et définissez le comportement à adopter à l'expiration du jeton. L'API doit vérifier les autorisations pour chaque ordre demandé. Le code d'exemple est fourni à titre illustratif et n'a été ni compilé ni testé avec un système réel ou un appareil Aura physique.
Conclusion
Connecter XREAL Aura à un système métier commence par une adresse d'API approuvée et une autorisation d'accès, puis passe par une application Android Studio qui récupère l'enregistrement nécessaire. Tester la connexion sur un ordinateur avant de la déployer sur Aura permet de distinguer les problèmes d'accès aux données de ceux liés à la configuration de l'appareil. L'exemple de l'ordre de travail affiche les informations sur l'équipement et les instructions pas à pas de manière lisible dans les lunettes, offrant aux entreprises un point de départ concret pour rendre les informations opérationnelles accessibles sur le lieu d'intervention. L'authentification avec les identifiants de l'entreprise, des autorisations adaptées et des tests sur l'appareil préparent cette connexion pour un pilote auprès des employés.
Discutez de la disponibilité du matériel et des exigences de votre pilote avec VR Expert.

























