HoloLens (1. generációs) és az Azure 309: Application Insights


Megjegyzés

A Mixed Reality Academy oktatóanyagai HoloLens (1. generációs) és Mixed Reality Modern headsetekkel készültek. Ezért fontos, hogy ezeket az oktatóanyagokat a helyére helyezzük azoknak a fejlesztőknek, akik továbbra is útmutatást keresnek az eszközök fejlesztéséhez. Ezek az oktatóanyagok nem frissülnek a 2. HoloLens eszközökkel. A rendszer fenntartja őket, hogy továbbra is a támogatott eszközökön dolgoznak. A jövőben egy új oktatóanyag-sorozat lesz közzétéve, amely bemutatja, hogyan fejleszthet a 2. HoloLens való fejlesztéshez. Ez az értesítés frissülni fog az oktatóanyagokra mutató hivatkozással, amikor közzé lesznek téve.


final product -start

Ebben a kurzusban megtudhatja, hogyan adhat Application Elemzések-képességeket egy vegyes valóságú alkalmazáshoz az Azure Application Elemzések API használatával a felhasználói viselkedéssel kapcsolatos elemzések gyűjtéséhez.

Az Elemzések a Microsoft egyik szolgáltatása, amely lehetővé teszi a fejlesztők számára, hogy elemzéseket gyűjtsenek az alkalmazásaikból, és egy könnyen használható portálról kezelve azt. Az elemzés bármi lehet, a teljesítménytől az egyéni információkon át a begyűjtött adatokon át. További információért látogasson el az Application Elemzések oldalra.

A kurzus befejezése után egy modern, vegyes valóságú headset-alkalmazással fog fog tudni tenni a következőket:

  1. Lehetővé teszi, hogy a felhasználó egy jelenetben tekintett és mozogjon.
  2. Aktiválja az elemzés küldését az Application Elemzések Service-nek a tekintet és a jeleneten lévő objektumokhoz való közelség használatával.
  3. Az alkalmazás a Szolgáltatást is hívja, és az elmúlt 24 órában lekéri a felhasználó által a leggyakrabban megközelített objektum adatait. Ez az objektum zöldre módosítja a színét.

Ez a kurzus bemutatja, hogyan lehet az eredményeket az Application Elemzések Service-ból egy Unity-alapú mintaalkalmazásba behozni. Ezeket a fogalmakat Egy ön által létrehozott egyéni alkalmazásra kell alkalmaznia.

Eszköztámogatás

Tanfolyam HoloLens Modern headsetek
MR és Azure 309: Application Insights ✔️ ✔️

Megjegyzés

Bár ez a kurzus elsősorban a Windows Mixed Reality (VR-) headsetekkel foglalkozik, a kurzusban tanultak használhatja a Microsoft HoloLens. Ahogy követi a kurzust, jegyzeteket fog látni az esetleges változásokról, amelyekre szükség lehet a HoloLens. A HoloLens előfordulhat, hogy a hangrögzítés során valamilyen echo-t fog kapni.

Előfeltételek

Megjegyzés

Ez az oktatóanyag olyan fejlesztők számára készült, akik alapszintű tapasztalattal rendelkeznek a Unity és a C# használatában. Vegye figyelembe azt is, hogy a dokumentum előfeltételei és írásos utasításai a cikk írásakor (2018. július) tesztelt és ellenőrzött adatokat jelölik. Használhatja a legújabb szoftvereket az eszközök telepítésével kapcsolatos cikkben felsoroltak szerint, de nem szabad feltételezni, hogy a kurzusban szereplő információk tökéletesen megegyeznek az újabb szoftverekben található információkkal, mint az alább felsoroltak.

Ehhez a kurzushoz a következő hardvereket és szoftvereket javasoljuk:

Előkészületek

A projekt létrehozásakor felmerülő problémák elkerülése érdekében határozottan javasoljuk, hogy az oktatóanyagban említett projektet egy gyökér- vagy gyökérmappában hozza létre (a hosszú mappák elérési útjai problémákat okozhatnak a létrehozáskor).

Figyelmeztetés

Vegye figyelembe, hogy az Application Elemzések adatok sok időt vesz igénybe, ezért legyen beteg. Ha ellenőrizni szeretné, hogy a szolgáltatás megkapta-e az adatokat, tekintse meg a 14.fejezetet, amely bemutatja, hogyan navigálhat a portálon.

1. fejezet – Az Azure Portal

Az Application Elemzések a alkalmazásban létre kell hoznia és konfigurálnia kell egy Application Elemzések Service-t a Azure Portal.

  1. Jelentkezzen be az Azure Portalra.

    Megjegyzés

    Ha még nem rendelkezik Azure-fiókkal, létre kell hoznia egyet. Ha osztályterem- vagy laborhelyzetben követi ezt az oktatóanyagot, kérjen segítséget az oktatótól vagy az egyik vezetőtől az új fiók beállításában.

  2. Miután bejelentkezett, kattintson a bal felső sarokban található Új elemre, keresse meg az Application Elemzések, majd kattintson az Enter gombra.

    Megjegyzés

    Előfordulhat, hogy az Új szó helyett a Create a resource(Erőforrás létrehozása) szó lett az újabb portálon.

    Azure Portal

  3. A jobb oldalon található új oldal az Azure Application Elemzések Service leírását tartalmazza. A lap bal alsó részén válassza a Létrehozás gombot a szolgáltatáshoz való társítás létrehozásához.

    Azure Portal

  4. Miután rákattintott a Létrehozás gombra:

    1. Szúrja be a kívánt nevet a szolgáltatáspéldányhoz.

    2. Alkalmazástípusként válassza az Általános lehetőséget.

    3. Válassza ki a megfelelő előfizetést.

    4. Válasszon ki egy erőforráscsoportot, vagy hozzon létre egy újat. Az erőforráscsoportokkal monitorzhatja, szabályozhatja a hozzáférést, kiépítheti és kezelheti az Azure-beli eszközök gyűjteményének számlázását. Javasoljuk, hogy az összes Azure-szolgáltatást egyetlen projekthez (például ezekhez a tanfolyamokhoz) egy közös erőforráscsoportban tartsa.

      Ha többet szeretne tudni az Azure-erőforráscsoportokról, tekintse meg az erőforráscsoporttal kapcsolatos cikket.

    5. Válasszon egy helyet.

    6. Azt is meg kell erősítenie, hogy megértette a szolgáltatásra alkalmazott használati feltételeket.

    7. Válassza a Létrehozás lehetőséget.

      Azure Portal

  5. Miután a Létrehozás gombra kattintott, meg kell várnia a szolgáltatás létrejöttét, ez egy percet is igénybe vehet.

  6. A szolgáltatáspéldány létrehozása után egy értesítés jelenik meg a portálon.

    Azure Portal

  7. Kattintson az értesítésekre az új szolgáltatáspéldány felfedezéséhez.

    Azure Portal

  8. Az értesítésben kattintson az Erőforrás ugrás gombra az új szolgáltatáspéldány felfedezéséhez. Meg fog lennie az új Application Elemzések Service-példányban.

    Azure Portal

    Megjegyzés

    Tartsa nyitva a weblapot, és könnyen elérhető legyen. Gyakran visszatér ide, hogy lássa a gyűjtött adatokat.

    Fontos

    Az Application Elemzések implementálásához három (3) specifikus értéket kell használnia: eszközkulcsot, alkalmazásazonosítót és API-kulcsot. Az alábbiakban láthatja, hogyan lehet lekérni ezeket az értékeket a szolgáltatásból. Ezeket az értékeket jegyezze fel egy üres Jegyzettömb oldalon, mert hamarosan használni fogja őket a kódban.

  9. A eszközkulcs megkeresése érdekében görgessen le a szolgáltatásfunkciók listájában, és kattintson a Tulajdonságok elemre. A megjelenő lapon megjelenik a szolgáltatáskulcs.

    Azure Portal

  10. A Tulajdonságok alatt megtalálja az API-hozzáférés et, amelyre kattintanunk kell. A jobb oldalon található panel az alkalmazás alkalmazásazonosítóját adja meg.

    Azure Portal

  11. Ha az Alkalmazásazonosító panel továbbra is meg van nyitva, kattintson a Create API Key (API-kulcs létrehozása) elemre, amely megnyitja az API-kulcs létrehozása panelt.

    Azure Portal

  12. A most már megnyitott API-kulcs létrehozása panelen adjon meg egy leírást, és jelölje be a három jelölőnégyzetet.

  13. Kattintson a Generate Key (Kulcs létrehozása) elemre. Az API-kulcs létrejön és megjelenik.

    Azure Portal

    Figyelmeztetés

    Ez az egyetlen alkalom, amikor a szolgáltatáskulcs megjelenik, ezért most készítse el annak másolatát.

