MR and Azure 311 - Microsoft GraphMR and Azure 311 - Microsoft Graph

Notes

Les tutoriels Mixed Reality Academy ont été conçus pour les appareils HoloLens (1re génération) et les casques immersifs de réalité mixte.The Mixed Reality Academy tutorials were designed with HoloLens (1st gen) and Mixed Reality Immersive Headsets in mind. Nous estimons qu’il est important de laisser ces tutoriels à la disposition des développeurs qui recherchent encore des conseils pour développer des applications sur ces appareils.As such, we feel it is important to leave these tutorials in place for developers who are still looking for guidance in developing for those devices. Notez que ces tutoriels ne sont pas mis à jour avec les derniers ensembles d’outils ou interactions utilisés pour HoloLens 2.These tutorials will not be updated with the latest toolsets or interactions being used for HoloLens 2. Ils sont fournis dans le but de fonctionner sur les appareils pris en charge.They will be maintained to continue working on the supported devices. Une nouvelle série de didacticiels sera publiée à l’avenir qui vous montrera comment développer pour HoloLens 2.There will be a new series of tutorials that will be posted in the future that will demonstrate how to develop for HoloLens 2. Cet avis sera mis à jour avec un lien vers ces didacticiels lors de leur publication.This notice will be updated with a link to those tutorials when they are posted.

Dans ce cours, vous allez apprendre à utiliser Microsoft Graph pour vous connecter à votre compte Microsoft à l’aide de l’authentification sécurisée dans une application de réalité mixte.In this course, you will learn how to use Microsoft Graph to log in into your Microsoft account using secure authentication within a mixed reality application. Vous allez ensuite récupérer et afficher vos réunions planifiées dans l’interface de l’application.You will then retrieve and display your scheduled meetings in the application interface.

Microsoft Graph est un ensemble d’API conçues pour permettre l’accès à de nombreux services de Microsoft.Microsoft Graph is a set of APIs designed to enable access to many of Microsoft's services. Microsoft décrit Microsoft Graph comme une matrice de ressources connectées par des relations, ce qui signifie qu’elle permet à une application d’accéder à toutes sortes de données utilisateur connectées.Microsoft describes Microsoft Graph as being a matrix of resources connected by relationships, meaning it allows an application to access all sorts of connected user data. Pour plus d’informations, consultez la page Microsoft Graph.For more information, visit the Microsoft Graph page.

Le développement inclut la création d’une application dans laquelle l’utilisateur sera invité à pointer vers le regard, puis à appuyer sur une sphère, ce qui invite l’utilisateur à se connecter en toute sécurité à un compte Microsoft.Development will include the creation of an app where the user will be instructed to gaze at and then tap a sphere, which will prompt the user to log in safely to a Microsoft account. Une fois connecté à son compte, l’utilisateur est en mesure de consulter la liste des réunions planifiées pour la journée.Once logged in to their account, the user will be able to see a list of meetings scheduled for the day.

Une fois ce cours terminé, vous disposerez d’une application HoloLens de réalité mixte, qui sera en mesure d’effectuer les opérations suivantes :Having completed this course, you will have a mixed reality HoloLens application, which will be able to do the following:

  1. À l’aide du geste TAP, appuyez sur un objet, qui invite l’utilisateur à se connecter à un compte Microsoft (en sortant de l’application pour se connecter, puis de nouveau dans l’application).Using the Tap gesture, tap on an object, which will prompt the user to log into a Microsoft Account (moving out of the app to log in, and then back into the app again).
  2. Affichez la liste des réunions planifiées pour la journée.View a list of meetings scheduled for the day.

Dans votre application, c’est à vous de savoir comment vous allez intégrer les résultats à votre conception.In your application, it is up to you as to how you will integrate the results with your design. Ce cours est conçu pour vous apprendre à intégrer un service Azure à votre projet Unity.This course is designed to teach you how to integrate an Azure Service with your Unity project. C’est votre travail d’utiliser les connaissances que vous avez acquises dans ce cours pour améliorer votre application de réalité mixte.It is your job to use the knowledge you gain from this course to enhance your mixed reality application.

Prise en charge des appareilsDevice support

CoursCourse HoloLensHoloLens Casques immersifsImmersive headsets
Réalité mixte - Azure - Cours 311 : Microsoft GraphMR and Azure 311: Microsoft Graph ✔️✔️

PrérequisPrerequisites

Notes

Ce didacticiel est conçu pour les développeurs qui ont une expérience de base avec Unity et C#.This tutorial is designed for developers who have basic experience with Unity and C#. Sachez également que les conditions préalables et les instructions écrites dans ce document représentent les éléments qui ont été testés et vérifiés au moment de la rédaction (juillet 2018).Please also be aware that the prerequisites and written instructions within this document represent what has been tested and verified at the time of writing (July 2018). Vous êtes libre d’utiliser le logiciel le plus récent, tel qu’indiqué dans l’article installer les outils , bien qu’il ne soit pas supposé que les informations de ce cours correspondent parfaitement à ce que vous trouverez dans les logiciels plus récents que ceux répertoriés ci-dessous.You are free to use the latest software, as listed within the install the tools article, though it should not be assumed that the information in this course will perfectly match what you will find in newer software than what is listed below.

Nous vous recommandons d’utiliser le matériel et les logiciels suivants pour ce cours :We recommend the following hardware and software for this course:

Avant de commencerBefore you start

  1. Pour éviter de rencontrer des problèmes lors de la création de ce projet, il est fortement recommandé de créer le projet mentionné dans ce didacticiel dans un dossier racine ou dans un dossier racine (les chemins de dossiers longs peuvent entraîner des problèmes au moment de la génération).To avoid encountering issues building this project, it is strongly suggested that you create the project mentioned in this tutorial in a root or near-root folder (long folder paths can cause issues at build-time).
  2. Configurez et testez votre HoloLens.Set up and test your HoloLens. Si vous avez besoin de la prise en charge de la configuration de votre HoloLens, consultez l’article Configuration de hololens.If you need support setting up your HoloLens, make sure to visit the HoloLens setup article.
  3. Il est judicieux d’effectuer un réglage de l’étalonnage et du capteur au début du développement d’une nouvelle application HoloLens (parfois, il peut être utile d’effectuer ces tâches pour chaque utilisateur).It is a good idea to perform Calibration and Sensor Tuning when beginning developing a new HoloLens App (sometimes it can help to perform those tasks for each user).

Pour obtenir de l’aide sur l’étalonnage, veuillez suivre ce lien vers l’article d’étalonnage HoloLens.For help on Calibration, please follow this link to the HoloLens Calibration article.

