HoloLens (1. generace) a Azure 309: Application Insights

Článek
07/04/2024

Poznámka:

Kurzy Mixed Reality Academy byly navrženy s HoloLensem (1. generace) a imerzivními náhlavními soupravami hybridní reality. Proto máme pocit, že je důležité nechat tyto kurzy zavedené pro vývojáře, kteří stále hledají pokyny při vývoji těchto zařízení. Tyto kurzy nebudou aktualizovány nejnovějšími sadami nástrojů ani interakcemi používanými pro HoloLens 2. Budou zachovány, aby pokračovaly v práci na podporovaných zařízeních. Bude k dispozici nová série kurzů, které budou publikovány v budoucnu, které předvádějí, jak vyvíjet pro HoloLens 2. Toto oznámení se při publikování aktualizuje odkazem na tyto kurzy.

Úvodní obrazovka kurzu Mixed Reality Academy.

V tomto kurzu se dozvíte, jak přidat funkce Application Insights do aplikace hybridní reality pomocí rozhraní API Aplikace Azure lication Insights ke shromažďování analýz týkajících se chování uživatelů.

Application Insights je služba Microsoftu, která vývojářům umožňuje shromažďovat analýzy ze svých aplikací a spravovat je z snadno použitelného portálu. Analýza může být cokoli od výkonu až po vlastní informace, které chcete shromažďovat. Další informace najdete na stránce Application Insights.

Po dokončení tohoto kurzu budete mít aplikaci pro imerzivní náhlavní soupravu hybridní reality, která bude moct provést následující akce:

Umožňuje uživateli upřet pohled na scénu a pohybovat se kolem scény.
Aktivujte odesílání analýz do služby Application Insights pomocí pohledu a blízkosti objektů ve scéně.
Aplikace bude také volat službu a během posledních 24 hodin načítá informace o objektu, ke kterému se uživatel přiblíží nejvíce. Tento objekt změní barvu na zelenou.

V tomto kurzu se dozvíte, jak získat výsledky ze služby Application Insights do ukázkové aplikace založené na Unity. Bude na vás, abyste tyto koncepty použili na vlastní aplikaci, kterou byste mohli vytvářet.

Podpora zařízení

Kurz	HoloLens	Imerzivní náhlavní soupravy
MR a Azure 309: Application Insights	✔️	✔️

Poznámka:

I když se tento kurz primárně zaměřuje na imerzivní náhlavní soupravy Windows Mixed Reality (VR), můžete také použít to, co se v tomto kurzu naučíte, na Microsoft HoloLens. Při sledování kurzu uvidíte poznámky o všech změnách, které možná budete potřebovat k podpoře HoloLensu. Při použití HoloLensu si můžete během hlasového zachycení všimnout určité ozvěny.

Požadavky

Poznámka:

Tento kurz je určený pro vývojáře, kteří mají základní zkušenosti s Unity a C#. Mějte také na paměti, že požadavky a písemné pokyny v tomto dokumentu představují to, co bylo otestováno a ověřeno v době psaní (červenec 2018). Můžete používat nejnovější software, jak je uvedeno v článku o instalaci nástrojů , i když by se nemělo předpokládat, že informace v tomto kurzu budou dokonale odpovídat tomu, co najdete v novějším softwaru, než je uvedeno níže.

Pro tento kurz doporučujeme následující hardware a software:

Vývojový počítač kompatibilní s Windows Mixed Reality pro vývoj imerzivních náhlavních souprav (VR)
Windows 10 Fall Creators Update (nebo novější) s povoleným režimem vývojáře
Nejnovější sada Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Imerzivní náhlavní souprava Windows Mixed Reality (VR) nebo Microsoft HoloLens s povoleným režimem vývojáře
Sada sluchátek s vestavěným mikrofonem (pokud náhlavní souprava nemá vestavěný mikrofon a reproduktory)
Přístup k internetu pro nastavení Azure a načítání dat Application Insights

Než začnete

Abyste se vyhnuli problémům při sestavování tohoto projektu, důrazně doporučujeme vytvořit projekt v tomto kurzu v kořenové nebo téměř kořenové složce (dlouhé cesty ke složkám můžou způsobovat problémy v době sestavení).

Upozorňující

Mějte na paměti, že data do Application Insights nějakou dobu trvá, takže buďte trpěliví. Pokud chcete zkontrolovat, jestli služba obdržela vaše data, podívejte se na kapitolu 14, která vám ukáže, jak na portálu přejít.