2. fejezet – A Unity-projekt beállítása

Az alábbiakban egy tipikus, vegyes valóságban való fejlesztésre vonatkozó beállítás van beállítva, és így jó sablon más projektekhez.

  1. Nyissa meg a Unityt, és kattintson a New (Új) elemre.

    A Unity-Project

  2. Most meg kell adnia egy Unity-Project, és be kell szúrja az MR _ Azure Application _ _ Elemzések. Győződjön meg arról, hogy a Sablon beállítása 3D. A Hely beállításnál adja meg az Önnek megfelelő helyet (ne feledje, hogy a gyökérkönyvtárakhoz közelebb van a jobb). Ezután kattintson a Projekt létrehozása elemre.

    A Unity-Project

  3. Ha a Unity nyitva van, érdemes ellenőrizni, hogy az alapértelmezett Script Editor értéke Visual Studio. Lépjen a Beállítások > szerkesztése lapra, majd az új ablakban lépjen a Külső eszközök elemre. Módosítsa a Külső szkriptszerkesztőt a Visual Studio 2017-re. Zárja be a Beállítások ablakot.

    A Unity-Project

  4. Ezután a Fájl build > Gépház a platformot a Universal Windows Platform (Platformváltás) gombra kattintva váltsa át a Universal Windows Platform(Platformváltás) elemre.

    A Unity-Project

  5. A Fájl > buildelőre Gépház, és győződjön meg a következőről:

    1. A Céleszköz beállítása Bármely eszköz

      A céleszköz Microsoft HoloLens állítsa a Céleszközt a következőre: HoloLens.

    2. A Build Type (Build típusa) beállítása D3D

    3. Az SDK a Legújabb telepítve beállításra van állítva

    4. A Build and Run (Összeállítás és futtatás) beállítása Local Machine (Helyi gép)

    5. Mentse a jelenet, és adja hozzá a buildhez.

      1. Ehhez válassza az Add Open Scenes (Nyitott jelenetek hozzáadása) gombra. Megjelenik egy Mentés ablak.

        A Unity-Project

      2. Hozzon létre egy új mappát ehhez és bármely jövőbeli jelenethez, majd kattintson a New folder (Új mappa) gombra egy új mappa létrehozásához, és nevezze el Scenes (Jelenetek) néven.

        A Unity-Project

      3. Nyissa meg az újonnan létrehozott Scenes mappát, majd a Fájlnév: szövegmezőbe írja be az ApplicationInsightsScene nevet, majd kattintson a Mentés gombra.

        A Unity-Project

  6. A build Gépház beállításokat az alapértelmezett értéken kell hagynunk.

  7. A Build Gépház ablakban kattintson a Player Gépház gombra, ezzel megnyitja a kapcsolódó panelt abban a térben, ahol az Inspector található.

    A Unity-Project

  8. Ezen a panelen ellenőrizni kell néhány beállítást:

    1. Az Egyéb Gépház lapon:

      1. A parancsprogram-futtatás verziójának kísérletinek (.NET 4.6-nak megfelelőnek) kell lennie, ami kiváltja a szerkesztő újraindításának szükségét.

      2. A parancsfájl-háttérrendszernek .NET-nek kell lennie

      3. Az API-kompatibilitási szint legyen .NET 4.6

      A Unity-Project

    2. A Publishing Gépház lapon, a Képességek alatt ellenőrizze a következőt:

      • InternetClient

        A Unity-Project

    3. A panel további, XR Gépház (a Publishing Gépház alatt található) panelen jelölje be a Virtual Reality támogatott jelölőnégyzetét, és győződjön meg arról, hogy az Windows Mixed Reality SDK hozzá van adva.

      A Unity-Project

  9. A Build Gépház visszatérve a Unity C# Projects már nem szürkül ki; jelölje be a mellette jelölőnégyzetet.

  10. Zárja be a Build Gépház ablakot.

  11. Mentse a jelenetét, és Project (FILE > SAVE SCENE / FILE SAVE > PROJECT).

3. fejezet – A Unity-csomag importálása

Fontos

Ha ki szeretné hagyni a kurzus Unity-összetevőinek beállítását, és közvetlenül a kódba szeretne ugrani, nyugodtan töltse le ezt az Azure-MR-309.unitypackagecsomagot, importálja a projektbe Custom Package-csomagként. Ez a következő fejezetből származó DLL-eket is tartalmazza. Importálás után folytassa a 6. fejezettel.

Fontos

Ahhoz, hogy az Application Elemzések a Unityben, importálni kell hozzá a DLL-t a Newtonsoft DLL-sel együtt. Jelenleg van egy ismert probléma a Unityben, amely miatt a beépülő modulokat újra kell konfigurálni az importálás után. A hiba megoldása után ezekre a lépésekre (ebben a szakaszban 4–7) már nincs szükség.