Pour obtenir de l’aide sur le réglage du capteur, veuillez suivre ce lien vers l’article sur le paramétrage du capteur HoloLens.For help on Sensor Tuning, please follow this link to the HoloLens Sensor Tuning article.

Chapitre 1-créer votre application dans le portail d’inscription des applicationsChapter 1 - Create your app in the Application Registration Portal

Pour commencer, vous devrez créer et inscrire votre application dans le portail d’inscription des applications.To begin with, you will need to create and register your application in the Application Registration Portal.

Dans ce chapitre, vous trouverez également la clé de service qui vous permettra d’effectuer des appels à Microsoft Graph pour accéder au contenu de votre compte.In this Chapter you will also find the Service Key that will allow you to make calls to Microsoft Graph to access your account content.

  1. Accédez au portail d’inscription des applications Microsoft et connectez-vous avec votre compte Microsoft.Navigate to the Microsoft Application Registration Portal and login with your Microsoft Account. Une fois que vous êtes connecté, vous êtes redirigé vers le portail d’inscription des applications.Once you have logged in, you will be redirected to the Application Registration Portal.

  2. Dans la section mes applications , cliquez sur le bouton Ajouter une application.In the My applications section, click on the button Add an app.

    Important

    Le portail d’inscription des applications peut paraître différent, selon que vous avez déjà travaillé avec Microsoft Graph.The Application Registration Portal can look different, depending on whether you have previously worked with Microsoft Graph. Les captures d’écran ci-dessous affichent ces différentes versions.The below screenshots display these different versions.

  3. Ajoutez un nom pour votre application, puis cliquez sur créer.Add a name for your application and click Create.

  4. Une fois l’application créée, vous êtes redirigé vers la page principale de l’application.Once the application has been created, you will be redirected to the application main page. Copiez l’ID de l' application et veillez à noter cette valeur dans un endroit sûr. vous l’utiliserez bientôt dans votre code.Copy the Application Id and make sure to note this value somewhere safe, you will use it soon in your code.

  5. Dans la section plateformes , assurez-vous que application native est affiché.In the Platforms section, make sure Native Application is displayed. Si ce n’est pas le cas, cliquez sur Ajouter une plateforme , puis sélectionnez application native.If not click on Add Platform and select Native Application.

  6. Faites défiler la page vers le dessous et, dans la section intitulée Microsoft Graph autorisations , vous devez ajouter des autorisations supplémentaires pour l’application.Scroll down in the same page and in the section called Microsoft Graph Permissions you will need to add additional permissions for the application. Cliquez sur Ajouter en regard de autorisations déléguées.Click on Add next to Delegated Permissions.

  7. Étant donné que vous souhaitez que votre application accède au calendrier de l’utilisateur, activez la case à cocher calendriers. lire , puis cliquez sur OK.Since you want your application to access the user's Calendar, check the box called Calendars.Read and click OK.

  8. Faites défiler vers le bas et cliquez sur le bouton Enregistrer .Scroll to the bottom and click the Save button.

  9. Votre enregistrement sera confirmé et vous pourrez vous déconnecter du portail d’inscription des applications.Your save will be confirmed, and you can log out from the Application Registration Portal.

Chapitre 2-configurer le projet UnityChapter 2 - Set up the Unity project

Ce qui suit est une configuration classique pour le développement avec une réalité mixte, et, par conséquent, est un bon modèle pour d’autres projets.The following is a typical set up for developing with mixed reality, and as such, is a good template for other projects.

  1. Ouvrez Unity et cliquez sur nouveau.Open Unity and click New.

  2. Vous devez fournir un nom de projet Unity.You need to provide a Unity project name. Insérez MSGraphMR.Insert MSGraphMR. Assurez-vous que le modèle de projet est défini sur 3D.Make sure the project template is set to 3D. Définissez l' emplacement approprié pour vous (n’oubliez pas que les répertoires racine sont mieux adaptés).Set the Location to somewhere appropriate for you (remember, closer to root directories is better). Ensuite, cliquez sur créer un projet.Then, click Create project.

  3. Si Unity est ouvert, il est conseillé de vérifier que l' éditeur de script par défaut est défini sur Visual Studio.With Unity open, it is worth checking the default Script Editor is set to Visual Studio. Accédez à modifier > les Préférences , puis à partir de la nouvelle fenêtre, accédez à outils externes.Go to Edit > Preferences and then from the new window, navigate to External Tools. Remplacez l' éditeur de script externe par Visual Studio 2017.Change External Script Editor to Visual Studio 2017. Fermez la fenêtre Préférences .Close the Preferences window.

  4. Accédez à fichier > paramètres de build et sélectionnez plateforme Windows universelle, puis cliquez sur le bouton changer de plateforme pour appliquer votre sélection.Go to File > Build Settings and select Universal Windows Platform, then click on the Switch Platform button to apply your selection.

  5. Tout en conservant les paramètres de génération de fichiers, assurez-vous > Build Settings que :While still in File > Build Settings, make sure that:

    1. L' appareil cible est défini sur HoloLensTarget Device is set to HoloLens

    2. Le type de build est D3DBuild Type is set to D3D

    3. Le SDK est configuré sur le dernier installéSDK is set to Latest installed

    4. Version de Visual Studio définie sur le dernier installéVisual Studio Version is set to Latest installed

    5. La génération et l’exécution sont définies sur l' ordinateur localBuild and Run is set to Local Machine

    6. Enregistrez la scène et ajoutez-la à la Build.Save the scene and add it to the build.

      1. Pour ce faire, sélectionnez Ajouter des scènes ouvertes.Do this by selecting Add Open Scenes. Une fenêtre d’enregistrement s’affiche.A save window will appear.

      2. Créez un dossier pour cela, ainsi que toute nouvelle scène.Create a new folder for this, and any future, scene. Sélectionnez le bouton nouveau dossier pour créer un nouveau dossier, puis nommez-le scenes.Select the New folder button, to create a new folder, name it Scenes.

      3. Ouvrez le dossier scenes nouvellement créé, puis dans le champ nom de fichier:, tapez MR_ComputerVisionScene, puis cliquez sur Enregistrer.Open your newly created Scenes folder, and then in the File name: text field, type MR_ComputerVisionScene, then click Save.

        Important

        Sachez que vous devez enregistrer vos scènes Unity dans le dossier ressources , car elles doivent être associées au projet Unity.Be aware, you must save your Unity scenes within the Assets folder, as they must be associated with the Unity project. La création du dossier scenes (et d’autres dossiers similaires) est un moyen classique de structurer un projet Unity.Creating the scenes folder (and other similar folders) is a typical way of structuring a Unity project.

    7. Les paramètres restants, dans paramètres de build, doivent être laissés par défaut pour le moment.The remaining settings, in Build Settings, should be left as default for now.

  6. Dans la fenêtre paramètres de build , cliquez sur le bouton Paramètres du lecteur pour ouvrir le panneau correspondant dans l’espace où se trouve l' inspecteur .In the Build Settings window, click on the Player Settings button, this will open the related panel in the space where the Inspector is located.

  7. Dans ce volet, quelques paramètres doivent être vérifiés :In this panel, a few settings need to be verified:

    1. Sous l’onglet autres paramètres :In the Other Settings tab:

      1. La version du runtime de script doit être expérimentale (.net 4,6 équivalent), ce qui déclenche la nécessité de redémarrer l’éditeur.Scripting Runtime Version should be Experimental (.NET 4.6 Equivalent), which will trigger a need to restart the Editor.

      2. Le backend de script doit être .netScripting Backend should be .NET

      3. Le niveau de compatibilité de l’API doit être .net 4,6API Compatibility Level should be .NET 4.6

    2. Dans l’onglet paramètres de publication , sous fonctionnalités, activez la case à cocher :Within the Publishing Settings tab, under Capabilities, check:

      • InternetClientInternetClient

    3. Plus bas dans le panneau, dans les paramètres XR (situés sous paramètres de publication), cochez la réalité virtuelle prise en charge, assurez-vous que le Kit de développement logiciel (SDK) Windows Mixed Reality est ajouté.Further down the panel, in XR Settings (found below Publish Settings), check Virtual Reality Supported, make sure the Windows Mixed Reality SDK is added.

  8. De retour dans les paramètres de build, les projets Unity C# ne sont plus grisés. Cochez la case en regard de cette option.Back in Build Settings, Unity C# Projects is no longer greyed out; check the checkbox next to this.

  9. Fermez la fenêtre Build Settings.Close the Build Settings window.

  10. Enregistrez votre scène et votre projet (fichier > Save scenes/file > Save Project).Save your scene and project (FILE > SAVE SCENES / FILE > SAVE PROJECT).