Kapitola 1 – Azure Portal

Pokud chcete používat Application Insights, budete muset vytvořit a nakonfigurovat službu Application Insights na webu Azure Portal.

Přihlaste se na webu Azure Portal.

Poznámka:

Pokud ještě nemáte účet Azure, budete ho muset vytvořit. Pokud tento kurz sledujete v situaci v učebně nebo testovacím prostředí, požádejte svého instruktora nebo některého z proktorů, aby vám pomohli nastavit nový účet.
Po přihlášení klikněte v levém horním rohu na Nový a vyhledejte Application Insights a klikněte na Enter.

Poznámka:

Slovo Nový mohlo být nahrazeno vytvořením prostředku na novějších portálech.
Na nové stránce vpravo se zobrazí popis služby Aplikace Azure lication Insights. V levém dolním rohu této stránky vyberte tlačítko Vytvořit a vytvořte přidružení k této službě.
Po kliknutí na Vytvořit:
1. Vložte požadovaný název pro tuto instanci služby.
2. Jako typ aplikace vyberte Obecné.
3. Vyberte příslušné předplatné.
4. Zvolte skupinu prostředků nebo vytvořte novou. Skupina prostředků poskytuje způsob, jak monitorovat, řídit přístup, zřizovat a spravovat fakturaci pro kolekci prostředků Azure. Doporučuje se zachovat všechny služby Azure přidružené k jednomu projektu (například tyto kurzy) v rámci společné skupiny prostředků).
  
  Pokud si chcete přečíst další informace o skupinách prostředků Azure, navštivte prosím článek o skupině prostředků.
5. Vyberte Umístění.
6. Budete také muset potvrdit, že jste porozuměli podmínkám a ujednáním použitým pro tuto službu.
7. Vyberte Vytvořit.
Jakmile kliknete na Vytvořit, budete muset počkat, až se služba vytvoří, může to trvat minutu.
Po vytvoření instance služby se na portálu zobrazí oznámení.
Vyberte oznámení a prozkoumejte novou instanci služby.
Kliknutím na tlačítko Přejít k prostředku v oznámení můžete prozkoumat novou instanci služby. Přejdete do nové instance služby Application Insights.

Poznámka:

Nechte tuto webovou stránku otevřenou a snadno přístupnou, často se sem vrátíte, abyste viděli shromážděná data.

Důležité

K implementaci Application Insights budete muset použít tři (3) specifické hodnoty: instrumentační klíč, ID aplikace a klíč rozhraní API. Níže se dozvíte, jak tyto hodnoty načíst z vaší služby. Nezapomeňte si tyto hodnoty poznamenat na prázdné stránce Poznámkového bloku , protože je brzy použijete ve svém kódu.
Pokud chcete najít instrumentační klíč, budete se muset posunout dolů v seznamu funkcí služby a vybrat Vlastnosti, zobrazí se karta zobrazená klíč služby.
Trochu pod vlastnostmi najdete Přístup k rozhraní API, na které potřebujete kliknout. Na panelu vpravo se zobrazí ID aplikace.
Po otevření panelu ID aplikace klikněte na Vytvořit klíč rozhraní API, který otevře panel Vytvořit klíč rozhraní API.
V otevřeném panelu Vytvořit klíč rozhraní API zadejte popis a zaškrtněte tři pole.
Klikněte na Vygenerovat klíč. Váš klíč rozhraní API se vytvoří a zobrazí.

Upozorňující

Toto je jediný čas, kdy se klíč služby zobrazí, takže teď vytvořte jeho kopii.

Kapitola 2 – Nastavení projektu Unity

Následuje typické nastavení pro vývoj s hybridní realitou, a proto je vhodná šablona pro jiné projekty.

Otevřete Unity a klikněte na Nový.
Teď budete muset zadat název projektu Unity, vložit MR_Azure_Application_Insights. Ujistěte se, že je šablona nastavená na 3D. Nastavte umístění na místo, které je pro vás vhodné (nezapomeňte, že blíže ke kořenovým adresářům je lepší). Potom klikněte na Vytvořit projekt.
Když je Unity otevřená, je vhodné zkontrolovat, jestli je výchozí editor skriptů nastavený na Visual Studio. Přejděte na Upravit předvolby a pak v novém okně přejděte na Externí nástroje. > Změňte editor externích skriptů na Visual Studio 2017. Zavřete okno Předvolby.
Dále přejděte do Nastavení sestavení souborů > a přepněte platformu na Univerzální platforma Windows kliknutím na tlačítko Přepnout platformu.
Přejděte do nastavení sestavení souborů > a ujistěte se, že:
1. Cílové zařízení je nastavené na libovolné zařízení.
  
  Pro Microsoft HoloLens nastavte cílové zařízení na HoloLens.