Az Application Elemzések a saját projektjére való importálásához győződjön meg arról, hogy letöltötte a beépülő modulokat tartalmazó ".unitypackage" fájlt. Ezután tegye a következőket:

  1. Adja hozzá a .unitypackage-et a Unityhez az Assets > Import Package Custom > Package menüelem használatával.

  2. A felugró Import Unity Package (Import Unity-csomag) mezőben győződjön meg arról, hogy minden elem ki van jelölve a beépülő modulok alatt (és beleértve a beépülő modulokat is).

    A Unity-csomag importálása

  3. Kattintson az Importálás gombra az elemek projekthez való hozzáadásához.

  4. A beépülő modulok Elemzések a Project mappában válassza ki a következő beépülő modulokat:

    • Microsoft.ApplicationInsights

    A Unity-csomag importálása

  5. A beépülő modul kiválasztása után győződjön meg arról, hogy a Bármely platform jelölőnégyzet nincs bejelölve, majd győződjön meg arról, hogy a WSAPlayer is be van jelölve, majd kattintson az Apply (Alkalmaz) gombra. Ez csupán annak megerősítésére van állítva, hogy a fájlok megfelelően vannak konfigurálva.

    A Unity-csomag importálása

    Megjegyzés

    A beépülő modulok ilyen megjelölése esetén úgy konfigurálja őket, hogy csak a Unity-szerkesztőben használják őket. A WSA-mappában különböző DLL-ek találhatók, amelyeket a rendszer a projekt Unityből való exportálása után fog használni.

  6. Ezután meg kell nyitnia a WSA mappát a Elemzések mappában. Láthatja ugyanannak a fájlnak a másolatát, amely az előbb konfigurált. Jelölje ki ezt a fájlt, majd a vizsgálóban győződjön meg arról, hogy a Bármely platform jelölőnégyzet nincs bejelölve, majd győződjön meg arról, hogy csak a WSAPlayer jelölőnégyzet van bejelölve. Kattintson az Alkalmaz gombra.

    A Unity-csomag importálása

  7. Most a 4–6. lépést kell követnie, de ehelyett a Newtonsoft beépülő modulokat kell használnia. Az alábbi képernyőképen láthatja, hogyan kell kinéznie az eredménynek.

    A Unity-csomag importálása

4. fejezet – A kamera és a felhasználói vezérlők beállítása

Ebben a fejezetben úgy fogja beállítani a kamerát és a vezérlőket, hogy a felhasználó láthatja és mozoghat a jelenetben.

  1. Kattintson a jobb gombbal egy üres területre a Hierarchia panelen, majd kattintson az Üres létrehozása > elemre.

    A kamera és a Felhasználó vezérlők beállítása

  2. Nevezze át az új üres GameObjectet a Camera Parent névre.

    A kamera és a Felhasználó vezérlők beállítása

  3. Kattintson a jobb gombbal egy üres területre a Hierarchia panelen, majd a 3D-objektumon, majd a Sphere-ben.

  4. Nevezze át a Sphere-t a jobb kézzel névre.

  5. Állítsa a jobb kéz Transform Scale (Átformált skálája) beállítását a következőre: 0,1, 0,1, 0.1

    A kamera és a Felhasználó vezérlők beállítása

  6. Távolítsa el a Sphere-összeütköztető összetevőt a jobb oldaliról. Kattintson a Fogaskerék gombra a Sphere-ütköztető összetevőben, majd válassza az Összetevő eltávolítása gombra.

    A kamera és a Felhasználó vezérlők beállítása

  7. A Hierarchia panelen húzza a Main Camera (Fő kamera) és a Right Hand (Jobb kéz) objektumokat a Camera Parent (Kamera szülőobjektuma) objektumra.

    A kamera és a Felhasználó vezérlők beállítása

  8. Állítsa a Fő kamera és a Jobb oldali objektum Transform Position (Átalakítás) pozícióját is 0, 0, 0 ( 0) állásra.

    A kamera és a Felhasználó vezérlők beállítása

    A kamera és a Felhasználó vezérlők beállítása

5. fejezet – Objektumok beállítása a Unity-jelenetben

