Connecter XREAL Aura à vos systèmes d'entreprise

Connecter XREAL Aura à vos systèmes d'entreprise

Synthèse

Pour connecter XREAL Aura à un système d'entreprise, exécutez une application d'entreprise autorisée sur son boîtier de calcul (compute puck) Android XR et laissez cette application demander des 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 crée 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 se compose de lunettes filaires et d'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 tâche et les instructions pour l'exécuter. 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 d'entreprise, 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, sans que l'enregistrement source soit modifié.

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 sur Android XR avant d'en créer une nouvelle. 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 doit tout de même faire l'objet de tests de compatibilité et d'accès. [4]

Pour le contexte matériel, consultez notre page produit XREAL Aura. Vérifiez la disponibilité et l'assistance actuelles pour 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 de tâche 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 (p. ex. WO-1001) correspondant au schéma JSON décrit dans la Référence développeur.

· Demandez à votre service 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 lui donne l'autorisation de 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. Si ce n'est pas le cas, adaptez 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 la tâche 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 officielle de téléchargement d'Android Studio. Installez Android Studio et terminez sa configuration. Si vous avez besoin des outils XR dédiés de Google, suivez le 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 ait terminé la synchronisation Gradle. Gradle est l'outil de compilation 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 poursuivre.

É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, y compris l'autorisation d'accès au réseau.

· Dans le volet Project à gauche d'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 ciblant 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 aucune 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, de sorte que l'écran reste réactif.

Étape 3.1 Ouvrir le bon fichier dans Android Studio

· Dans le volet Project à gauche d'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 le nom de votre 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 Commande+F sous macOS, et recherchez api.your-company.example.

· Remplacez l'URL d'exemple dans 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, adaptez 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 se connectera à aucun système d'entreprise.

É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 vous lancer dans le dépannage d'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 devriez 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. Si 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 Paramètres d'Aura, connectez-vous à un réseau Wi-Fi qui peut 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'initiation au développement actuellement fournie par XREAL pour activer le débogage et connecter le boîtier de calcul à votre ordinateur. Commencez par la FAQ Aura de XREAL (tutorials.xreal.com/docs/aura/troubleshooting/faq/), qui contient l'entrée consacrée aux ressources pour développeurs ; partez de là si vous avez besoin des instructions actuelles.

· Dans l'application Paramètres d'Aura, ouvrez les Options pour les développeurs et activez la méthode de débogage prise en charge par votre appareil, en suivant cette procédure d'initiation. Autorisez votre ordinateur de développement si Aura affiche une invite. Le guide sur les appareils physiques 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 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'initiation 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 (Paramètres > Appareils connectés > Associer un nouvel appareil), 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 sous 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 l'émulateur ou le réseau 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 des autorisations nécessaires. Demandez à l'administrateur du système métier d'accorder l'accès approprié.

· L'API renvoie 404 : vérifiez le numéro d'ordre et que le point de terminaison pointe 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éral à l'utilisateur. Pour connaître le statut exact de 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 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 <short-lived access token> 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 travaux réels ; l'exemple décrit une station de formation inactive. Avant la mise en production, validez la taille de la réponse et la longueur des champs, rejetez les données de procédure non valides et définissez le comportement à 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é sur un système réel ou un appareil Aura physique.

Conclusion

Connecter XREAL Aura à un système d'entreprise commence par une adresse d'API approuvée et une autorisation d'accès, suivies d'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 étape par étape 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 de travail. La connexion via le compte de l'entreprise, des autorisations appropriées et des tests sur l'appareil préparent cette connexion à un projet pilote avec les employés.

Discutez de la disponibilité du matériel et des exigences de votre projet pilote avec VR Expert.

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

Un système a besoin d'une API accessible, d'une méthode d'authentification approuvée et de l'autorisation de récupérer les enregistrements nécessaires. Les logiciels de planification des ressources d'entreprise (ERP) coordonnent les opérations de l'entreprise, tandis que les logiciels de gestion de la maintenance organisent l'entretien des équipements. Leurs API et structures de données varient : chaque intégration doit donc être vérifiée en fonction du produit et de la configuration concernés.

Google prend en charge les interfaces Android standard dans les panneaux système d'Android XR. Les applications Android 2D pour mobile ou grand écran fonctionnent par défaut dans Android XR, affichées sous forme de panneau 2D dans un espace XR/3D. Testez la connexion, l'accès au réseau, l'affichage et la saisie de l'application sur Aura avant de l'approuver pour les employés. Une application existante qui fournit déjà les enregistrements nécessaires peut réduire la quantité de développement requise. [4]

Une fenêtre d'application Android standard peut afficher l'ordre de travail et ses instructions. Les panneaux Jetpack XR personnalisés constituent une extension facultative lorsqu'une tâche particulière gagne à une autre disposition des informations. [4]

Une API interne de l'entreprise peut être accessible via un réseau local ou privé approuvé. L'appareil doit tout de même pouvoir atteindre l'API et tous les services nécessaires à l'authentification. L'exemple nécessite une connexion active et ne stocke pas les ordres de travail pour une utilisation hors ligne.

L'exemple récupère et affiche des informations. La transmission de résultats nécessite une opération d'API supplémentaire, une autorisation de l'utilisateur et une interface de confirmation. Le serveur doit valider la transmission et gérer les requêtes répétées en toute sécurité.