2. Typ sestavení je nastavený na D3D.
3. Sada SDK je nastavená na nejnovější nainstalovanou verzi.
4. Sestavení a spuštění je nastavené na místní počítač.
5. Uložte scénu a přidejte ji do sestavení.
  1. Uděláte to tak, že vyberete Přidat otevřené scény. Zobrazí se okno pro uložení.
  2. Vytvořte novou složku pro tuto a jakoukoli budoucí scénu a potom klikněte na tlačítko Nová složka a vytvořte novou složku, pojmenujte ji Scény.
  3. Otevřete nově vytvořenou složku Scény a potom v názvu souboru: textové pole, zadejte ApplicationInsightsScene a klikněte na Uložit.
Zbývající nastavení v nastavení sestavení by teď měla zůstat ve výchozím nastavení.
V okně Nastavení sestavení vyberte Nastavení přehrávače, otevře se související panel v prostoru, kde se nachází inspektor.
Na tomto panelu je potřeba ověřit několik nastavení:
1. Na kartě Další nastavení:
  1. Skriptovací verze modulu runtime by měla být experimentální (ekvivalent .NET 4.6), která aktivuje nutnost restartování editoru.
  2. Back-end skriptování by měl být .NET.
  3. Úroveň kompatibility rozhraní API by měla být .NET 4.6
2. Na kartě Nastavení publikování v části Možnosti zaškrtněte:
  - InternetClient
3. Dále na panelu v nastavení XR (najdete pod nastavením publikování) zaškrtněte možnost Podpora virtuální reality a ujistěte se, že je přidaná sada SDK pro Windows Mixed Reality .
Zpět v nastavení sestavení už projekty Unity C# nejsou šedé. Zaškrtněte políčko vedle tohoto nastavení.
Zavřete okno Nastavení sestavení.
Uložte scénu a projekt (FILE SAVE SCENE / FILE>>SAVE PROJECT).

Kapitola 3 – Import balíčku Unity

Důležité

Pokud chcete přeskočit komponenty Nastavení Unity v tomto kurzu a pokračovat přímo do kódu, můžete si stáhnout tento balíček Azure-MR-309.unitypackage, importovat ho do projektu jako vlastní balíček. Bude obsahovat také knihovny DLL z další kapitoly. Po importu pokračujte z kapitoly 6.

Důležité

Pokud chcete použít Application Insights v Unity, musíte pro ni importovat knihovnu DLL spolu s knihovnou DLL Newtonsoft. V Unity je v současné době známý problém, který vyžaduje, aby se po importu překonfigurovaly moduly plug-in. Tyto kroky (4 až 7 v této části) se už po vyřešení chyby nevyžadují.

Pokud chcete importovat Application Insights do vlastního projektu, ujistěte se, že jste stáhli soubor .unitypackage obsahující moduly plug-in. Pak proveďte tyto akce:

Přidejte soubor.unitypackage** do Unity pomocí možnosti nabídky Vlastní balíček importu prostředků>.>
V okně Import Unity Package (Importovat balíček Unity), které se zobrazí, zkontrolujte, že je vybrané vše v části (a včetně) modulů plug-in.
Kliknutím na tlačítko Importovat přidejte položky do projektu.
Přejděte do složky Insights v části Moduly plug-in v zobrazení Projektu a vyberte pouze následující moduly plug-in:
- Microsoft.ApplicationInsights
Pokud je vybraný tento modul plug-in, ujistěte se, že je nezaškrtnutá možnost Libovolná platforma, a ujistěte se, že je také nezaškrtnutá možnost WSAPlayer a potom klikněte na tlačítko Použít. Stačí jenom ověřit, že jsou soubory správně nakonfigurované.

Poznámka:

Označení podobných modulů plug-in nakonfiguruje tak, aby se používaly jenom v Unity Editoru. Ve složce WSA existuje jiná sada knihoven DLL, které se po exportu projektu z Unity použijí.
Dále musíte otevřít složku WSA v rámci složky Insights . Zobrazí se kopie stejného souboru, který jste nakonfigurovali. Vyberte tento soubor a potom v inspektoru ověřte, že je nezaškrtnutá žádná platforma, a pak zkontrolujte, že je zaškrtnuté pouze WSAPlayer. Klikněte na tlačítko Použit.
Teď budete muset postupovat podle kroků 4 až 6, ale pro moduly plug-in Newtonsoft . Podívejte se na následující snímek obrazovky s tím, jak by měl výsledek vypadat.

Kapitola 4 – Nastavení kamery a uživatelských ovládacích prvků

V této kapitole nastavíte kameru a ovládací prvky, které uživateli umožní vidět a přesouvat se ve scéně.

Pravým tlačítkem myši klikněte do prázdné oblasti na panelu hierarchie a pak v části Vytvořit>prázdný.
Přejmenujte nový prázdný GameObject na Nadřazený objekt fotoaparátu.
Klikněte pravým tlačítkem myši do prázdné oblasti na panelu hierarchie a pak na 3D objektu a pak na Sphere.
Přejmenujte Sphere na pravou ruku.
Nastavení měřítka transformace pravé ruky na 0,1, 0,1, 0,1
Odeberte komponentu spletiče Sphere z pravé ruky kliknutím na ozubené kolečko v komponentě Sbalovač Sphere a poté odebrat komponentu.
Na panelu hierarchie přetáhněte hlavní kameru a objekty vpravo na nadřazený objekt fotoaparátu.
Nastavte pozici transformace hlavní kamery i objektu Pravá ruka na hodnotu 0, 0, 0.

Kapitola 5 – Nastavení objektů ve scéně Unity

Teď pro svoji scénu vytvoříte několik základních obrazců, se kterými může uživatel pracovat.

Klikněte pravým tlačítkem myši do prázdné oblasti na panelu hierarchie a pak na 3D objekt a pak vyberte Rovina.
Nastavte pozici transformace roviny na 0, -1, 0.
Nastavte měřítko transformace roviny na 5, 1, 5.
Vytvořte základní materiál pro použití s objektem Rovina , aby ostatní obrazce byly snadněji vidět. Přejděte na panel projektu, klikněte pravým tlačítkem myši a potom vytvořte novou složku a potom složku. Pojmenujte ho Materiály.
Otevřete složku Materiály a potom klikněte pravým tlačítkem myši, klepněte na příkaz Vytvořit, potom Materiál a vytvořte nový materiál. Pojmenujte ho Modře.
S vybraným novým modrým materiálem se podívejte na inspektor a klikněte na obdélníkové okno vedle Albedo. Vyberte modrou barvu (obrázek níže je Hex Color: #3592FFFF). Po výběru klikněte na tlačítko Zavřít.
Přetáhněte nový materiál ze složky Materiály do nově vytvořené roviny ve scéně (nebo ho přetáhněte na objekt Rovina v hierarchii).
Pravým tlačítkem myši klikněte do prázdné oblasti v panelu hierarchie a pak na 3D objektu capsule.
- S vybranou kapsli změňte její transformační pozici na : -10, 1, 0.
Klikněte pravým tlačítkem myši do prázdné oblasti na panelu hierarchie a potom na 3D objektu v datové krychli.
- Když je vybraná datová krychle, změňte její pozici transformace na: 0, 0, 10.
Pravým tlačítkem myši klikněte do prázdné oblasti na panelu hierarchie a pak na 3D objektu Sphere.
- S vybranou oblastí změňte jeho transformační pozici na: 10, 0, 0.
Poznámka:

Tyto hodnoty pozice jsou návrhy. Můžete nastavit pozice objektů na cokoli, co chcete, i když je pro uživatele aplikace jednodušší, pokud vzdálenost objektů není příliš daleko od kamery.
Když je vaše aplikace spuštěná, musí být schopná identifikovat objekty ve scéně, aby toho bylo možné dosáhnout, musí být označené. Vyberte jeden z objektů a na panelu inspektoru klikněte na Přidat značku..., který prohodí inspektor s panelem Značky a vrstvy.
Klikněte na symbol + (plus) a zadejte název značky jako ObjectInScene.

Upozorňující

Pokud pro značku použijete jiný název, budete muset zajistit, aby se tato změna také změnila na dataFromAnalytics, ObjectTrigger a Gaze, skripty později, aby byly nalezeny a zjištěny objekty ve scéně.
Když je značka vytvořená, musíte ji teď použít pro všechny tři objekty. V hierarchii podržte klávesu Shift a potom klikněte na kapsle, datová krychle a sphere, objekty, pak v inspektoru klikněte na rozevírací nabídku vedle značky Tag a potom klikněte na značku ObjectInScene, kterou jste vytvořili.

Kapitola 6 – Vytvoření třídy ApplicationInsightsTracker

Prvním skriptem, který potřebujete vytvořit, je ApplicationInsightsTracker, který zodpovídá za:

Vytváření událostí na základě interakcí uživatelů, které se mají odeslat do Aplikace Azure lication Insights.
Vytváření vhodných názvů událostí v závislosti na interakci uživatele
Odesílání událostí do instance služby Application Insights

Vytvoření této třídy:

Pravým tlačítkem myši klikněte na panel projektu a pak na Vytvořit>složku. Pojmenujte složky Skripty.
Když jste vytvořili složku Scripts , poklikejte na ni a otevřete ji. Potom v této složce klikněte pravým tlačítkem myši na příkaz Vytvořit>skript jazyka C#. Pojmenujte skript ApplicationInsightsTracker.
Poklikáním otevřete nový skript ApplicationInsightsTracker v sadě Visual Studio.

Aktualizujte obory názvů v horní části skriptu následujícím způsobem:

    using Microsoft.ApplicationInsights;
    using Microsoft.ApplicationInsights.DataContracts;
    using Microsoft.ApplicationInsights.Extensibility;
    using UnityEngine;

Uvnitř třídy vložte následující proměnné:

    /// <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;

Poznámka:

Nastavte hodnoty instrumentationKey, applicationId a API_Key odpovídajícím způsobem pomocí klíčů služby z webu Azure Portal, jak je uvedeno v kapitole 1, krok 9 výše.

Pak přidejte metody Start() a Awake(), které budou volány při inicializaci třídy:

    /// <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;
    }