Most létre fog hozni néhány alapszintű alakzatot a jelenethez, amellyel a felhasználó interakcióba léphet.

  1. Kattintson a jobb gombbal egy üres területre a Hierarchia panelen, majd a 3D Objektum területen válassza a Sík lehetőséget.

  2. Állítsa a Sík átalakítása pozíciót 0, -1, 0 állásra.

  3. Állítsa a Sík átalakítása skálát 5, 1, 5 beállításra.

    Objektumok beállítása a Unity-jelenetben

  4. Hozzon létre egy alapszintű anyagot a Plane objektumhoz, hogy a többi alakzat könnyebben látható legyen. Lépjen a Project paneljére, kattintson a jobb gombbal, majd kattintson a Létrehozás, végül a Mappa elemre egy új mappa létrehozásához. Nevezze el Materials (Anyagok) néven.

    Objektumok beállítása a Unity-jelenetben Objektumok beállítása a Unity-jelenetben

  5. Új anyag létrehozásához nyissa meg az Anyagok mappát, majd kattintson a jobb gombbal a Létrehozás, majd a Material elemre. Nevezze el Kékre.

    Objektumok beállítása a Unity-jelenetben Objektumok beállítása a Unity-jelenetben

  6. Az új Kék anyag kiválasztása után nézze meg az Inspectort, és kattintson a téglalap alakú ablakra az Albedo mellett. Válasszon egy kék színt (az alábbi képen Hexxszín: # 3592FFFF ). Ha kiválasztotta, kattintson a Bezárás gombra.

    Objektumok beállítása a Unity-jelenetben

  7. Húzza az új anyagot az Materials (Anyagok) mappából az újonnan létrehozott Plane(Sík) mappába a jeleneten belül (vagy a Plane (Sík) objektumra a Hierarchy (Hierarchia) hierarchián belül).

    Objektumok beállítása a Unity-jelenetben

  8. Kattintson a jobb gombbal egy üres területre a Hierarchia panelen, majd a 3D Object, Capsule területen.

    • A Capsule kiválasztása után módosítsa a Transform Position (Átalakítás pozíciója) beállítást a következőre: -10, 1, 0.
  9. Kattintson a jobb gombbal egy üres területre a Hierarchia panelen, majd a 3D Object, Cube (3D objektum) területen.

    • A Kocka kiválasztása után módosítsa a Transform Position (Átalakítás pozíciója) beállítást a következőre: 0, 0, 10.
  10. Kattintson a jobb gombbal egy üres területre a Hierarchia panelen, majd a 3D Object( 3D Object, Sphere) területen.

    • A Sphere kiválasztása után módosítsa a Transform Position (Átalakítás pozíciója) beállítást a következőre: 10, 0, 0.

    Objektumok beállítása a Unity-jelenetben

    Megjegyzés

    Ezek a Pozíció értékek javaslatok. Az objektumok pozícióit szabadon beállíthatja bármilyen módon, bár az alkalmazás felhasználója egyszerűbb, ha az objektumok távolságai nem túl távol vannak a kamerától.

  11. Ha az alkalmazás fut, képesnek kell lennie azonosítani a jelenetben lévő objektumokat, hogy ezt el tudja érni, címkével kell ellátni őket. Válassza ki az egyik objektumot, majd az Inspector panelen kattintson a Címke hozzáadása... elemre, amely felcseréli az Inspectort a Címkék & rétegek panellel.

    Objektumok beállítása a Unity-jelenetben

  12. Kattintson a + (plusz) szimbólumra, majd írja be a címke nevét ObjectInScene néven.

    Objektumok beállítása a Unity-jelenetben

    Figyelmeztetés

    Ha más nevet használ a címkéhez, győződjön meg arról, hogy a módosítás a DataFromAnalytics, az ObjectTrigger és a Gaze szkripteket is későbbre váltja, hogy az objektumok megtalálása és észlelése a jelenetben is meglegyen.

  13. A létrehozott címkét most mindhárom objektumra alkalmaznia kell. A hierarchiában tartsa lenyomva a Shift billentyűt, majd kattintson a Capsule, Cube, és Sphere objektumokra, majd az Inspectorban kattintson a címke melletti legördülő menüre, majd a létrehozott ObjectInScene címkére.

    Objektumok beállítása a Unity-jelenetben

6. fejezet – Az ApplicationInsightsTracker osztály létrehozása

Az első szkript, amelyet létre kell hoznia, az ApplicationInsightsTracker, amely a következőért felelős:

  1. Események létrehozása felhasználói interakciók alapján az Azure Application Elemzések.

  2. A megfelelő eseménynevek létrehozása a felhasználói beavatkozástól függően.

  3. Események elküldése az Application Elemzések Service-példánynak.

Az osztály létrehozása:

  1. Kattintson a jobb gombbal a Project panelen, majd a Mappa > létrehozása elemre. A mappának a Scripts nevet kell írnia.

    Az ApplicationInsightsTracker osztály létrehozása Az ApplicationInsightsTracker osztály létrehozása

  2. A Szkriptek mappa létrehozása után kattintson rá duplán a megnyitásához. Ezután a mappában kattintson a jobb gombbal a > Create C# Script (C#-szkript létrehozása) parancsra. A szkriptnek nevezze el az ApplicationInsightsTracker nevet.

  3. Kattintson duplán az új ApplicationInsightsTracker szkriptre, és nyissa meg az Visual Studio.

  4. Frissítse a szkript tetején található névtereket az alábbi módon:

        using Microsoft.ApplicationInsights;
        using Microsoft.ApplicationInsights.DataContracts;
        using Microsoft.ApplicationInsights.Extensibility;
        using UnityEngine;
    
  5. A osztályon belül szúrja be a következő változókat:

        /// <summary>
        /// Allows this class to behavior like a singleton
        /// </summary>
        public static ApplicationInsightsTracker Instance;
    
        /// <summary>
        /// Insert your Instrumentation Key here
        /// </summary>
        internal string instrumentationKey = "Insert Instrumentation Key here";
    
        /// <summary>
        /// Insert your Application Id here
        /// </summary>
        internal string applicationId = "Insert Application Id here";
    
        /// <summary>
        /// Insert your API Key here
        /// </summary>
        internal string API_Key = "Insert API Key here";
    
        /// <summary>
        /// Represent the Analytic Custom Event object
        /// </summary>
        private TelemetryClient telemetryClient;
    
        /// <summary>
        /// Represent the Analytic object able to host gaze duration
        /// </summary>
        private MetricTelemetry metric;
    

    Megjegyzés

    Állítsa be megfelelően a instrumentationKey, applicationId és API_Key értékeket az Azure Portal szolgáltatáskulcsai segítségével, az 1.fejezet 9. lépése és újabb fejezetben említettek szerint.

  6. Ezután adja hozzá a Start() és az Egyed() metódusokat, amelyeket a rendszer az osztály inicializáláskor hív meg:

        /// <summary>
        /// Sets this class instance as a singleton
        /// </summary>
        void Awake()
        {
            Instance = this;
        }
    
        /// <summary>
        /// Use this for initialization
        /// </summary>
        void Start()
        {
            // Instantiate telemetry and metric
            telemetryClient = new TelemetryClient();
    
            metric = new MetricTelemetry();
    
            // Assign the Instrumentation Key to the Event and Metric objects
            TelemetryConfiguration.Active.InstrumentationKey = instrumentationKey;
    
            telemetryClient.InstrumentationKey = instrumentationKey;
        }
    
  7. Adja hozzá az alkalmazás által regisztrált események és metrikák küldéséért felelős metódusokat:

        /// <summary>
        /// Submit the Event to Azure Analytics using the event trigger object
        /// </summary>
        public void RecordProximityEvent(string objectName)
        {
            telemetryClient.TrackEvent(CreateEventName(objectName));
        }
    
        /// <summary>
        /// Uses the name of the object involved in the event to create 
        /// and return an Event Name convention
        /// </summary>
        public string CreateEventName(string name)
        {
            string eventName = $"User near {name}";
            return eventName;
        }
    
        /// <summary>
        /// Submit a Metric to Azure Analytics using the metric gazed object
        /// and the time count of the gaze
        /// </summary>
        public void RecordGazeMetrics(string objectName, int time)
        {
            // Output Console information about gaze.
            Debug.Log($"Finished gazing at {objectName}, which went for <b>{time}</b> second{(time != 1 ? "s" : "")}");
    
            metric.Name = $"Gazed {objectName}";
    
            metric.Value = time;
    
            telemetryClient.TrackMetric(metric);
        }
    
  8. A Unitybe való visszatérés előtt mindenképpen mentse a módosításokat a Visual Studio.

7. fejezet – A Tekintet parancsfájl létrehozása

A következő létrehozni szükséges szkript a Gaze szkript. Ez a szkript felelős egy Olyan Raycast létrehozásáért, amely a Main Camera-től továbbítva észleli, hogy a felhasználó melyik objektumot nézi. Ebben az esetben a Raycastnak azonosítania kell, hogy a felhasználó objektumra tekint-e az ObjectInScene címkével, majd meg kell számolnia, hogy a felhasználó mennyi ideig tekint erre az objektumra.

  1. Kattintson duplán a Scripts mappára a megnyitásához.

  2. Kattintson a jobb gombbal a Scripts (Szkriptek) mappára, majd kattintson a Create > C# Script (C#-szkript létrehozása) parancsra. A szkriptnek a Következő nevet kell írnia:.

  3. Kattintson duplán a szkriptre, és nyissa meg a Visual Studio.

  4. Cserélje le a meglévő kódot a következőre:

        using UnityEngine;
    
        public class Gaze : MonoBehaviour
        {
            /// <summary>
            /// Provides Singleton-like behavior to this class.
            /// </summary>
            public static Gaze Instance;
    
            /// <summary>
            /// Provides a reference to the object the user is currently looking at.
            /// </summary>
            public GameObject FocusedGameObject { get; private set; }
    
            /// <summary>
            /// Provides whether an object has been successfully hit by the raycast.
            /// </summary>
            public bool Hit { get; private set; }
    
            /// <summary>
            /// Provides a reference to compare whether the user is still looking at 
            /// the same object (and has not looked away).
            /// </summary>
            private GameObject _oldFocusedObject = null;
    
            /// <summary>
            /// Max Ray Distance
            /// </summary>
            private float _gazeMaxDistance = 300;
    
            /// <summary>
            /// Max Ray Distance
            /// </summary>
            private float _gazeTimeCounter = 0;
    
            /// <summary>
            /// The cursor object will be created when the app is running,
            /// this will store its values. 
            /// </summary>
            private GameObject _cursor;
        }
    
  5. Most hozzá kell adni a kódot az Új() és Start() metódushoz.

        private void Awake()
        {
            // Set this class to behave similar to singleton
            Instance = this;
            _cursor = CreateCursor();
        }
    
        void Start()
        {
            FocusedGameObject = null;
        }
    
        /// <summary>
        /// Create a cursor object, to provide what the user
        /// is looking at.
        /// </summary>
        /// <returns></returns>
        private GameObject CreateCursor()    
        {
            GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
    
            // Remove the collider, so it does not block raycast.
            Destroy(newCursor.GetComponent<SphereCollider>());
    
            newCursor.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
    
            newCursor.GetComponent<MeshRenderer>().material.color = 
            Color.HSVToRGB(0.0223f, 0.7922f, 1.000f);
    
            newCursor.SetActive(false);
            return newCursor;
        }
    
  6. A Gaze osztályban adja hozzá a következő kódot az Update() metódushoz egy Raycast kivetítéséhez és a célként találat észleléséhez:

        /// <summary>
        /// Called every frame
        /// </summary>
        void Update()
        {
            // Set the old focused gameobject.
            _oldFocusedObject = FocusedGameObject;
    
            RaycastHit hitInfo;
    
            // Initialize Raycasting.
            Hit = Physics.Raycast(Camera.main.transform.position, Camera.main.transform.forward, out hitInfo, _gazeMaxDistance);
    
            // Check whether raycast has hit.
            if (Hit == true)
            {
                // Check whether the hit has a collider.
                if (hitInfo.collider != null)
                {
                    // Set the focused object with what the user just looked at.
                    FocusedGameObject = hitInfo.collider.gameObject;
    
                    // Lerp the cursor to the hit point, which helps to stabilize the gaze.
                    _cursor.transform.position = Vector3.Lerp(_cursor.transform.position, hitInfo.point, 0.6f);
    
                    _cursor.SetActive(true);
                }
                else
                {
                    // Object looked on is not valid, set focused gameobject to null.
                    FocusedGameObject = null;
    
                    _cursor.SetActive(false);
                }
            }
            else
            {
                // No object looked upon, set focused gameobject to null.
                FocusedGameObject = null;
    
                _cursor.SetActive(false);
            }
    
            // Check whether the previous focused object is this same object. If so, reset the focused object.
            if (FocusedGameObject != _oldFocusedObject)
            {
                ResetFocusedObject();
            }
            // If they are the same, but are null, reset the counter. 
            else if (FocusedGameObject == null && _oldFocusedObject == null)
            {
                _gazeTimeCounter = 0;
            }
            // Count whilst the user continues looking at the same object.
            else
            {
                _gazeTimeCounter += Time.deltaTime;
            }
        }
    
  7. Adja hozzá a ResetFocusedObject() metódust, hogy adatokat küldjön az Application Elemzések, amikor a felhasználó egy objektumot figyelt meg.

        /// <summary>
        /// Reset the old focused object, stop the gaze timer, and send data if it
        /// is greater than one.
        /// </summary>
        public void ResetFocusedObject()
        {
            // Ensure the old focused object is not null.
            if (_oldFocusedObject != null)
            {
                // Only looking for objects with the correct tag.
                if (_oldFocusedObject.CompareTag("ObjectInScene"))
                {
                    // Turn the timer into an int, and ensure that more than zero time has passed.
                    int gazeAsInt = (int)_gazeTimeCounter;
    
                    if (gazeAsInt > 0)
                    {
                        //Record the object gazed and duration of gaze for Analytics
                        ApplicationInsightsTracker.Instance.RecordGazeMetrics(_oldFocusedObject.name, gazeAsInt);
                    }
                    //Reset timer
                    _gazeTimeCounter = 0;
                }
            }
        }
    
  8. Befejezte a Gaze szkriptet. Mentse a módosításokat a Visual Studio, mielőtt visszatér a Unitybe.

8. fejezet – Az ObjectTrigger osztály létrehozása

A következő szkript, amelyet létre kell hoznia, az ObjectTrigger, amely a következőért felelős:

  • A Main Camera-nak való ütközéshez szükséges összetevők hozzáadása.
  • Annak észlelése, hogy a kamera közel van-e egy ObjectInScene címkével ellátott objektumhoz.

A szkript létrehozása:

  1. Kattintson duplán a Scripts mappára a megnyitásához.

  2. Kattintson a jobb gombbal a Scripts (Szkriptek) mappára, majd kattintson a Create > C# Script (C#-szkript létrehozása) parancsra. A szkriptnek nevezze el az ObjectTrigger nevet.

  3. Kattintson duplán a szkriptre, és nyissa meg a Visual Studio. Cserélje le a meglévő kódot a következőre:

        using UnityEngine;
    
        public class ObjectTrigger : MonoBehaviour
        {
            private void Start()
            {
                // Add the Collider and Rigidbody components, 
                // and set their respective settings. This allows for collision.
                gameObject.AddComponent<SphereCollider>().radius = 1.5f;
    
                gameObject.AddComponent<Rigidbody>().useGravity = false;
            }
    
            /// <summary>
            /// Triggered when an object with a collider enters this objects trigger collider.
            /// </summary>
            /// <param name="collision">Collided object</param>
            private void OnCollisionEnter(Collision collision)
            {
                CompareTriggerEvent(collision, true);
            }
    
            /// <summary>
            /// Triggered when an object with a collider exits this objects trigger collider.
            /// </summary>
            /// <param name="collision">Collided object</param>
            private void OnCollisionExit(Collision collision)
            {
                CompareTriggerEvent(collision, false);
            }
    
            /// <summary>
            /// Method for providing debug message, and sending event information to InsightsTracker.
            /// </summary>
            /// <param name="other">Collided object</param>
            /// <param name="enter">Enter = true, Exit = False</param>
            private void CompareTriggerEvent(Collision other, bool enter)
            {
                if (other.collider.CompareTag("ObjectInScene"))
                {
                    string message = $"User is{(enter == true ? " " : " no longer ")}near <b>{other.gameObject.name}</b>";
    
                    if (enter == true)
                    {
                        ApplicationInsightsTracker.Instance.RecordProximityEvent(other.gameObject.name);
                    }
                    Debug.Log(message);
                }
            }
        }
    
  4. A Unitybe való visszatérés előtt mindenképpen mentse a módosításokat a Visual Studio.

9. fejezet – A DataFromAnalytics osztály létrehozása

Most létre kell hoznia a DataFromAnalytics szkriptet, amely a következőért felelős:

  • Elemzési adatok lekérése arról, hogy melyik objektumot közelíti meg a legjobban a kamera.
  • A szolgáltatáskulcsok használatával, amelyek lehetővé teszik a kommunikációt az Azure Application Elemzések Service-példányával.
  • A jelenet objektumai rendezése, amely szerint a legnagyobb az események száma.
  • A leginkább megközelített objektum anyagszínének zöldre módosítása.

A szkript létrehozása:

  1. Kattintson duplán a Scripts mappára a megnyitásához.

  2. Kattintson a jobb gombbal a Scripts (Szkriptek) mappára, majd kattintson a Create > C# Script (C#-szkript létrehozása) parancsra. A szkriptnek nevezze el a DataFromAnalytics nevet.

  3. Kattintson duplán a szkriptre, és nyissa meg a Visual Studio.

  4. Szúrja be a következő névtereket:

        using Newtonsoft.Json;
        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.Linq;
        using UnityEngine;
        using UnityEngine.Networking;
    
  5. A szkriptbe szúrja be a következőt:

        /// <summary>
        /// Number of most recent events to be queried
        /// </summary>
        private int _quantityOfEventsQueried = 10;
    
        /// <summary>
        /// The timespan with which to query. Needs to be in hours.
        /// </summary>
        private int _timepspanAsHours = 24;
    
        /// <summary>
        /// A list of the objects in the scene
        /// </summary>
        private List<GameObject> _listOfGameObjectsInScene;
    
        /// <summary>
        /// Number of queries which have returned, after being sent.
        /// </summary>
        private int _queriesReturned = 0;
    
        /// <summary>
        /// List of GameObjects, as the Key, with their event count, as the Value.
        /// </summary>
        private List<KeyValuePair<GameObject, int>> _pairedObjectsWithEventCount = new List<KeyValuePair<GameObject, int>>();
    
        // Use this for initialization
        void Start()
        {
            // Find all objects in scene which have the ObjectInScene tag (as there may be other GameObjects in the scene which you do not want).
            _listOfGameObjectsInScene = GameObject.FindGameObjectsWithTag("ObjectInScene").ToList();
    
            FetchAnalytics();
        }
    
  6. A DataFromAnalytics osztályban közvetlenül a Start() metódus után adja hozzá a következő, FetchAnalytics() nevű metódust. Ez a metódus felelős a kulcs-érték párok listájának GameObject és helyőrző eseményszámmal való feltöltődéséért. Ezután inicializálja a GetWebRequest() coroutine-t. Az Application Elemzések hívásának lekérdezési struktúrája ebben a metódusban is megtalálható, mint a Lekérdezés URL-címe végpont.

        private void FetchAnalytics()
        {
            // Iterate through the objects in the list
            for (int i = 0; i < _listOfGameObjectsInScene.Count; i++)
            {
                // The current event number is not known, so set it to zero.
                int eventCount = 0;
    
                // Add new pair to list, as placeholder, until eventCount is known.
                _pairedObjectsWithEventCount.Add(new KeyValuePair<GameObject, int>(_listOfGameObjectsInScene[i], eventCount));
    
                // Set the renderer of the object to the default color, white
                _listOfGameObjectsInScene[i].GetComponent<Renderer>().material.color = Color.white;
    
                // Create the appropriate object name using Insights structure
                string objectName = _listOfGameObjectsInScene[i].name;
    
                // Build the queryUrl for this object.
                string queryUrl = Uri.EscapeUriString(string.Format(
                    "https://api.applicationinsights.io/v1/apps/{0}/events/$all?timespan=PT{1}H&$search={2}&$select=customMetric/name&$top={3}&$count=true",
                    ApplicationInsightsTracker.Instance.applicationId, _timepspanAsHours, "Gazed " + objectName, _quantityOfEventsQueried));
    
    
                // Send this object away within the WebRequest Coroutine, to determine it is event count.
                StartCoroutine("GetWebRequest", new KeyValuePair<string, int>(queryUrl, i));
            }
        }
    
  7. Közvetlenül a FetchAnalytics() metódus alatt adjon hozzá egy GetWebRequest() nevű metódust, amely egy IEnumeratort ad vissza. Ennek a metódusnak az a feladata, hogy lekérte, hogy egy adott GameObjectnek megfelelő esemény hányszor lett meghívva az Application Elemzések. Az összes elküldött lekérdezés visszaadott a DetermineWinner() metódust.

        /// <summary>
        /// Requests the data count for number of events, according to the
        /// input query URL.
        /// </summary>
        /// <param name="webQueryPair">Query URL and the list number count.</param>
        /// <returns></returns>
        private IEnumerator GetWebRequest(KeyValuePair<string, int> webQueryPair)
        {
            // Set the URL and count as their own variables (for readability).
            string url = webQueryPair.Key;
            int currentCount = webQueryPair.Value;
    
            using (UnityWebRequest unityWebRequest = UnityWebRequest.Get(url))
            {
                DownloadHandlerBuffer handlerBuffer = new DownloadHandlerBuffer();
    
                unityWebRequest.downloadHandler = handlerBuffer;
    
                unityWebRequest.SetRequestHeader("host", "api.applicationinsights.io");
    
                unityWebRequest.SetRequestHeader("x-api-key", ApplicationInsightsTracker.Instance.API_Key);
    
                yield return unityWebRequest.SendWebRequest();
    
                if (unityWebRequest.isNetworkError)
                {
                    // Failure with web request.
                    Debug.Log("<color=red>Error Sending:</color> " + unityWebRequest.error);
                }
                else
                {
                    // This query has returned, so add to the current count.
                    _queriesReturned++;
    
                    // Initialize event count integer.
                    int eventCount = 0;
    
                    // Deserialize the response with the custom Analytics class.
                    Analytics welcome = JsonConvert.DeserializeObject<Analytics>(unityWebRequest.downloadHandler.text);
    
                    // Get and return the count for the Event
                    if (int.TryParse(welcome.OdataCount, out eventCount) == false)
                    {
                        // Parsing failed. Can sometimes mean that the Query URL was incorrect.
                        Debug.Log("<color=red>Failure to Parse Data Results. Check Query URL for issues.</color>");
                    }
                    else
                    {
                        // Overwrite the current pair, with its actual values, now that the event count is known.
                        _pairedObjectsWithEventCount[currentCount] = new KeyValuePair<GameObject, int>(_pairedObjectsWithEventCount[currentCount].Key, eventCount);
                    }
    
                    // If all queries (compared with the number which was sent away) have 
                    // returned, then run the determine winner method. 
                    if (_queriesReturned == _pairedObjectsWithEventCount.Count)
                    {
                        DetermineWinner();
                    }
                }
            }
        }
    
  8. A következő metódus a DetermineWinner(), amely a GameObject és az Int párok listáját rendezi a legmagasabb eseményszám szerint. Ezután zöldre módosítja a GameObject anyagszínét (visszajelzésként a legnagyobb számról). Ez megjelenít egy üzenetet az elemzési eredményekkel.

        /// <summary>
        /// Call to determine the keyValue pair, within the objects list, 
        /// with the highest event count.
        /// </summary>
        private void DetermineWinner()
        {
            // Sort the values within the list of pairs.
            _pairedObjectsWithEventCount.Sort((x, y) => y.Value.CompareTo(x.Value));
    
            // Change its colour to green
            _pairedObjectsWithEventCount.First().Key.GetComponent<Renderer>().material.color = Color.green;
    
            // Provide the winner, and other results, within the console window. 
            string message = $"<b>Analytics Results:</b>\n " +
                $"<i>{_pairedObjectsWithEventCount.First().Key.name}</i> has the highest event count, " +
                $"with <i>{_pairedObjectsWithEventCount.First().Value.ToString()}</i>.\nFollowed by: ";
    
            for (int i = 1; i < _pairedObjectsWithEventCount.Count; i++)
            {
                message += $"{_pairedObjectsWithEventCount[i].Key.name}, " +
                    $"with {_pairedObjectsWithEventCount[i].Value.ToString()} events.\n";
            }
    
            Debug.Log(message);
        }
    
  9. Adja hozzá a JSON-objektum deerializálásához használt osztálystruktúrát, amely az Application Elemzések. Adja hozzá ezeket az osztályokat a DataFromAnalytics osztályfájl alján, az osztálydefiníción kívül.

        /// <summary>
        /// These classes represent the structure of the JSON response from Azure Insight
        /// </summary>
        [Serializable]
        public class Analytics
        {
            [JsonProperty("@odata.context")]
            public string OdataContext { get; set; }
    
            [JsonProperty("@odata.count")]
            public string OdataCount { get; set; }
    
            [JsonProperty("value")]
            public Value[] Value { get; set; }
        }
    
        [Serializable]
        public class Value
        {
            [JsonProperty("customMetric")]
            public CustomMetric CustomMetric { get; set; }
        }
    
        [Serializable]
        public class CustomMetric
        {
            [JsonProperty("name")]
            public string Name { get; set; }
        }
    
  10. A Unitybe való visszatérés előtt mindenképpen mentse a módosításokat a Visual Studio.

10. fejezet – A Movement osztály létrehozása

A movement szkript a következő szkript, amit létre kell hoznia. A következőért felelős:

  • A Main Camera mozgatás a kamera irányának megfelelően.
  • Az összes többi szkript hozzáadása objektumok jelenetéhez.

A szkript létrehozása:

  1. Kattintson duplán a Scripts mappára a megnyitásához.

  2. Kattintson a jobb gombbal a Scripts mappában, majd kattintson a > Create C# Script (C#-szkript létrehozása) parancsra. A szkriptnek a Movement (Mozgás) nevet kell írnia.

  3. Kattintson duplán a szkriptre, hogy az a következővel Visual Studio.

  4. Cserélje le a meglévő kódot a következőre:

        using UnityEngine;
        using UnityEngine.XR.WSA.Input;
    
        public class Movement : MonoBehaviour
        {
            /// <summary>
            /// The rendered object representing the right controller.
            /// </summary>
            public GameObject Controller;
    
            /// <summary>
            /// The movement speed of the user.
            /// </summary>
            public float UserSpeed;
    
            /// <summary>
            /// Provides whether source updates have been registered.
            /// </summary>
            private bool _isAttached = false;
    
            /// <summary>
            /// The chosen controller hand to use. 
            /// </summary>
            private InteractionSourceHandedness _handness = InteractionSourceHandedness.Right;
    
            /// <summary>
            /// Used to calculate and proposes movement translation.
            /// </summary>
            private Vector3 _playerMovementTranslation;
    
            private void Start()
            {
                // You are now adding components dynamically 
                // to ensure they are existing on the correct object  
    
                // Add all camera related scripts to the camera. 
                Camera.main.gameObject.AddComponent<Gaze>();
                Camera.main.gameObject.AddComponent<ObjectTrigger>();
    
                // Add all other scripts to this object.
                gameObject.AddComponent<ApplicationInsightsTracker>();
                gameObject.AddComponent<DataFromAnalytics>();
            }
    
            // Update is called once per frame
            void Update()
            {
    
            }
        }
    
  5. A Movement osztályban, az üres Update() metódus alá szúrja be a következő metódusokat, amelyek lehetővé teszik, hogy a felhasználó a kézvezérlővel mozogjon a virtuális térben:

        /// <summary>
        /// Used for tracking the current position and rotation of the controller.
        /// </summary>
        private void UpdateControllerState()
        {
    #if UNITY_WSA && UNITY_2017_2_OR_NEWER
            // Check for current connected controllers, only if WSA.
            string message = string.Empty;
    
            if (InteractionManager.GetCurrentReading().Length > 0)
            {
                foreach (var sourceState in InteractionManager.GetCurrentReading())
                {
                    if (sourceState.source.kind == InteractionSourceKind.Controller && sourceState.source.handedness == _handness)
                    {
                        // If a controller source is found, which matches the selected handness, 
                        // check whether interaction source updated events have been registered. 
                        if (_isAttached == false)
                        {
                            // Register events, as not yet registered.
                            message = "<color=green>Source Found: Registering Controller Source Events</color>";
                            _isAttached = true;
    
                            InteractionManager.InteractionSourceUpdated += InteractionManager_InteractionSourceUpdated;
                        }
    
                        // Update the position and rotation information for the controller.
                        Vector3 newPosition;
                        if (sourceState.sourcePose.TryGetPosition(out newPosition, InteractionSourceNode.Pointer) && ValidPosition(newPosition))
                        {
                            Controller.transform.localPosition = newPosition;
                        }
    
                        Quaternion newRotation;
    
                        if (sourceState.sourcePose.TryGetRotation(out newRotation, InteractionSourceNode.Pointer) && ValidRotation(newRotation))
                        {
                            Controller.transform.localRotation = newRotation;
                        }
                    }
                }
            }
            else
            {
                // Controller source not detected. 
                message = "<color=blue>Trying to detect controller source</color>";
    
                if (_isAttached == true)
                {
                    // A source was previously connected, however, has been lost. Disconnected
                    // all registered events. 
    
                    _isAttached = false;
    
                    InteractionManager.InteractionSourceUpdated -= InteractionManager_InteractionSourceUpdated;
    
                    message = "<color=red>Source Lost: Detaching Controller Source Events</color>";
                }
            }
    
            if(message != string.Empty)
            {
                Debug.Log(message);
            }
    #endif
        }
    
        /// <summary>
        /// This registered event is triggered when a source state has been updated.
        /// </summary>
        /// <param name="obj"></param>
        private void InteractionManager_InteractionSourceUpdated(InteractionSourceUpdatedEventArgs obj)
        {
            if (obj.state.source.handedness == _handness)
            {
                if(obj.state.thumbstickPosition.magnitude > 0.2f)
                {
                    float thumbstickY = obj.state.thumbstickPosition.y;
    
                    // Vertical Input.
                    if (thumbstickY > 0.3f || thumbstickY < -0.3f)
                    {
                        _playerMovementTranslation = Camera.main.transform.forward;
                        _playerMovementTranslation.y = 0;
                        transform.Translate(_playerMovementTranslation * UserSpeed * Time.deltaTime * thumbstickY, Space.World);
                    }
                }
            }
        }
    
        /// <summary>
        /// Check that controller position is valid. 
        /// </summary>
        /// <param name="inputVector3">The Vector3 to check</param>
        /// <returns>The position is valid</returns>
        private bool ValidPosition(Vector3 inputVector3)
        {
            return !float.IsNaN(inputVector3.x) && !float.IsNaN(inputVector3.y) && !float.IsNaN(inputVector3.z) && !float.IsInfinity(inputVector3.x) && !float.IsInfinity(inputVector3.y) && !float.IsInfinity(inputVector3.z);
        }
    
        /// <summary>
        /// Check that controller rotation is valid. 
        /// </summary>
        /// <param name="inputQuaternion">The Quaternion to check</param>
        /// <returns>The rotation is valid</returns>
        private bool ValidRotation(Quaternion inputQuaternion)
        {
            return !float.IsNaN(inputQuaternion.x) && !float.IsNaN(inputQuaternion.y) && !float.IsNaN(inputQuaternion.z) && !float.IsNaN(inputQuaternion.w) && !float.IsInfinity(inputQuaternion.x) && !float.IsInfinity(inputQuaternion.y) && !float.IsInfinity(inputQuaternion.z) && !float.IsInfinity(inputQuaternion.w);
        }   
    
  6. Végül adja hozzá a metódushívást az Update() metódusban.

        // Update is called once per frame
        void Update()
        {
            UpdateControllerState();
        }
    
  7. Mielőtt visszatér a Unitybe, mindenképpen mentse a módosításokat a Visual Studio, mielőtt visszatér a Unitybe.

11. fejezet – A szkripthivatkozások beállítása

Ebben a fejezetben a Movement szkriptet a Camera Parent (Kamera szülője) fölé kell állítania, és be kell állítania a referenciacéljait. Ez a szkript kezeli majd a többi szkript elhelyezését, ahol szükség van rá.

  1. A Project Panel Scripts mappájában húzza a Movement parancsfájlt a Camera Parent objektumra, amely a Hierarchia panelen található.

    Szkripthivatkozások beállítása a Unity-jelenetben

  2. Kattintson a Camera Parent (Kamera szülője) elemre. A Hierarchia panelen húzza a jobb oldali objektumot a Hierarchia panelről a referenciacélra(Controller) az Inspector panelen. Állítsa a Felhasználói sebesség beállítását 5-re az alábbi képen látható módon.

    Szkripthivatkozások beállítása a Unity-jelenetben

12. fejezet – A Unity-projekt létrehozása

A projekt Unity szakaszának minden szükséges művelete befejeződött, így ideje a Unityből felépíteni.

  1. Lépjen a Build Gépház, (File > Build Gépház).

  2. A Build Gépház ablakban kattintson a Build (Összeállítás) elemre.

    Unity-Project UWP-megoldáshoz

  3. Megjelenik Fájlkezelő előugró ablak, amely a build helyét kéri. Hozzon létre egy új mappát (a bal felső sarokban található New Folder (Új mappa) gombra kattintva), és nevezze el BUILDS néven.

    Unity-Project UWP-megoldáshoz

    1. Nyissa meg az új BUILDS mappát, és hozzon létre egy másik mappát (még egyszer a New Folder (Új mappa) használatával), és nevezze el MR Azure Application _ _ _ Elemzések.

      Unity-Project UWP-megoldáshoz

    2. Jelölje ki az MR Azure Application _ _ _ Elemzések mappát, és kattintson a Select Folder (Mappa kiválasztása) elemre. A projekt létrehozása egy-egy percet is igénybe fog venni.

  4. A Build (Fájlkezelő) után megjelenik az új projekt helye.

13. fejezet – MR_Azure_Application_Insights üzembe helyezése a gépen

Az MR _ _ Azure-alkalmazás _ Elemzések üzembe helyezése a helyi gépen:

  1. Nyissa meg az MR _ _ Azure-alkalmazás _ Elemzések megoldásfájlját a Visual Studio.

  2. A Megoldásplatformon válassza az x86, helyi gép lehetőséget.

  3. A Megoldáskonfigurációban válassza a Hibakeresés lehetőséget.

    Unity-Project UWP-megoldáshoz

  4. A Build (Build) menüben kattintson a Deploy Solution (Megoldás üzembe helyezése) elemre az alkalmazás saját gépre való telepítéséhez.

  5. Az alkalmazásnak most már meg kell jelenni a telepített alkalmazások listájában, amely készen áll a telepítésre.

  6. Indítsa el a vegyes valóság alkalmazást.

  7. Mozoghat a jelenetben, megközelítve az objektumokat, és azokat nézve, amikor az Azure Insight Service elegendő eseményadatot gyűjtött össze, a leginkább megkért objektumot zöldre fogja állítani.

Fontos

Míg a szolgáltatás által gyűjtött események és metrikák átlagos várakozási ideje körülbelül 15 percet vesz igénybe, bizonyos esetekben akár 1 órát is igénybe vehet.

14. fejezet – Az Application Elemzések Service portál

Miután körbe barangolt a jelenetben, és több objektumra tekintett, láthatja az Application Elemzések Service portálon gyűjtött adatokat.

  1. Vissza az Application Elemzések Service Portalra.

  2. Kattintson a Metrikaböngésző elemre.

    Az összegyűjtött adatok ása

  3. Megnyílik egy lapon, amely az alkalmazáshoz kapcsolódó eseményeket és metrikákat ábrázoló grafikont tartalmazza. Ahogy korábban említettük, az adatok gráfban való megjelenítése némi időt (akár 1 órát) is

    Az összegyűjtött adatok ása

  4. Kattintson a Total of Events by Application Version (Események összege alkalmazásverzió szerint) menüsávra az események részletes, névvel való bontásának a nevére vonatkozó részletekért.

    Az összegyűjtött adatok ása

Elkészült az Application Elemzések Service-alkalmazással

Gratulálunk, felépített egy vegyes valóságot használó alkalmazást, amely az Application Elemzések Service-t használja a felhasználók alkalmazáson belüli tevékenységének figyelése érdekében.

kurzus eredménye

Bónusz gyakorlatok

1. gyakorlat

A manuális létrehozás helyett próbálja meg létrehozni az ObjectInScene objektumokat, és állítsa be azok koordinátáit a szkriptek síkon. Így meg lehet kérdezni az Azure-tól, hogy mi volt a legnépszerűbb objektum (tekintet vagy közelségi eredmények alapján), és egy további objektumot hoz létre ezek közül.

2. gyakorlat

Rendezheti az alkalmazás Elemzések eredményeket, hogy a leginkább releváns adatokat kapják meg, és ezeket az időérzékeny adatokat implementálja az alkalmazásban.