Chapitre 3-bibliothèques d’importation dans UnityChapter 3 - Import Libraries in Unity

Important

Si vous souhaitez ignorer le composant Unity Set up de ce cours et continuer directement dans le code, n’hésitez pas à télécharger ce fichier Azure-Mr-311. pour Unity, à l’importer dans votre projet en tant que package personnalisé, puis à passer au Chapitre 5.If you wish to skip the Unity Set up component of this course, and continue straight into code, feel free to download this Azure-MR-311.unitypackage, import it into your project as a Custom Package, and then continue from Chapter 5.

Pour utiliser Microsoft Graph dans Unity, vous devez utiliser la dll Microsoft. Identity. client .To use Microsoft Graph within Unity you need to make use of the Microsoft.Identity.Client DLL. Il est toutefois possible d’utiliser le kit de développement logiciel (SDK) Microsoft Graph, mais il nécessite l’ajout d’un package NuGet après la génération du projet Unity (c’est-à-dire la modification du projet après la génération).It is possible to use the Microsoft Graph SDK, however, it will require the addition of a NuGet package after you build the Unity project (meaning editing the project post-build). Il est considéré comme plus simple d’importer les dll requises directement dans Unity.It is considered simpler to import the required DLLs directly into Unity.

Notes

Il existe actuellement un problème connu dans Unity qui nécessite que les plug-ins soient reconfigurés après l’importation.There is currently a known issue in Unity which requires plugins to be reconfigured after import. Ces étapes (4-7 dans cette section) ne sont plus nécessaires une fois que le bogue a été résolu.These steps (4 - 7 in this section) will no longer be required after the bug has been resolved.

Pour importer Microsoft Graph dans votre propre projet, téléchargez le fichier MSGraph_LabPlugins.zip.To import Microsoft Graph into your own project, download the MSGraph_LabPlugins.zip file. Ce package a été créé avec les versions des bibliothèques qui ont été testées.This package has been created with versions of the libraries that have been tested.

Si vous souhaitez en savoir plus sur l’ajout de dll personnalisées à votre projet Unity, suivez ce lien.If you wish to know more about how to add custom DLLs to your Unity project, follow this link.

Pour importer le package :To import the package:

  1. Ajoutez le package Unity à Unity à l’aide de l' > option de menu package d'importation de packages > personnalisés .Add the Unity Package to Unity by using the Assets > Import Package > Custom Package menu option. Sélectionnez le package que vous venez de télécharger.Select the package you just downloaded.

  2. Dans la zone importer le package Unity qui s’affiche, vérifiez que tous les plug-ins sous (et y compris) sont sélectionnés.In the Import Unity Package box that pops up, ensure everything under (and including) Plugins is selected.

  3. Cliquez sur le bouton Importer pour ajouter les éléments à votre projet.Click the Import button to add the items to your project.

  4. Accédez au dossier MSGraph sous plug-ins dans le panneau Projet et sélectionnez le plug-in appelé Microsoft. Identity. client.Go to the MSGraph folder under Plugins in the Project Panel and select the plugin called Microsoft.Identity.Client.

  5. Une fois le plug-in sélectionné, assurez-vous que toutes les plateformes sont décochées, vérifiez que WSAPlayer est également désactivé, puis cliquez sur appliquer.With the plugin selected, ensure that Any Platform is unchecked, then ensure that WSAPlayer is also unchecked, then click Apply. Cela vous permet de vérifier que les fichiers sont correctement configurés.This is just to confirm that the files are configured correctly.

    Notes

    Le marquage de ces plug-ins permet de les configurer pour qu’ils soient utilisés uniquement dans l’éditeur Unity.Marking these plugins configures them to only be used in the Unity Editor. Il existe un ensemble différent de dll dans le dossier WSA qui sera utilisé une fois que le projet est exporté d’Unity en tant qu’application Windows universelle.There are a different set of DLLs in the WSA folder which will be used after the project is exported from Unity as a Universal Windows Application.

  6. Ensuite, vous devez ouvrir le dossier WSA , dans le dossier MSGraph .Next, you need to open the WSA folder, within the MSGraph folder. Vous verrez une copie du même fichier que celui que vous venez de configurer.You will see a copy of the same file you just configured. Sélectionnez le fichier, puis dans l’inspecteur :Select the file, and then in the inspector:

    • Vérifiez que toutes les plateformes sont désactivées et que seul WSAPlayer est activé.ensure that Any Platform is unchecked, and that only WSAPlayer is checked.

    • Vérifiez que le Kit de développement logiciel (SDK) a la valeur UWP et que le serveur principal de script est défini sur le point netEnsure SDK is set to UWP, and Scripting Backend is set to Dot Net

    • Vérifiez que l’option ne pas traiter est cochée.Ensure that Don't process is checked.

  7. Cliquez sur Appliquer.Click Apply.