Přidejte metody zodpovědné za odesílání událostí a metrik registrovaných vaší aplikací:

    /// <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);
    }

Než se vrátíte do Unity, nezapomeňte změny uložit v sadě Visual Studio.

Kapitola 7 – Vytvoření skriptu Pohled

Dalším skriptem , který se má vytvořit, je skript Gaze . Tento skript je zodpovědný za vytvoření Raycastu, který bude promítnut vpřed z hlavní kamery, aby zjistil, na který objekt se uživatel dívá. V tomto případě bude raycast muset zjistit, jestli se uživatel dívá na objekt se značkou ObjectInScene, a pak spočítat, jak dlouho uživatel upřená na daný objekt.

Poklikáním otevřete složku Skripty .
Klikněte pravým tlačítkem do složky Scripts (Skripty) a klikněte na Create C# Script (Vytvořit>skript jazyka C#). Pojmenujte skript Gaze.
Poklikáním na skript ho otevřete v sadě Visual Studio.

Nahraďte stávající kód následujícím kódem:

    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;
    }

Kód pro metody Awake() a Start() je teď potřeba přidat.

    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;
    }

Uvnitř třídy Gaze přidejte do metody Update() následující kód pro projekt Raycast a zjištění cílového hitu:

    /// <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;
        }
    }

Přidejte metodu ResetFocusedObject() pro odeslání dat do Application Insights , když se uživatel podíval na objekt.

    /// <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;
            }
        }
    }

Dokončili jste skript Gaze . Před návratem do Unity uložte změny v sadě Visual Studio.

Kapitola 8 – Vytvoření třídy ObjectTrigger

Dalším skriptem, který potřebujete vytvořit, je ObjectTrigger, který zodpovídá za:

Přidání komponent potřebných ke kolizi do hlavní kamery
Zjistí, jestli se fotoaparát nachází poblíž objektu označeného jako ObjectInScene.

Vytvoření skriptu:

Poklikáním otevřete složku Skripty .
Klikněte pravým tlačítkem do složky Scripts (Skripty) a klikněte na Create C# Script (Vytvořit>skript jazyka C#). Pojmenujte skript ObjectTrigger.

Poklikáním na skript ho otevřete v sadě Visual Studio. Nahraďte stávající kód následujícím kódem:

    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);
            }
        }
    }

Než se vrátíte do Unity, nezapomeňte změny uložit v sadě Visual Studio.

