Synthèse
Ce guide du SDK Unity pour XREAL One Pro montre aux développeurs et aux équipes métier comment créer et tester une application avec le SDK XREAL 3.1.0. Le premier résultat est un APK Android qui s'ouvre via XREAL Control Glasses sur un smartphone compatible. Commencez par l'exemple officiel Hello MR, puis ajoutez un panneau d'instructions métier simple si vous devez afficher le contenu de vos propres processus.
Le premier build Hello MR ne nécessite aucun code personnalisé. Une expérience propre à votre entreprise nécessite en revanche un travail de développement Unity dès que les équipes ajoutent leurs propres étapes, commandes, flux de données, authentification ou connexion à un backend. Les XREAL One Pro sont un écran connecté et non un ordinateur autonome : c'est donc le smartphone compatible qui exécute l'application. Vérifiez la compatibilité, les autorisations, le traitement des données et la gestion des appareils avec votre équipe technique interne avant tout déploiement plus large.
Introduction
Le flux de travail du SDK Unity pour les XREAL One Pro est un moyen pratique de tester une interface professionnelle mains libres, comme une liste de tâches, une vue d'assistance à distance ou une courte instruction de travail. Consultez la page produit XREAL One Pro chez VR Expert pour une présentation de l'appareil. Ce guide se concentre sur le parcours de développement Unity et sur les vérifications qui comptent avant un pilote en entreprise : smartphone hôte compatible, bon plug-in XREAL, autorisations Android et premier build clair.
Prérequis du SDK Unity pour XREAL One Pro
- Méthode de développement : SDK XREAL pour Unity. Ce guide ne couvre pas le développement natif Android, Java ou Kotlin.
- Documentation actuelle du SDK : version 3.1.0 au moment de la vérification. Consultez les dernières notes de version de XREAL avant le développement ou le déploiement.
- Versions d'Unity dans le guide de démarrage rapide : Unity 2021.3 LTS, 2022.3 LTS ou Unity 6000.0 LTS avec Android Build Support.
- Hôte compatible : XREAL mentionne le Beam Pro ou des smartphones Android compatibles ; le guide de démarrage rapide cite les gammes phares Samsung S24 et ultérieures. Les notes de la version 3.1.0 indiquent le Beam Pro et le Samsung S25 comme testés et compatibles.
- Suivi sur les One Pro : commencez en 3DoF. Le SDK XREAL 3.1.0 ajoute le 6DoF pour la série One, avec le module XREAL Eye fixé et un firmware des lunettes mis à jour.
- Connexion du smartphone : le smartphone doit disposer d'une sortie vidéo USB-C DisplayPort et, séparément, être compatible comme hôte du SDK XREAL. La sortie vidéo seule ne prouve pas la prise en charge du SDK.
Avant d'ouvrir Unity
· Smartphone hôte compatible : utilisez le Beam Pro ou un smartphone répertorié comme compatible dans la documentation actuelle du SDK XREAL. Le guide de démarrage rapide cite actuellement les gammes phares Samsung S24 et ultérieures ; les notes de version 3.1.0 indiquent le Beam Pro et le Samsung S25 comme hôtes testés et compatibles (XREAL teste le S24 sous Android 14 et le S25 sous Android 15). Évitez de préférence de passer le smartphone sous Android 16, car la documentation de XREAL comporte l'avertissement « Veuillez ne pas mettre à niveau vos appareils de développement vers Android 16 », et désactivez Samsung DeX pendant le développement.
· Unity : installez un éditeur Unity LTS répertorié par XREAL avec Android Build Support. S'il manque, ajoutez Android Build Support via Unity Hub > Installs > (votre éditeur) > Add modules.
· Outils du SDK Android : installez le SDK Android 12.0 (API 31) ou plus récent depuis Android Studio > More Actions > SDK Manager, ou via Tools > SDK Manager dans un projet Android Studio ouvert. Il s'agit uniquement de la chaîne d'outils de build Android pour Unity, et non d'un flux de développement d'application native.
· SDK et runtime : téléchargez le SDK XREAL pour Unity 3.1.0 depuis la page de téléchargement développeurs de XREAL. Récupérez ControlGlasses 3.1.0 via le lien figurant dans la note de version du SDK 3.1.0 ; la page de téléchargement propose encore l'ancien build 1.1.0, qui correspond au SDK 3.0.0. Consultez les notes actuelles sur le firmware avant de tester.
· Conditions du SDK et information sur les données : avant le développement, lisez et acceptez les conditions actuelles des API XREAL (XREAL APIs Terms). XREAL exige que les développeurs indiquent comment le SDK collecte et traite les données dans l'application, et recommande de mentionner le SDK XREAL avec un lien vers sa politique de confidentialité. Ajoutez ces informations en complément des informations de confidentialité et de la procédure de vérification propres à votre organisation.
· Câble des lunettes : utilisez une connexion USB-C prenant en charge la vidéo DisplayPort. Vérifiez aussi que le smartphone est un hôte compatible avec le SDK, car il s'agit d'une vérification distincte.
Créer et exécuter la première application XREAL One Pro
Étape 1 Créer un projet Unity pour Android
· Ouvrez Unity Hub. Sélectionnez Projects, puis New project.
· Choisissez un modèle. Sélectionnez un modèle 3D, saisissez un nom de projet explicite comme `BusinessXREALPilot`, puis cliquez sur Create project.
· Passez à Android. Dans l'éditeur Unity, ouvrez File > Build Settings, ou l'Android Build Profile dans Unity 6. Sélectionnez Android et choisissez Switch Platform.
Vérification : la plateforme Android est sélectionnée et Unity a terminé l'importation du projet.
Étape 2 Installer les packages XR d'Unity
· Ouvrez le Package Manager. Dans l'éditeur Unity, choisissez Window > Package Manager.
· Sélectionnez le Unity Registry. Utilisez le menu de source des packages en haut à gauche, puis recherchez XR Interaction Toolkit.
· Installez le toolkit. Sélectionnez XR Interaction Toolkit (XREAL prend en charge les versions 2.5.x et 3.0.x) et cliquez sur Install. Ouvrez son onglet Samples et importez Starter Assets et Hands Interaction Demo ; d'après les notes de dépannage de XREAL, HelloMR affiche des prefabs manquants sans l'exemple consacré aux mains.
· Limitez le premier build au strict nécessaire. Laissez AR Foundation de côté. Le tableau de compatibilité de XREAL indique que le suivi de plans, le suivi d'images, le suivi des mains, le maillage de profondeur et les ancres spatiales ne sont pas pris en charge sur la série XREAL One, avec ou sans le module caméra ; ces fonctions nécessitent les Air 2 Ultra, de sorte qu'un prototype sur One Pro ne peut pas les utiliser.
Vérification : XR Interaction Toolkit apparaît dans le projet et son exemple Starter Assets est importé.
Étape 3 Importer le SDK XREAL pour Unity
· Ouvrez le menu des packages. Dans le Package Manager, cliquez sur le bouton plus et choisissez Add package from tarball.
· Sélectionnez l'archive du SDK. Accédez au fichier `com.xreal.xr.tar.gz` téléchargé et cliquez sur Open.
· Importez le premier exemple. Sélectionnez XREAL XR Plugin dans le Package Manager, ouvrez Samples et importez Interaction Basics. N'importez pas l'exemple AR Features : ses fonctions de plans, d'images et d'ancres ne fonctionnent pas sur la série One.
Vérification : XREAL XR Plugin figure dans le Package Manager et Interaction Basics peut être importé.
Étape 4 Activer le plug-in XREAL pour Android
· Ouvrez Project Settings. Choisissez Edit > Project Settings > XR Plug in Management.
· Sélectionnez Android. Ouvrez l'onglet Android et cochez XREAL.
· Appliquez les correctifs du projet. Si Project Validation s'affiche avec des avertissements, ouvrez-le et cliquez sur Fix All à côté des correctifs requis. Attendez qu'Unity ait fini de modifier les paramètres.
Vérification : l'onglet Android indique que XREAL est activé et les éléments de validation requis sont corrigés.
Étape 5 Configurer la prise en charge des One Pro et le suivi
· Ouvrez la page des paramètres XREAL. Dans Project Settings, sélectionnez XR Plug in Management > XREAL.
· Vérifiez la catégorie d'appareil. Sous Support Devices, activez la catégorie Vision pour les lunettes de la série XREAL One.
· Choisissez le suivi. Réglez Initial Tracking Type sur MODE_3DOF pour des lunettes One Pro sans XREAL Eye. Ne choisissez MODE_6DOF que lorsque le XREAL Eye est fixé et que le firmware des lunettes a été mis à jour comme indiqué pour le SDK 3.1.0.
· Choisissez la source d'entrée du prototype. Réglez Initial Input Source sur Controller pour que le smartphone Android compatible serve de manette à l'application. Le rayon de la manette est configuré à l'étape 11.
Vérification : le projet est configuré pour la série XREAL One et le mode de suivi correspond au matériel connecté.
Étape 6 Définir les paramètres de build Android
· Ouvrez Player Settings. Revenez à File > Build Settings ou à l'Android Build Profile, sélectionnez Player Settings, puis ouvrez Other Settings.
· Attribuez un identifiant unique à l'application. Saisissez un Package Name au format de domaine inversé, par exemple `com.companyname.workflowpilot`. Ne laissez pas l'identifiant de l'exemple dans un projet de production.
· Définissez l'identité de l'application. Dans la même section de Player Settings, renseignez Company Name et Product Name avec le nom de votre organisation et celui de l'application pilote. Dans Resolution and Presentation, réglez Default Orientation sur Portrait, comme indiqué dans le guide de démarrage rapide de XREAL.
· Définissez les options graphiques. Conformément au guide de démarrage rapide de XREAL, désactivez Auto Graphics API et utilisez OpenGLES3.
· Définissez les niveaux d'API Android. Réglez Minimum API Level sur Android 10 ou plus récent et Target API Level sur Automatic (highest installed). Installez le SDK Android API 31 ou ultérieur dans SDK Manager. Il s'agit de paramètres distincts : les outils SDK installés d'une part, la version minimale de l'application d'autre part.
· Définissez l'architecture Android. Dans Player Settings > Other Settings > Configuration, activez ARM64 pour le smartphone cible et réglez Scripting Backend sur IL2CPP pour les builds ARM64. XREAL documente cette exigence pour les builds ARM64.
Vérification : le projet utilise l'identifiant de package et les paramètres Android requis pour le build Unity.
Étape 7 Valider les contrôles du manifeste Android et des autorisations
· Utilisez d'abord le manifeste généré. Unity et le package XREAL génèrent ou fusionnent les entrées du manifeste Android pendant le build. Ne créez pas de manifeste Android personnalisé pour un exemple de base, sauf si un paramètre XREAL ou une fonction documentée l'exige. Le critère à remplir pour le manifeste : l'application finale doit déclarer les autorisations et la configuration dont ses fonctions ont besoin.
· Ne sélectionnez que les autorisations nécessaires. Dans Project Settings > XR Plug in Management > XREAL, ouvrez Android Permissions. N'activez Camera que pour une fonction basée sur la caméra, Audio que si l'application a besoin d'accéder à l'audio, et Vibration que si l'application utilise le retour haptique.
· Autorisez l'affichage demandé à l'exécution. Lorsque Control Glasses demande une autorisation au lancement, autorisez Control Glasses à s'afficher par-dessus d'autres applications. Si vous avez ignoré la demande, ouvrez Paramètres Android > Applications > Accès spécifiques des applications > Affichage par-dessus d'autres applis > Control Glasses et activez l'option. Les libellés exacts peuvent varier selon le smartphone.
Vérification : le package XREAL est configuré uniquement avec les autorisations nécessaires à votre prototype, et Control Glasses peut s'afficher par-dessus d'autres applications au lancement.
Étape 8 Ouvrir Hello MR et vérifier la scène
· Trouvez l'exemple importé. Dans la fenêtre Project d'Unity, ouvrez Assets > Samples > XREAL XR Plugin > la version du package installée > Interaction Basics.
· Ouvrez la scène d'exemple. Double-cliquez sur `HelloMR.unity`. Si elle n'y figure pas, revenez à Window > Package Manager > XREAL XR Plugin > Samples et importez Interaction Basics.
· Enregistrez la scène. Choisissez File > Save. Vérifiez la Hierarchy et assurez-vous que les objets de l'exemple sont visibles.
Vérification : Hello MR s'ouvre sans ressources d'exemple manquantes. Cet exemple vous donne une base de référence sans code personnalisé.
Étape 9 Ajouter un panneau d'instructions métier en C sharp sous Unity
· Décidez s'il faut ajouter du code. Passez cette étape pour créer le build de l'exemple Hello MR non modifié. Suivez-la si vous voulez que le prototype affiche vos propres instructions métier.
· Créez un Canvas en world space. Dans la Hierarchy, clic droit > UI > Canvas. Dans la Hierarchy, placez le Canvas directement à la racine de la scène ou sous XR Origin (ne le rattachez pas directement à Main Camera, pour éviter qu'il reste figé devant le visage). Réglez Render Mode sur World Space. Dans Rect Transform, définissez la position sur X 0, Y 0, Z 1.5 (devant le point de départ de l'utilisateur), la rotation sur 0, 0, 0 et l'échelle sur 0.001 sur tous les axes.
· Ajoutez le texte de la tâche et du statut. Dans la Hierarchy, faites un clic droit sur Canvas > UI > Text - TextMeshPro. Importez TMP Essentials si Unity le demande. Renommez le premier objet texte InstructionText. Créez un second objet Text - TextMeshPro nommé StatusText. Donnez aux deux des zones de texte lisibles, par exemple largeur 900, hauteur 180, taille de police 42. Placez StatusText sous l'instruction.
· Ajoutez un bouton de validation. Dans la Hierarchy, faites un clic droit sur Canvas > UI > Button - TextMeshPro. Renommez-le MarkCompleteButton et définissez son libellé visible sur Mark complete. Si la scène ne contient pas d'EventSystem, créez-en un via Hierarchy > clic droit > UI > Event System. Créez un C Sharp Script nommé BusinessChecklistDisplay dans Assets et ouvrez-le dans votre éditeur de code Unity.
Vérification : la scène contient un Canvas en world space, un objet texte TextMeshPro et un nouveau fichier de script C sharp.
using TMPro; using UnityEngine; using UnityEngine.UI;
public class BusinessChecklistDisplay : MonoBehaviour { [SerializeField] private TMP_Text instructionText; [SerializeField] private TMP_Text statusText; [SerializeField] private Button completeButton;
[TextArea(2, 5)] [SerializeField] private string instruction = "Review the assigned task.\nConfirm the required item.";
private void Start() { if (instructionText == null || statusText == null || completeButton == null) { Debug.LogError("Assign the text fields and button in the Inspector.", this); return; }
instructionText.text = instruction; statusText.text = "Status: Not complete"; completeButton.onClick.AddListener(MarkComplete); }
private void MarkComplete() { statusText.text = "Status: Complete (local demo)"; completeButton.interactable = false; }
private void OnDestroy() { if (completeButton != null) completeButton.onClick.RemoveListener(MarkComplete); } }
Portée pour les développeurs : ce code affiche des instructions et modifie le statut localement lorsque le bouton est sélectionné. Il n'enregistre pas de tâche dans un système de l'entreprise, n'authentifie pas d'utilisateur et n'envoie pas de données sur un réseau. Ces fonctions nécessitent un code applicatif adapté à l'API, à la gestion des identités et à la conception du traitement des données de votre organisation. Ne placez ni identifiants de connexion ni données métier réelles dans l'APK.
Étape 10 Relier le script au panneau d'instructions
· Attendez la fin de la compilation par Unity. Enregistrez le script dans l'éditeur de code, revenez à Unity et attendez que l'indicateur de compilation disparaisse.
· Attachez le script. Faites glisser `BusinessChecklistDisplay` depuis la fenêtre Project sur le Canvas dans la Hierarchy.
· Assignez les champs de l'interface. Sélectionnez le Canvas. Dans l'Inspector, recherchez Business Checklist Display. Faites glisser InstructionText et StatusText depuis la Hierarchy vers les champs correspondants, puis faites glisser MarkCompleteButton dans Complete Button.
· Définissez les valeurs d'exemple. Dans le même composant de l'Inspector, remplacez Instruction par un texte de démonstration approuvé et non confidentiel. Enregistrez la scène. Après sélection, le bouton remplace le texte de StatusText par « Complete (local demo) » ; il n'envoie ni n'enregistre de résultat métier réel.
Vérification : l'Inspector affiche les deux champs de texte et le bouton assignés, et le texte de statut change lorsque vous sélectionnez Mark complete dans l'éditeur Unity.
Étape 11 Configurer la sélection à la manette pour l'interface
· Configurez le module d'entrée de l'EventSystem. Sélectionnez EventSystem dans la Hierarchy. Supprimez Standalone Input Module s'il est présent, puis utilisez Add Component pour ajouter XR UI Input Module. Si le preset XRI Starter Assets est disponible, appliquez XRI Default XR UI Input Module afin que le module dispose des actions d'entrée attendues.
· Configurez le raycaster du Canvas. Sélectionnez Canvas. Supprimez Graphic Raycaster et ajoutez Tracked Device Graphic Raycaster. Cela permet à un rayon XR suivi de cibler le bouton.
· Activez l'interaction avec l'interface sur le rayon de la manette. Dans XR Origin, sélectionnez l'objet manette qui possède un XR Ray Interactor. Dans sa section UI Interaction, activez Interaction with UI GameObjects. Laissez l'Initial Input Source de XREAL réglée sur Controller, comme à l'étape 5.
· Vérifiez la chaîne de la manette. L'exemple Interaction Basics devrait fournir les objets manette et les actions d'entrée. Si XR Origin ne comporte pas de XR Ray Interactor, importez l'exemple XRI Starter Assets et utilisez sa configuration XR Origin/manette avant le build.
Vérification : dans l'éditeur Unity, le rayon de la manette met en surbrillance le bouton Mark complete et sa sélection modifie le texte de statut. Répétez ce test sur le smartphone compatible et les lunettes avant d'utiliser ce flux dans un pilote.
Étape 12 Facultatif : relier la validation des tâches à une API métier
Notions d'API métier à connaître avant de coder
· API REST : une adresse web et un format de requête convenu qui permettent à l'application d'échanger des données avec un service de l'entreprise.
· Jeton d'accès : un identifiant de courte durée délivré après une connexion approuvée ; l'application l'envoie pour prouver que l'utilisateur est autorisé à agir.
· Clé d'idempotence : un identifiant de requête unique qui permet au serveur de reconnaître une nouvelle tentative et d'éviter d'enregistrer deux fois la même validation.
· HTTPS : une communication réseau chiffrée qui protège les données pendant leur transit entre le smartphone et le serveur.
· Définissez d'abord le contrat d'API de l'entreprise. Demandez à votre équipe plateforme l'endpoint HTTPS, les champs JSON acceptés, la source d'identité des utilisateurs, l'émetteur des jetons d'accès, la réponse en cas de succès et la politique de nouvelles tentatives. L'exemple ci-dessous envoie taskId, operatorId, requestId et completedAtUtc ; faites-les correspondre à l'API de votre entreprise avant utilisation. Utilisez des identifiants opaques approuvés par votre organisation, et non des noms ou des données sensibles.
· Activez l'accès réseau pour ce build. Pour la version API de l'application, ouvrez Edit > Project Settings > Player > Android > Other Settings > Configuration et réglez Internet Access sur Require. Relancez le build et inspectez le manifeste fusionné pour vérifier la présence de android.permission.INTERNET. Cette autorisation n'affiche aucune demande Android.
· Ajoutez un script connecteur. Dans Unity, créez `BusinessTaskApi.cs`, collez les deux blocs de code consécutifs dans ce même fichier, dans l'ordre, puis enregistrez-le. Le second bloc se poursuit à l'intérieur de SubmitCompletion. L'endpoint est un espace réservé ; remplacez-le par l'endpoint approuvé de l'entreprise. Le jeton d'accès ne doit figurer ni dans l'Inspector, ni dans le code source, ni dans l'APK, ni dans les journaux.
using System; using System.Collections; using System.Text; using UnityEngine; using UnityEngine.Networking;
[Serializable] public class TaskCompletionPayload { public string taskId; public string operatorId; public string requestId; public string completedAtUtc; }
public class BusinessTaskApi : MonoBehaviour { [SerializeField] private string completionEndpoint = "https://api.example.com/v1/task-completions";
public IEnumerator SubmitCompletion( string taskId, string operatorId, string accessToken, string requestId, Action<bool, string> onComplete) { if (string.IsNullOrWhiteSpace(taskId) || string.IsNullOrWhiteSpace(operatorId) || string.IsNullOrWhiteSpace(accessToken) || string.IsNullOrWhiteSpace(requestId)) { onComplete?.Invoke(false, "Missing task, user, token, or request ID."); yield break; }
if (!Uri.TryCreate(completionEndpoint, UriKind.Absolute, out Uri endpoint) || endpoint.Scheme != Uri.UriSchemeHttps) { onComplete?.Invoke(false, "Use the approved HTTPS API endpoint."); yield break; }
var payload = new TaskCompletionPayload { taskId = taskId, operatorId = operatorId, requestId = requestId, completedAtUtc = DateTime.UtcNow.ToString("o") }; byte[] body = Encoding.UTF8.GetBytes(JsonUtility.ToJson(payload));
using (var request = new UnityWebRequest(completionEndpoint, "POST")) { request.uploadHandler = new UploadHandlerRaw(body); request.downloadHandler = new DownloadHandlerBuffer(); request.timeout = 20; request.SetRequestHeader("Content-Type", "application/json"); request.SetRequestHeader("Authorization", "Bearer " + accessToken); request.SetRequestHeader("Idempotency-Key", requestId);
yield return request.SendWebRequest();
bool accepted = request.result == UnityWebRequest.Result.Success && request.responseCode >= 200 && request.responseCode < 300; string message = accepted ? "Completion accepted by the business system." : "Request failed (HTTP " + request.responseCode + "). " + request.error; onComplete?.Invoke(accepted, message); } } }
· Appelez le connecteur depuis le bouton. Ajoutez un composant `BusinessTaskApi` au Canvas et assignez-le à `taskApi` dans `BusinessChecklistDisplay`. Remplacez la méthode `MarkComplete`, purement locale, par un appel de coroutine une fois que le SDK d'identité de votre entreprise fournit un jeton d'accès valide et que le système métier fournit les identifiants de la tâche et de l'opérateur :
· Câblez l'action authentifiée. Dans le script BusinessChecklistDisplay existant, le bouton appelle actuellement la méthode locale MarkComplete. Pour la version de production, modifiez ce gestionnaire afin que le flux de connexion approuvé de l'entreprise obtienne un jeton d'accès et appelle SubmitToBusinessSystem(token). N'ajoutez pas de formulaire nom d'utilisateur/mot de passe et ne stockez pas de jeton dans la scène.
// Fields to add to BusinessChecklistDisplay: [SerializeField] private BusinessTaskApi taskApi; [SerializeField] private string taskId; // Set from your approved task source. [SerializeField] private string operatorId; // Set from your approved identity source. // Call this after obtaining a short-lived token from the company identity SDK. private void SubmitToBusinessSystem(string accessToken) { string requestId = System.Guid.NewGuid().ToString("N"); StartCoroutine(taskApi.SubmitCompletion( taskId, operatorId, accessToken, requestId, HandleCompletionResult)); } private void HandleCompletionResult(bool accepted, string message) { statusText.text = accepted ? "Status: Submitted" : "Status: Not submitted"; Debug.Log(message); // Do not log tokens or sensitive business data. }
Important : `accessToken` doit provenir de votre fournisseur de connexion approuvé, au moment de l'exécution. Le nom de fonction ci-dessus est un point de transfert, pas une implémentation complète de la gestion des identités. Configurez l'autorisation côté API pour la tâche et l'utilisateur, validez chaque champ sur le serveur, utilisez un identifiant de requête stable lors des nouvelles tentatives et ne désactivez pas le bouton tant que le serveur n'a pas accepté la requête. Adaptez le connecteur au schéma de réponse de votre API et à votre version d'Unity avant la mise en production.
Vérification : dans un environnement de test, vérifiez qu'une requête autorisée est acceptée, qu'un jeton expiré ou non autorisé est rejeté, qu'un dépassement de délai laisse la tâche visiblement non envoyée et qu'une nouvelle tentative avec le même identifiant de requête ne crée pas de doublon.
Étape 13 Ajouter la scène Hello MR au build Android
· Ouvrez la fenêtre de build. Choisissez File > Build Settings. Dans Scenes In Build, cliquez sur Add Open Scenes et vérifiez que HelloMR figure dans la liste et est coché.
· Pour Unity 6. Ouvrez l'Android Build Profile actif et ajoutez la scène HelloMR actuellement ouverte à sa liste de scènes.
Vérification : le build Android inclut la scène que vous venez de tester et de personnaliser.
Étape 14 Créer le premier APK
· Vérifiez qu'Android est actif. Contrôlez la plateforme sélectionnée dans Build Settings ou dans l'Android Build Profile.
· Lancez le build de l'application. Cliquez sur Build, choisissez un dossier de sortie et nommez le fichier `BusinessXREALPilot.apk`.
· Inspectez le manifeste final. Ouvrez Android Studio et choisissez Build > Analyze APK, puis sélectionnez BusinessXREALPilot.apk. Dans AndroidManifest.xml, vérifiez le nom du package et assurez-vous que les autorisations déclarées correspondent aux fonctions de ce pilote. Contrôlez l'APK généré, car il contient le manifeste fusionné qu'Unity installera.
· Conservez une copie de test versionnée. Pour un pilote en entreprise, archivez l'APK avec sa version d'Unity, la version du SDK XREAL, le modèle de smartphone et la date du test, afin que l'équipe puisse reproduire le même build.
Vérification : Unity crée l'APK sans erreur de build, et le manifeste résolu a été vérifié avant l'installation.
Étape 15 Installer l'APK sur un smartphone Android compatible
· Connectez le smartphone à l'ordinateur. Utilisez l'USB ou configurez ADB sans fil. Sur le smartphone, activez les Options pour les développeurs et le débogage USB si vous installez par câble.
· Installez l'APK. Utilisez Build and Run dans Unity ou exécutez `adb install -r BusinessXREALPilot.apk` depuis un terminal où ADB est disponible.
· Acceptez les demandes d'Android. Confirmez les demandes d'installation et de débogage sur le smartphone. Conservez l'APK sur le smartphone compatible que vous prévoyez d'utiliser avec les lunettes.
Vérification : la nouvelle application Unity apparaît dans la liste des applications du smartphone.
Étape 16 Lancer l'application métier via Control Glasses
· Connectez les lunettes. Déconnectez le smartphone de l'ordinateur de développement et connectez les XREAL One Pro à la sortie USB-C DisplayPort du smartphone.
· Ouvrez l'application runtime. Sur le smartphone, ouvrez Control Glasses. Recherchez `BusinessXREALPilot` dans sa liste d'applications et touchez l'application. Le Beam Pro utilise MyGlasses à la place.
· Accordez les accès demandés. Autorisez Control Glasses à s'afficher par-dessus d'autres applications si Android le demande. N'accordez Camera, Audio ou Vibration que si l'application Unity utilise ces fonctions et demande l'autorisation correspondante.
· Vérifiez le résultat. Assurez-vous que Hello MR et le panneau d'instructions métier facultatif sont visibles dans les lunettes. Tournez doucement la tête pour vérifier que la vue suit le mode 3DoF attendu.
Vérification : l'application s'exécute sur le smartphone compatible et son affichage apparaît dans les XREAL One Pro.
Vérifications du pilote avant un usage plus large
· Testez avec un contenu d'exemple approuvé. N'utilisez aucune donnée personnelle, client ou confidentielle dans les premiers prototypes.
· Vérifiez la combinaison exacte de smartphone et de firmware. Ne partez pas du principe qu'une connexion vidéo USB-C implique la compatibilité avec le SDK XREAL.
· Validez la saisie et la lisibilité. Vérifiez la taille de police, le contraste, le positionnement et le nombre d'actions nécessaires en portant les lunettes.
· Passez en revue les exigences de l'entreprise. Avant un usage plus large, vérifiez l'authentification, le stockage des données, l'accès réseau, la distribution des mises à jour, la gestion des appareils et les exigences applicables en matière de confidentialité, comme le RGPD.
· Gardez un périmètre d'application réaliste. Ce projet prouve qu'une application Unity peut fonctionner avec cette configuration. Il ne prouve pas à lui seul la maturité pour la production, une certification de sécurité ou la prise en charge de tous les smartphones Android.
Conclusion
Un prototype professionnel pour les XREAL One Pro commence dans Unity avec le SDK XREAL actuel, un hôte Android compatible, le plug-in XREAL et les paramètres d'appareil, ainsi que les bonnes autorisations de manifeste et d'exécution. La scène Hello MR fournit un premier build sans code, tandis qu'un petit composant Unity en C sharp peut ajouter un panneau d'instructions métier simple avant que l'équipe ne crée et n'installe un APK. Lancez l'application via Control Glasses et testez-la avec le smartphone, le firmware, le contenu et le flux de travail exacts prévus pour le pilote. Cette démarche aide les entreprises à vérifier si un logiciel spatial mains libres répond à leurs besoins, à identifier tôt les exigences techniques et de confidentialité, et à prendre des décisions mieux éclairées avant d'investir dans un déploiement plus large.
Consultez la page produit XREAL One Pro pour en savoir plus sur le produit, puis contactez VR Expert pour déterminer si l'appareil et la configuration logicielle correspondent aux exigences de développement et de pilote de votre organisation.
Lien connexe suggéré : Test des XREAL One Pro pour les professionnels
