Chapitre 4-Configuration de l’appareil photoChapter 4 - Camera Setup

Au cours de ce chapitre, vous allez configurer la caméra principale de votre scène :During this Chapter you will set up the Main Camera of your scene:

  1. Dans le panneau hiérarchie, sélectionnez l' appareil photo principal.In the Hierarchy Panel, select the Main Camera.

  2. Une fois sélectionné, vous pouvez voir tous les composants de la caméra principale dans le panneau inspecteur .Once selected, you will be able to see all the components of the Main Camera in the Inspector panel.

    1. L' objet Camera doit être nommé Camera main (Notez l’orthographe !)The Camera object must be named Main Camera (note the spelling!)

    2. La balise principale de l’appareil photo doit être définie sur MainCamera (Notez l’orthographe !)The Main Camera Tag must be set to MainCamera (note the spelling!)

    3. Vérifiez que la position de la transformation est définie sur 0, 0, 0Make sure the Transform Position is set to 0, 0, 0

    4. Définir des indicateurs clairs sur couleur unieSet Clear Flags to Solid Color

    5. Définir la couleur d’arrière-plan du composant Camera sur Black, alpha 0 (code hexadécimal : #00000000)Set the Background Color of the Camera Component to Black, Alpha 0 (Hex Code: #00000000)

  3. La dernière structure de l’objet dans le volet de la hiérarchie doit être similaire à celle illustrée dans l’image ci-dessous :The final object structure in the Hierarchy Panel should be like the one shown in the image below:

Chapitre 5-créer une classe MeetingsUIChapter 5 - Create MeetingsUI class

Le premier script que vous devez créer est MeetingsUI, qui est responsable de l’hébergement et du remplissage de l’interface utilisateur de l’application (message de bienvenue, instructions et détails des réunions).The first script you need to create is MeetingsUI, which is responsible for hosting and populating the UI of the application (welcome message, instructions and the meetings details).

Pour créer cette classe :To create this class:

  1. Cliquez avec le bouton droit sur le dossier ressources dans le panneau Projet, puis sélectionnez créer un > dossier.Right-click on the Assets folder in the Project Panel, then select Create > Folder. Nommez le dossier scripts.Name the folder Scripts.

  2. Ouvrez le dossier scripts , puis, dans ce dossier, cliquez avec le bouton droit sur créer un > script C#.Open the Scripts folder then, within that folder, right-click, Create > C# Script. Nommez le script MeetingsUI.Name the script MeetingsUI.

  3. Double-cliquez sur le nouveau script MeetingsUI pour l’ouvrir avec Visual Studio.Double-click on the new MeetingsUI script to open it with Visual Studio.

  4. Insérez les espaces de noms suivants :Insert the following namespaces:

    using System;
    using UnityEngine;
    
  5. À l’intérieur de la classe, insérez les variables suivantes :Inside the class insert the following variables:

        /// <summary>
        /// Allows this class to behave like a singleton
        /// </summary>
        public static MeetingsUI Instance;
    
        /// <summary>
        /// The 3D text of the scene
        /// </summary>
        private TextMesh _meetingDisplayTextMesh;
    
  6. Remplacez ensuite la méthode Start () et ajoutez une méthode éveillé () .Then replace the Start() method and add an Awake() method. Ils sont appelés lorsque la classe est initialisée :These will be called when the class initializes:

        /// <summary>
        /// Called on initialization
        /// </summary>
        void Awake()
        {
            Instance = this;
        }
    
        /// <summary>
        /// Called on initialization, after Awake
        /// </summary>
        void Start ()
        {
            // Creating the text mesh within the scene
            _meetingDisplayTextMesh = CreateMeetingsDisplay();
        }
    
  7. Ajoutez les méthodes responsables de la création de l' interface utilisateur des réunions et remplissez-la avec les réunions en cours lorsque vous y êtes invité :Add the methods responsible for creating the Meetings UI and populate it with the current meetings when requested:

        /// <summary>
        /// Set the welcome message for the user
        /// </summary>
        internal void WelcomeUser(string userName)
        {
            if(!string.IsNullOrEmpty(userName))
            {
                _meetingDisplayTextMesh.text = $"Welcome {userName}";
            }
            else 
            {
                _meetingDisplayTextMesh.text = "Welcome";
            }
        }
    
        /// <summary>
        /// Set up the parameters for the UI text
        /// </summary>
        /// <returns>Returns the 3D text in the scene</returns>
        private TextMesh CreateMeetingsDisplay()
        {
            GameObject display = new GameObject();
            display.transform.localScale = new Vector3(0.03f, 0.03f, 0.03f);
            display.transform.position = new Vector3(-3.5f, 2f, 9f);
            TextMesh textMesh = display.AddComponent<TextMesh>();
            textMesh.anchor = TextAnchor.MiddleLeft;
            textMesh.alignment = TextAlignment.Left;
            textMesh.fontSize = 80;
            textMesh.text = "Welcome! \nPlease gaze at the button" +
                "\nand use the Tap Gesture to display your meetings";
    
            return textMesh;
        }
    
        /// <summary>
        /// Adds a new Meeting in the UI by chaining the existing UI text
        /// </summary>
        internal void AddMeeting(string subject, DateTime dateTime, string location)
        {
            string newText = $"\n{_meetingDisplayTextMesh.text}\n\n Meeting,\nSubject: {subject},\nToday at {dateTime},\nLocation: {location}";
    
            _meetingDisplayTextMesh.text = newText;
        }
    
  8. Supprimez la méthode Update () et Enregistrez vos modifications dans Visual Studio avant de revenir à Unity.Delete the Update() method, and save your changes in Visual Studio before returning to Unity.

Chapitre 6-créer la classe GraphChapter 6 - Create the Graph class

Le script suivant à créer est le script Graph .The next script to create is the Graph script. Ce script est chargé d’effectuer les appels pour authentifier l’utilisateur et de récupérer les réunions planifiées pour le jour actuel à partir du calendrier de l’utilisateur.This script is responsible for making the calls to authenticate the user and retrieve the scheduled meetings for the current day from the user's calendar.

Pour créer cette classe :To create this class:

  1. Double-cliquez sur le dossier scripts pour l’ouvrir.Double-click on the Scripts folder, to open it.

  2. Cliquez avec le bouton droit dans le dossier scripts , puis cliquez sur créer un > script C#.Right-click inside the Scripts folder, click Create > C# Script. Nommez le graphique de script.Name the script Graph.

  3. Double-cliquez sur le script pour l’ouvrir avec Visual Studio.Double-click on the script to open it with Visual Studio.

  4. Insérez les espaces de noms suivants :Insert the following namespaces:

    using System.Collections.Generic;
    using UnityEngine;
    using Microsoft.Identity.Client;
    using System;
    using System.Threading.Tasks;
    
    #if !UNITY_EDITOR && UNITY_WSA
    using System.Net.Http;
    using System.Net.Http.Headers;
    using Windows.Storage;
    #endif
    

    Important

    Vous remarquerez que certaines parties du code de ce script sont encapsulées autour des directives de précompilation. cela permet d’éviter les problèmes liés aux bibliothèques lors de la génération de la solution Visual Studio.You will notice that parts of the code in this script are wrapped around Precompile Directives, this is to avoid issues with the libraries when building the Visual Studio Solution.

  5. Supprimez les méthodes Start () et Update () , car elles ne seront pas utilisées.Delete the Start() and Update() methods, as they will not be used.

  6. En dehors de la classe Graph , insérez les objets suivants, qui sont nécessaires pour désérialiser l’objet JSON représentant les réunions planifiées quotidiennement :Outside the Graph class, insert the following objects, which are necessary to deserialize the JSON object representing the daily scheduled meetings:

    /// <summary>
    /// The object hosting the scheduled meetings
    /// </summary>
    [Serializable]
    public class Rootobject
    {
        public List<Value> value;
    }
    
    [Serializable]
    public class Value
    {
        public string subject { get; set; }
        public StartTime start { get; set; }
        public Location location { get; set; }
    }
    
    [Serializable]
    public class StartTime
    {
        public string dateTime;
    
        private DateTime? _startDateTime;
        public DateTime StartDateTime
        {
            get
            {
                if (_startDateTime != null)
                    return _startDateTime.Value;
                DateTime dt;
                DateTime.TryParse(dateTime, out dt);
                _startDateTime = dt;
                return _startDateTime.Value;
            }
        }
    }
    
    [Serializable]
    public class Location
    {
        public string displayName { get; set; }
    }
    
  7. À l’intérieur de la classe Graph , ajoutez les variables suivantes :Inside the Graph class, add the following variables:

        /// <summary>
        /// Insert your Application Id here
        /// </summary>
        private string _appId = "-- Insert your Application Id here --";
    
        /// <summary>
        /// Application scopes, determine Microsoft Graph accessibility level to user account
        /// </summary>
        private IEnumerable<string> _scopes = new List<string>() { "User.Read", "Calendars.Read" };
    
        /// <summary>
        /// Microsoft Graph API, user reference
        /// </summary>
        private PublicClientApplication _client;
    
        /// <summary>
        /// Microsoft Graph API, authentication
        /// </summary>
        private AuthenticationResult _authResult;
    
    

    Notes

    Modifiez la valeur AppID pour qu’elle soit l' ID d’application que vous avez noté au Chapitre 1, étape 4.Change the appId value to be the App Id that you have noted in Chapter 1, step 4. Cette valeur doit être identique à celle affichée dans le portail d’inscription des applications, dans la page d’inscription de votre application.This value should be the same as that displayed in the Application Registration Portal, in your application registration page.

  8. Dans la classe Graph , ajoutez les méthodes SignInAsync () et AquireTokenAsync (), qui invitent l’utilisateur à insérer les informations d’identification de connexion.Within the Graph class, add the methods SignInAsync() and AquireTokenAsync(), that will prompt the user to insert the log-in credentials.

        /// <summary>
        /// Begin the Sign In process using Microsoft Graph Library
        /// </summary>
        internal async void SignInAsync()
        {
    #if !UNITY_EDITOR && UNITY_WSA
            // Set up Grap user settings, determine if needs auth
            ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
            string userId = localSettings.Values["UserId"] as string;
            _client = new PublicClientApplication(_appId);
    
            // Attempt authentication
            _authResult = await AcquireTokenAsync(_client, _scopes, userId);
    
            // If authentication is successful, retrieve the meetings
            if (!string.IsNullOrEmpty(_authResult.AccessToken))
            {
                // Once Auth as been completed, find the meetings for the day
                await ListMeetingsAsync(_authResult.AccessToken);
            }
    #endif
        }
    
        /// <summary>
        /// Attempt to retrieve the Access Token by either retrieving
        /// previously stored credentials or by prompting user to Login
        /// </summary>
        private async Task<AuthenticationResult> AcquireTokenAsync(
            IPublicClientApplication app, IEnumerable<string> scopes, string userId)
        {
            IUser user = !string.IsNullOrEmpty(userId) ? app.GetUser(userId) : null;
            string userName = user != null ? user.Name : "null";
    
            // Once the User name is found, display it as a welcome message
            MeetingsUI.Instance.WelcomeUser(userName);
    
            // Attempt to Log In the user with a pre-stored token. Only happens
            // in case the user Logged In with this app on this device previously
            try
            {
                _authResult = await app.AcquireTokenSilentAsync(scopes, user);
            }
            catch (MsalUiRequiredException)
            {
                // Pre-stored token not found, prompt the user to log-in 
                try
                {
                    _authResult = await app.AcquireTokenAsync(scopes);
                }
                catch (MsalException msalex)
                {
                    Debug.Log($"Error Acquiring Token: {msalex.Message}");
                    return _authResult;
                }
            }
    
            MeetingsUI.Instance.WelcomeUser(_authResult.User.Name);
    
    #if !UNITY_EDITOR && UNITY_WSA
            ApplicationData.Current.LocalSettings.Values["UserId"] = 
            _authResult.User.Identifier;
    #endif
            return _authResult;
        }
    
  9. Ajoutez les deux méthodes suivantes :Add the following two methods:

    1. BuildTodayCalendarEndpoint (), qui génère l’URI spécifiant le jour et l’intervalle de temps pendant lesquels les réunions planifiées sont récupérées.BuildTodayCalendarEndpoint(), which builds the URI specifying the day, and time span, in which the scheduled meetings are retrieved.

    2. ListMeetingsAsync (), qui demande les réunions planifiées à partir de Microsoft Graph.ListMeetingsAsync(), which requests the scheduled meetings from Microsoft Graph.

        /// <summary>
        /// Build the endpoint to retrieve the meetings for the current day.
        /// </summary>
        /// <returns>Returns the Calendar Endpoint</returns>
        public string BuildTodayCalendarEndpoint()
        {
            DateTime startOfTheDay = DateTime.Today.AddDays(0);
            DateTime endOfTheDay = DateTime.Today.AddDays(1);
            DateTime startOfTheDayUTC = startOfTheDay.ToUniversalTime();
            DateTime endOfTheDayUTC = endOfTheDay.ToUniversalTime();
    
            string todayDate = startOfTheDayUTC.ToString("o");
            string tomorrowDate = endOfTheDayUTC.ToString("o");
            string todayCalendarEndpoint = string.Format(
                "https://graph.microsoft.com/v1.0/me/calendarview?startdatetime={0}&enddatetime={1}",
                todayDate,
                tomorrowDate);
    
            return todayCalendarEndpoint;
        }
    
        /// <summary>
        /// Request all the scheduled meetings for the current day.
        /// </summary>
        private async Task ListMeetingsAsync(string accessToken)
        {
    #if !UNITY_EDITOR && UNITY_WSA
            var http = new HttpClient();
    
            http.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Bearer", accessToken);
            var response = await http.GetAsync(BuildTodayCalendarEndpoint());
    
            var jsonResponse = await response.Content.ReadAsStringAsync();
    
            Rootobject rootObject = new Rootobject();
            try
            {
                // Parse the JSON response.
                rootObject = JsonUtility.FromJson<Rootobject>(jsonResponse);
    
                // Sort the meeting list by starting time.
                rootObject.value.Sort((x, y) => DateTime.Compare(x.start.StartDateTime, y.start.StartDateTime));
    
                // Populate the UI with the meetings.
                for (int i = 0; i < rootObject.value.Count; i++)
                {
                    MeetingsUI.Instance.AddMeeting(rootObject.value[i].subject,
                                                rootObject.value[i].start.StartDateTime.ToLocalTime(),
                                                rootObject.value[i].location.displayName);
                }
            }
            catch (Exception ex)
            {
                Debug.Log($"Error = {ex.Message}");
                return;
            }
    #endif
        }
    
  10. Vous avez maintenant terminé le script Graph .You have now completed the Graph script. Enregistrez vos modifications dans Visual Studio avant de revenir à Unity.Save your changes in Visual Studio before returning to Unity.

Chapitre 7-créer le script GazeInputChapter 7 - Create the GazeInput script

Vous allez maintenant créer le GazeInput.You will now create the GazeInput. Cette classe gère et effectue le suivi du point de regard de l’utilisateur à l’aide d’un Raycast provenant de la caméra principale, en projetant vers l’avant.This class handles and keeps track of the user's gaze, using a Raycast coming from the Main Camera, projecting forward.

Pour créer le script :To create the script:

  1. Double-cliquez sur le dossier scripts pour l’ouvrir.Double-click on the Scripts folder, to open it.

  2. Cliquez avec le bouton droit dans le dossier scripts , puis cliquez sur créer un > script C#.Right-click inside the Scripts folder, click Create > C# Script. Nommez le script GazeInput.Name the script GazeInput.

  3. Double-cliquez sur le script pour l’ouvrir avec Visual Studio.Double-click on the script to open it with Visual Studio.

  4. Modifiez le code des espaces de noms pour qu’il corresponde à celui ci-dessous, avec l’ajout de la balise'[ System. Serializable ]'au-dessus de votre classe GazeInput , afin qu’elle puisse être sérialisée :Change the namespaces code to match the one below, along with adding the '[System.Serializable]' tag above your GazeInput class, so that it can be serialized:

    using UnityEngine;
    
    /// <summary>
    /// Class responsible for the User's Gaze interactions
    /// </summary>
    [System.Serializable]
    public class GazeInput : MonoBehaviour
    {
    
  5. À l’intérieur de la classe GazeInput , ajoutez les variables suivantes :Inside the GazeInput class, add the following variables:

        [Tooltip("Used to compare whether an object is to be interacted with.")]
        internal string InteractibleTag = "SignInButton";
    
        /// <summary>
        /// Length of the gaze
        /// </summary>
        internal float GazeMaxDistance = 300;
    
        /// <summary>
        /// Object currently gazed
        /// </summary>
        internal GameObject FocusedObject { get; private set; }
    
        internal GameObject oldFocusedObject { get; private set; }
    
        internal RaycastHit HitInfo { get; private set; }
    
        /// <summary>
        /// Cursor object visible in the scene
        /// </summary>
        internal GameObject Cursor { get; private set; }
    
        internal bool Hit { get; private set; }
    
        internal Vector3 Position { get; private set; }
    
        internal Vector3 Normal { get; private set; }
    
        private Vector3 _gazeOrigin;
    
        private Vector3 _gazeDirection;
    
  6. Ajoutez la méthode CreateCursor () pour créer le curseur HoloLens dans la scène, puis appelez la méthode à partir de la méthode Start () :Add the CreateCursor() method to create the HoloLens cursor in the scene, and call the method from the Start() method:

        /// <summary>
        /// Start method used upon initialisation.
        /// </summary>
        internal virtual void Start()
        {
            FocusedObject = null;
            Cursor = CreateCursor();
        }
    
        /// <summary>
        /// Method to create a cursor object.
        /// </summary>
        internal GameObject CreateCursor()
        {
            GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            newCursor.SetActive(false);
            // Remove the collider, so it doesn't block raycast.
            Destroy(newCursor.GetComponent<SphereCollider>());
            newCursor.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
            Material mat = new Material(Shader.Find("Diffuse"));
            newCursor.GetComponent<MeshRenderer>().material = mat;
            mat.color = Color.HSVToRGB(0.0223f, 0.7922f, 1.000f);
            newCursor.SetActive(true);
    
            return newCursor;
        }
    
  7. Les méthodes suivantes activent le point de Raycast de regard et assurent le suivi des objets ayant le focus.The following methods enable the gaze Raycast and keep track of the focused objects.

    /// <summary>
    /// Called every frame
    /// </summary>
    internal virtual void Update()
    {
        _gazeOrigin = Camera.main.transform.position;
    
        _gazeDirection = Camera.main.transform.forward;
    
        UpdateRaycast();
    }
    /// <summary>
    /// Reset the old focused object, stop the gaze timer, and send data if it
    /// is greater than one.
    /// </summary>
    private void ResetFocusedObject()
    {
        // Ensure the old focused object is not null.
        if (oldFocusedObject != null)
        {
            if (oldFocusedObject.CompareTag(InteractibleTag))
            {
                // Provide the 'Gaze Exited' event.
                oldFocusedObject.SendMessage("OnGazeExited", SendMessageOptions.DontRequireReceiver);
            }
        }
    }
    
        private void UpdateRaycast()
        {
            // Set the old focused gameobject.
            oldFocusedObject = FocusedObject;
            RaycastHit hitInfo;
    
            // Initialise Raycasting.
            Hit = Physics.Raycast(_gazeOrigin,
                _gazeDirection,
                out hitInfo,
                GazeMaxDistance);
                HitInfo = hitInfo;
    
            // Check whether raycast has hit.
            if (Hit == true)
            {
                Position = hitInfo.point;
                Normal = hitInfo.normal;
    
                // Check whether the hit has a collider.
                if (hitInfo.collider != null)
                {
                    // Set the focused object with what the user just looked at.
                    FocusedObject = hitInfo.collider.gameObject;
                }
                else
                {
                    // Object looked on is not valid, set focused gameobject to null.
                    FocusedObject = null;
                }
            }
            else
            {
                // No object looked upon, set focused gameobject to null.
                FocusedObject = null;
    
                // Provide default position for cursor.
                Position = _gazeOrigin + (_gazeDirection * GazeMaxDistance);
    
                // Provide a default normal.
                Normal = _gazeDirection;
            }
    
            // Lerp the cursor to the given position, which helps to stabilize the gaze.
            Cursor.transform.position = Vector3.Lerp(Cursor.transform.position, Position, 0.6f);
    
            // Check whether the previous focused object is this same. If so, reset the focused object.
            if (FocusedObject != oldFocusedObject)
            {
                ResetFocusedObject();
                if (FocusedObject != null)
                {
                    if (FocusedObject.CompareTag(InteractibleTag))
                    {
                        // Provide the 'Gaze Entered' event.
                        FocusedObject.SendMessage("OnGazeEntered", 
                            SendMessageOptions.DontRequireReceiver);
                    }
                }
            }
        }
    
  8. Enregistrez vos modifications dans Visual Studio avant de revenir à Unity.Save your changes in Visual Studio before returning to Unity.

Chapitre 8-créer la classe interactionsChapter 8 - Create the Interactions class

Vous devez maintenant créer le script interactions , qui est chargé des opérations suivantes :You will now need to create the Interactions script, which is responsible for:

  • Gestion de l’interaction du robinet et du point d’interconnexion de l' appareil photo, qui permet à l’utilisateur d’interagir avec le « bouton » du journal dans la scène.Handling the Tap interaction and the Camera Gaze, which enables the user to interact with the log in "button" in the scene.

  • Création de l’objet de connexion « Button » dans la scène pour l’utilisateur avec lequel interagir.Creating the log in "button" object in the scene for the user to interact with.

Pour créer le script :To create the script:

  1. Double-cliquez sur le dossier scripts pour l’ouvrir.Double-click on the Scripts folder, to open it.

  2. Cliquez avec le bouton droit dans le dossier scripts , puis cliquez sur créer un > script C#.Right-click inside the Scripts folder, click Create > C# Script. Nommez les interactions de script.Name the script Interactions.

  3. Double-cliquez sur le script pour l’ouvrir avec Visual Studio.Double-click on the script to open it with Visual Studio.

  4. Insérez les espaces de noms suivants :Insert the following namespaces:

    using UnityEngine;
    using UnityEngine.XR.WSA.Input;
    
  5. Remplacez l’héritage de la classe interaction par monocomportement par GazeInput.Change the inheritance of the Interaction class from MonoBehaviour to GazeInput.

    Interactions de classes publiques : monocomportementpublic class Interactions : MonoBehaviour

    public class Interactions : GazeInput
    
  6. À l’intérieur de la classe d' interaction , insérez la variable suivante :Inside the Interaction class insert the following variable:

        /// <summary>
        /// Allows input recognition with the HoloLens
        /// </summary>
        private GestureRecognizer _gestureRecognizer;
    
  7. Remplacez la méthode Start . Notez qu’il s’agit d’une méthode override, qui appelle la méthode de la classe de pointage « base ».Replace the Start method; notice it is an override method, which calls the 'base' Gaze class method. Start () est appelé lors de l’initialisation de la classe, de l’inscription à la reconnaissance d’entrée et de la création du bouton de connexion dans la scène :Start() will be called when the class initializes, registering for input recognition and creating the sign in button in the scene:

        /// <summary>
        /// Called on initialization, after Awake
        /// </summary>
        internal override void Start()
        {
            base.Start();
    
            // Register the application to recognize HoloLens user inputs
            _gestureRecognizer = new GestureRecognizer();
            _gestureRecognizer.SetRecognizableGestures(GestureSettings.Tap);
            _gestureRecognizer.Tapped += GestureRecognizer_Tapped;
            _gestureRecognizer.StartCapturingGestures();
    
            // Add the Graph script to this object
            gameObject.AddComponent<MeetingsUI>();
            CreateSignInButton();
        }
    
  8. Ajoutez la méthode CreateSignInButton () , qui instancie le bouton de connexion dans la scène et définit ses propriétés :Add the CreateSignInButton() method, which will instantiate the sign in button in the scene and set its properties:

        /// <summary>
        /// Create the sign in button object in the scene
        /// and sets its properties
        /// </summary>
        void CreateSignInButton()
        {
            GameObject signInButton = GameObject.CreatePrimitive(PrimitiveType.Sphere);
    
            Material mat = new Material(Shader.Find("Diffuse"));
            signInButton.GetComponent<Renderer>().material = mat;
            mat.color = Color.blue;
    
            signInButton.transform.position = new Vector3(3.5f, 2f, 9f);
            signInButton.tag = "SignInButton";
            signInButton.AddComponent<Graph>();
        }
    
  9. Ajoutez la méthode GestureRecognizer_Tapped () , qui répond à l’événement Tap User.Add the GestureRecognizer_Tapped() method, which be respond for the Tap user event.

        /// <summary>
        /// Detects the User Tap Input
        /// </summary>
        private void GestureRecognizer_Tapped(TappedEventArgs obj)
        {
            if(base.FocusedObject != null)
            {
                Debug.Log($"TAP on {base.FocusedObject.name}");
                base.FocusedObject.SendMessage("SignInAsync", SendMessageOptions.RequireReceiver);
            }
        }
    
  10. Supprimez la méthode Update () , puis Enregistrez vos modifications dans Visual Studio avant de revenir à Unity.Delete the Update() method, and then save your changes in Visual Studio before returning to Unity.

Chapitre 9-configurer les références de scriptChapter 9 - Set up the script references

Dans ce chapitre, vous devez placer le script interactions sur l' appareil photo principal.In this Chapter you need to place the Interactions script onto the Main Camera. Ce script gère alors le placement des autres scripts là où ils doivent être.That script will then handle placing the other scripts where they need to be.

  • Dans le dossier scripts du panneau Projet, faites glisser les interactions de script vers l’objet caméra principale , comme illustré ci-dessous.From the Scripts folder in the Project Panel, drag the script Interactions to the Main Camera object, as pictured below.

Chapitre 10-configuration de la baliseChapter 10 - Setting up the Tag

Le code qui gère le point de regard utilise la balise SignInButton pour identifier l’objet avec lequel l’utilisateur interagit pour se connecter à Microsoft Graph.The code handling the gaze will make use of the Tag SignInButton to identify which object the user will interact with to sign-in to Microsoft Graph.

Pour créer la balise :To create the Tag:

  1. Dans l’éditeur Unity, cliquez sur la caméra principale dans le panneau hiérarchie.In the Unity Editor click on the Main Camera in the Hierarchy Panel.

  2. Dans le volet de l’inspecteur, cliquez sur la balise MainCamera pour ouvrir une liste déroulante.In the Inspector Panel click on the MainCamera Tag to open a drop-down list. Cliquez sur Ajouter une étiquette...Click on Add Tag...

  3. Cliquez sur le + bouton.Click on the + button.

  4. Écrivez le nom de la balise en tant que SignInButton , puis cliquez sur Enregistrer.Write the Tag name as SignInButton and click Save.

Chapitre 11-créer le projet Unity dans UWPChapter 11 - Build the Unity project to UWP

Tout ce qui est nécessaire pour la section Unity de ce projet est maintenant terminé. il est donc temps de la générer à partir d’Unity.Everything needed for the Unity section of this project has now been completed, so it is time to build it from Unity.

  1. Accédez à paramètres de build (*fichier > * paramètres de Build * *).Navigate to Build Settings (*File > *Build Settings**).

  2. Si ce n’est pas déjà fait, cochez les # projets Unity C.If not already, tick Unity C# Projects.

  3. Cliquez sur Générer.Click Build. Unity lance une fenêtre de l' Explorateur de fichiers , dans laquelle vous devez créer, puis sélectionner un dossier dans lequel générer l’application.Unity will launch a File Explorer window, where you need to create and then select a folder to build the app into. Créez ce dossier maintenant, puis nommez-le application.Create that folder now, and name it App. Ensuite, avec le dossier d' application sélectionné, cliquez sur Sélectionner un dossier.Then with the App folder selected, click Select Folder.

  4. Unity commence à générer votre projet dans le dossier de l' application .Unity will begin building your project to the App folder.

  5. Une fois la génération de Unity terminée (cela peut prendre un certain temps), une fenêtre de l' Explorateur de fichiers s’ouvre à l’emplacement de votre Build (Vérifiez la barre des tâches, car elle ne s’affiche pas toujours au-dessus de votre Windows, mais vous informera de l’ajout d’une nouvelle fenêtre).Once Unity has finished building (it might take some time), it will open a File Explorer window at the location of your build (check your task bar, as it may not always appear above your windows, but will notify you of the addition of a new window).

Chapitre 12-déployer dans HoloLensChapter 12 - Deploy to HoloLens

Pour effectuer un déploiement sur HoloLens :To deploy on HoloLens:

  1. Vous aurez besoin de l’adresse IP de votre HoloLens (pour le déploiement à distance) et vérifiez que votre HoloLens est en mode développeur.You will need the IP Address of your HoloLens (for Remote Deploy), and to ensure your HoloLens is in Developer Mode. Pour ce faire :To do this:

    1. Tout en portant votre HoloLens, ouvrez les paramètres.Whilst wearing your HoloLens, open the Settings.

    2. Accéder au réseau & > Options avancées de Wi-Fi > Advanced Options InternetGo to Network & Internet > Wi-Fi > Advanced Options

    3. Notez l’adresse IPv4 .Note the IPv4 address.

    4. Ensuite, revenez aux paramètres, puis pour mettre à jour & sécurité > pour les développeursNext, navigate back to Settings, and then to Update & Security > For Developers

    5. Définissez le mode développeur sur.Set Developer Mode On.

  2. Accédez à votre nouvelle build Unity (le dossier de l' application ) et ouvrez le fichier solution avec Visual Studio.Navigate to your new Unity build (the App folder) and open the solution file with Visual Studio.

  3. Dans la configuration de la solution, sélectionnez Déboguer.In the Solution Configuration select Debug.

  4. Dans la plateforme de la solution, sélectionnez x86, ordinateur distant.In the Solution Platform, select x86, Remote Machine. Vous serez invité à insérer l' adresse IP d’un périphérique distant (le HoloLens, dans ce cas, que vous avez noté).You will be prompted to insert the IP address of a remote device (the HoloLens, in this case, which you noted).

  5. Accédez au menu générer , puis cliquez sur déployer la solution pour chargement l’application à votre HoloLens.Go to Build menu and click on Deploy Solution to sideload the application to your HoloLens.

  6. Votre application doit maintenant apparaître dans la liste des applications installées sur votre HoloLens, prête à être lancée.Your app should now appear in the list of installed apps on your HoloLens, ready to be launched!

Votre application Microsoft Graph HoloLensYour Microsoft Graph HoloLens application

Félicitations, vous avez créé une application de réalité mixte qui tire parti de la Microsoft Graph pour lire et afficher les données de calendrier utilisateur.Congratulations, you built a mixed reality app that leverages the Microsoft Graph, to read and display user Calendar data.

Exercices bonusBonus exercises

Exercice 1Exercise 1

Utiliser Microsoft Graph pour afficher d’autres informations sur l’utilisateurUse Microsoft Graph to display other information about the user

  • Adresse de messagerie/numéro de téléphone/de profil utilisateurUser email / phone number / profile picture

Exercice 1Exercise 1

Implémentez le contrôle vocal pour naviguer dans l’interface utilisateur Microsoft Graph.Implement voice control to navigate the Microsoft Graph UI.