Kapitola 9 – Vytvoření třídy DataFromAnalytics

Teď budete muset vytvořit skript DataFromAnalytics , který je zodpovědný za:

Načítání analytických dat o tom, ke kterému objektu přistupovala kamera nejvíce.
Pomocí klíčů služby, které umožňují komunikaci s vaší instancí služby Aplikace Azure lication Insights.
Řazení objektů ve scéně, podle kterého má nejvyšší počet událostí.
Změna barvy materiálu u nejužovanějšího objektu na zelenou.

Vytvoření skriptu:

Poklikáním otevřete složku Skripty .
Klikněte pravým tlačítkem do složky Scripts (Skripty) a klikněte na Create C# Script (Vytvořit>skript jazyka C#). Pojmenujte skript DataFromAnalytics.
Poklikáním na skript ho otevřete v sadě Visual Studio.

Vložte následující obory názvů:

    using Newtonsoft.Json;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using UnityEngine;
    using UnityEngine.Networking;

Do skriptu vložte následující:

    /// <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();
    }

Do třídy DataFromAnalytics přidejte hned za metodu Start() následující metodu s názvem FetchAnalytics(). Tato metoda zodpovídá za naplnění seznamu párů klíč-hodnota pomocí Objektu GameObject a zástupného počtu událostí. Potom inicializuje korutinu GetWebRequest(). Strukturu dotazu volání Application Insights najdete také v rámci této metody jako koncový bod adresy URL dotazu.

    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));
        }
    }

Přímo pod metodu FetchAnalytics() přidejte metodu s názvem GetWebRequest(), která vrátí IEnumerator. Tato metoda zodpovídá za vyžádání počtu událostí odpovídajících konkrétnímu Objektu GameObject, který byl volána v Rámci Application Insights. Po vrácení všech odeslaných dotazů je volána metoda DetermineWinner().

    /// <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();
                }
            }
        }
    }

Další metodou je DetermineWinner(), která seřadí seznam dvojic GameObject a Int podle nejvyššího počtu událostí. Potom změní barvu materiálu objektu GameObject na zelenou (jako názor na to, že má nejvyšší počet). Zobrazí se zpráva s výsledky analýzy.

    /// <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);
    }

Přidejte strukturu třídy, která se použije k deserializaci objektu JSON přijatého z Application Insights. Tyto třídy přidejte na konec souboru třídy DataFromAnalytics mimo definici třídy.

    /// <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; }
    }

Než se vrátíte do Unity, nezapomeňte změny uložit v sadě Visual Studio.

Kapitola 10 – Vytvoření třídy pohybu

Skript pro přesun je dalším skriptem, který budete muset vytvořit. Zodpovídá za:

Pohyb hlavní kamery podle směru, na který se kamera dívá.
Přidání všech ostatních skriptů do objektů scény

Vytvoření skriptu:

Poklikáním otevřete složku Skripty .
Klikněte pravým tlačítkem do složky Scripts (Skripty) a klikněte na Create C# Script (Vytvořit>skript jazyka C#). Pojmenujte pohyb skriptu.
Poklikáním na skript ho otevřete v sadě Visual Studio.

Nahraďte stávající kód následujícím kódem:

    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()
        {

        }
    }

Do třídy Movement vložte pod prázdnou metodu Update() následující metody, které uživateli umožňují pohybovat se ve virtuálním prostoru pomocí kontroleru ruky:

    /// <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);
    }

Nakonec přidejte volání metody v metodě Update().

    // Update is called once per frame
    void Update()
    {
        UpdateControllerState();
    }

Než se vrátíte do Unity, nezapomeňte změny uložit v sadě Visual Studio.

Kapitola 11 – Nastavení odkazů na skripty

V této kapitole musíte umístit skript pohybu na nadřazenou kameru a nastavit jeho referenční cíle. Tento skript pak zpracuje umístění ostatních skriptů tam, kde musí být.

Ze složky Skripty na panelu projektu přetáhněte skript pro přesun do nadřazeného objektu fotoaparátu umístěného v panelu hierarchie.
Klikněte na nadřazenou položku fotoaparátu. Na panelu hierarchie přetáhněte objekt Pravé ruky z panelu hierarchie do referenčního cíle kontroleru v panelu inspektoru. Nastavte rychlost uživatele na 5, jak je znázorněno na následujícím obrázku.

Kapitola 12 – Sestavení projektu Unity

Všechno potřebné pro oddíl Unity tohoto projektu bylo dokončeno, takže je čas ho sestavit z Unity.

Přejděte na Nastavení sestavení (Nastavení sestavení souboru>).
V okně Nastavení sestavení klikněte na Sestavit.
Zobrazí se okno Průzkumník souborů s výzvou k zadání umístění sestavení. Vytvořte novou složku (kliknutím na Nová složka v levém horním rohu) a pojmenujte ji BUILDS.
1. Otevřete novou složku BUILDS a vytvořte další složku (pomocí nové složky ještě jednou) a pojmenujte ji MR_Azure_Application_Insights.
2. Pokud je vybraná MR_Azure_Application_Insights složka, klikněte na Vybrat složku. Sestavení projektu bude trvat minutu nebo tak.
Po sestavení se Průzkumník souborů zobrazí umístění nového projektu.

Kapitola 13 – Nasazení aplikace MR_Azure_Application_Insights do počítače

Nasazení aplikace MR_Azure_Application_Insights na místním počítači:

Otevřete soubor řešení MR_Azure_Application_Insights aplikace v sadě Visual Studio.
Na platformě řešení vyberte x86, místní počítač.
V konfiguraci řešení vyberte Ladit.
Přejděte do nabídky Sestavení a kliknutím na Nasadit řešení načtěte aplikaci do počítače bokem.
Vaše aplikace by se teď měla zobrazit v seznamu nainstalovaných aplikací připravených ke spuštění.
Spusťte aplikaci hybridní reality.
Pohyb po scéně, přístup k objektům a jejich prohlížení, když služba Azure Insights shromáždila dostatek dat událostí, nastaví objekt, který byl nejvíce přístupný na zelenou.

Důležité

Zatímco průměrná doba čekání na události a metriky shromážděná službou trvá přibližně 15 minut, v některých případech může trvat až 1 hodinu.

Kapitola 14 – Portál služby Application Insights

Jakmile se kolem scény přesunete a podíváte se na několik objektů, uvidíte data shromážděná na portálu služby Application Insights.

Vraťte se na portál služby Application Insights.
Vyberte Průzkumník metrik.
Otevře se na kartě obsahující graf, který představuje události a metriky související s vaší aplikací. Jak už bylo zmíněno výše, může trvat nějakou dobu (až 1 hodinu), než se data zobrazí v grafu.
Výběrem panelu Události v souhrnu událostí podle verze aplikace zobrazíte podrobný rozpis událostí s jejich názvy.

Vaše dokončená aplikace služby Application Insights

Blahopřejeme, vytvořili jste aplikaci hybridní reality, která využívá službu Application Insights k monitorování aktivity uživatele v rámci vaší aplikace.

Úvodní obrazovka kurzu.

Bonusová cvičení

Cvičení 1

Zkuste vytvořit objekty ObjectInScene a nastavte jejich souřadnice v rovině ve vašich skriptech, a ne ručně. Tímto způsobem byste se mohli zeptat Azure, co byl nejoblíbenější objekt (z pohledu nebo výsledků blízkosti) a vytvořit další z těchto objektů.

Cvičení 2

Výsledky Application Insights seřadíte podle času, abyste získali nejrelevavantnější data a implementovali tato data citlivá na čas ve vaší aplikaci.

Sdílet prostřednictvím

HoloLens (1. generace) a Azure 309: Application Insights

Podpora zařízení

Požadavky

Než začnete

Kapitola 1 – Azure Portal

Kapitola 2 – Nastavení projektu Unity

Kapitola 3 – Import balíčku Unity

Kapitola 4 – Nastavení kamery a uživatelských ovládacích prvků

Kapitola 5 – Nastavení objektů ve scéně Unity

Kapitola 6 – Vytvoření třídy ApplicationInsightsTracker

Kapitola 7 – Vytvoření skriptu Pohled

Kapitola 8 – Vytvoření třídy ObjectTrigger

Kapitola 9 – Vytvoření třídy DataFromAnalytics

Kapitola 10 – Vytvoření třídy pohybu

Kapitola 11 – Nastavení odkazů na skripty

Kapitola 12 – Sestavení projektu Unity

Kapitola 13 – Nasazení aplikace MR_Azure_Application_Insights do počítače

Kapitola 14 – Portál služby Application Insights

Vaše dokončená aplikace služby Application Insights

Bonusová cvičení

Další materiály