MR e Azure 309: Application InsightsMR and Azure 309: Application insights


Nota

Le esercitazioni di Mixed Reality Academy sono state progettate in base a HoloLens (prima generazione) e ai visori VR immersive di realtà mista.The Mixed Reality Academy tutorials were designed with HoloLens (1st gen) and Mixed Reality Immersive Headsets in mind. Pertanto, riteniamo importante lasciarle a disposizione degli sviluppatori a cui serve ancora materiale sussidiario per lo sviluppo di questi dispositivi.As such, we feel it is important to leave these tutorials in place for developers who are still looking for guidance in developing for those devices. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2.These tutorials will not be updated with the latest toolsets or interactions being used for HoloLens 2. Rimarranno invariate per consentire di continuare a lavorare sui dispositivi supportati.They will be maintained to continue working on the supported devices. In futuro sarà disponibile una nuova serie di esercitazioni che illustrano come sviluppare per HoloLens 2.There will be a new series of tutorials that will be posted in the future that will demonstrate how to develop for HoloLens 2. Questo avviso verrà aggiornato con un collegamento a queste esercitazioni quando vengono pubblicate.This notice will be updated with a link to those tutorials when they are posted.


prodotto finale-inizio

In questo corso si apprenderà come aggiungere Application Insights funzionalità a un'applicazione di realtà mista usando l'API applicazione Azure Insights per raccogliere le analisi relative al comportamento degli utenti.In this course, you will learn how to add Application Insights capabilities to a mixed reality application, using the Azure Application Insights API to collect analytics regarding user behavior.

Application Insights è un servizio Microsoft, che consente agli sviluppatori di raccogliere le analisi dalle applicazioni e di gestirle da un portale di facile utilizzo.Application Insights is a Microsoft service, allowing developers to collect analytics from their applications and manage it from an easy-to-use portal. L'analisi può essere di qualsiasi tipo, dalle prestazioni alle informazioni personalizzate da raccogliere.The analytics can be anything from performance to custom information you would like to collect. Per ulteriori informazioni, visitare la pagina Application Insights.For more information, visit the Application Insights page.

Dopo aver completato questo corso, si disporrà di un'applicazione con un auricolare immersiva a realtà mista che sarà in grado di eseguire le operazioni seguenti:Having completed this course, you will have a mixed reality immersive headset application which will be able to do the following:

  1. Consente all'utente di guardare e spostarsi in una scena.Allow the user to gaze and move around a scene.
  2. Attivare l'invio di analisi al servizio Application Insights, tramite l'uso di sguardi e prossimità di oggetti in scena.Trigger the sending of analytics to the Application Insights Service, through the use of Gaze and Proximity to in-scene objects.
  3. L'app chiamerà anche il servizio, recuperando le informazioni sull'oggetto che è stato più o meno affrontato dall'utente nelle ultime 24 ore.The app will also call upon the Service, fetching information about which object has been approached the most by the user, within the last 24 hours. Tale oggetto cambierà il colore in verde.That object will change its color to green.

Questo corso spiegherà come ottenere i risultati dal servizio Application Insights in un'applicazione di esempio basata su Unity.This course will teach you how to get the results from the Application Insights Service, into a Unity-based sample application. Sarà necessario applicare questi concetti a un'applicazione personalizzata che è possibile creare.It will be up to you to apply these concepts to a custom application you might be building.

Supporto di dispositiviDevice support

CorsoCourse HoloLensHoloLens Visori VR immersiveImmersive headsets
MR e Azure 309: Application InsightsMR and Azure 309: Application insights ✔️✔️ ✔️✔️

Nota

Sebbene questo corso sia incentrato principalmente sugli auricolari per la realtà mista (VR) di Windows, è anche possibile applicare le informazioni apprese in questo corso a Microsoft HoloLens.While this course primarily focuses on Windows Mixed Reality immersive (VR) headsets, you can also apply what you learn in this course to Microsoft HoloLens. Seguendo le istruzioni riportate in questo corso, vengono visualizzate le note sulle eventuali modifiche che potrebbero essere necessarie per supportare HoloLens.As you follow along with the course, you will see notes on any changes you might need to employ to support HoloLens. Quando si usa HoloLens, è possibile notare alcuni echi durante l'acquisizione vocale.When using HoloLens, you may notice some echo during voice capture.

PrerequisitiPrerequisites

Nota

Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Unity e C#.This tutorial is designed for developers who have basic experience with Unity and C#. Tenere inoltre presente che i prerequisiti e le istruzioni scritte in questo documento rappresentano gli elementi testati e verificati al momento della stesura (luglio 2018).Please also be aware that the prerequisites and written instructions within this document represent what has been tested and verified at the time of writing (July 2018). È possibile utilizzare il software più recente, come indicato nell'articolo installare gli strumenti , ma non si presuppone che le informazioni in questo corso corrispondano perfettamente a quelle disponibili nel software più recente rispetto a quanto indicato di seguito.You are free to use the latest software, as listed within the install the tools article, though it should not be assumed that the information in this course will perfectly match what you will find in newer software than what is listed below.

Per questo corso è consigliabile usare i componenti hardware e software seguenti:We recommend the following hardware and software for this course:

Prima di iniziareBefore you start

Per evitare che si verifichino problemi durante la compilazione di questo progetto, è consigliabile creare il progetto indicato in questa esercitazione in una cartella radice o quasi radice (i percorsi di cartella lunghi possono causare problemi in fase di compilazione).To avoid encountering issues building this project, it is strongly suggested that you create the project mentioned in this tutorial in a root or near-root folder (long folder paths can cause issues at build-time).

Avviso

Tenere presente che i dati che passano a Application Insights richiedono tempo, quindi possono essere pazienti.Be aware, data going to Application Insights takes time, so be patient. Se si vuole controllare se il servizio ha ricevuto i dati, vedere il capitolo 14, che illustra come spostarsi nel portale.If you want to check if the Service has received your data, check out Chapter 14, which will show you how to navigate the portal.

Capitolo 1-portale di AzureChapter 1 - The Azure Portal

Per usare Application Insights, è necessario creare e configurare un servizio di Application Insights nel portale di Azure.To use Application Insights, you will need to create and configure an Application Insights Service in the Azure portal.

  1. Accedere al portale di Azure.Log in to the Azure Portal.

    Nota

    Se non si dispone già di un account Azure, sarà necessario crearne uno.If you do not already have an Azure account, you will need to create one. Se si segue questa esercitazione in una classe o in una situazione di laboratorio, rivolgersi all'insegnante o a uno dei Proctor per ottenere assistenza nella configurazione del nuovo account.If you are following this tutorial in a classroom or lab situation, ask your instructor or one of the proctors for help setting up your new account.

  2. Una volta effettuato l'accesso, fare clic su nuovo nell'angolo in alto a sinistra e cercare Application Insights e premere invio.Once you are logged in, click on New in the top left corner, and search for Application Insights, and click Enter.

    Nota

    La parola New potrebbe essere stata sostituita con Crea una risorsa, nei portali più recenti.The word New may have been replaced with Create a resource, in newer portals.

    Portale di Azure

  3. La nuova pagina a destra fornirà una descrizione del servizio applicazione Azure Insights .The new page to the right will provide a description of the Azure Application Insights Service. Nella parte inferiore sinistra della pagina selezionare il pulsante Crea per creare un'associazione con il servizio.At the bottom left of this page, select the Create button, to create an association with this Service.

    Portale di Azure

  4. Una volta fatto clic su Crea:Once you have clicked on Create:

    1. Inserire il nome desiderato per l'istanza del servizio.Insert your desired Name for this Service instance.

    2. In tipo di applicazione selezionare generale.As Application Type, select General.

    3. Selezionare una sottoscrizione appropriata.Select an appropriate Subscription.

    4. Scegliere un gruppo di risorse o crearne uno nuovo.Choose a Resource Group or create a new one. Un gruppo di risorse consente di monitorare, controllare l'accesso, effettuare il provisioning e gestire la fatturazione per una raccolta di asset di Azure.A resource group provides a way to monitor, control access, provision and manage billing for a collection of Azure assets. Si consiglia di lasciare tutti i servizi di Azure associati a un singolo progetto (ad esempio questi corsi) in un gruppo di risorse comune).It is recommended to keep all the Azure Services associated with a single project (e.g. such as these courses) under a common resource group).

      Per altre informazioni sui gruppi di risorse di Azure, vedere l'articolo relativo al gruppo di risorse.If you wish to read more about Azure Resource Groups, please visit the resource group article.

    5. Selezionare un percorso.Select a Location.

    6. Sarà inoltre necessario confermare di aver compreso i termini e le condizioni applicati a questo servizio.You will also need to confirm that you have understood the Terms and Conditions applied to this Service.

    7. Selezionare Create (Crea).Select Create.

      Portale di Azure

  5. Una volta fatto clic su Crea, sarà necessario attendere il completamento della creazione del servizio. l'operazione potrebbe richiedere un minuto.Once you have clicked on Create, you will have to wait for the Service to be created, this might take a minute.

  6. Dopo la creazione dell'istanza del servizio, verrà visualizzata una notifica nel portale.A notification will appear in the portal once the Service instance is created.

    Portale di Azure

  7. Fare clic sulle notifiche per esplorare la nuova istanza del servizio.Click on the notifications to explore your new Service instance.

    Portale di Azure

  8. Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio.Click the Go to resource button in the notification to explore your new Service instance. Si verrà portati alla nuova istanza del servizio Application Insights .You will be taken to your new Application Insights Service instance.

    Portale di Azure

    Nota

    Questa pagina Web è aperta e facile da accedere. si tornerà spesso a visualizzare i dati raccolti.Keep this web page open and easy to access, you will come back here often to see the data collected.

    Importante

    Per implementare Application Insights, sarà necessario usare tre (3) valori specifici: chiave di strumentazione, ID applicazione e chiave API.To implement Application Insights, you will need to use three (3) specific values: Instrumentation Key, Application ID, and API Key. Di seguito viene illustrato come recuperare questi valori dal servizio.Below you will see how to retrieve these values from your Service. Assicurarsi di prendere nota di questi valori in una pagina del blocco note vuota, perché saranno presto usati nel codice.Make sure to note these values on a blank Notepad page, because you will use them soon in your code.

  9. Per trovare la chiave di strumentazione, è necessario scorrere verso il basso l'elenco di funzioni del servizio e fare clic su Proprietà. la scheda visualizzata mostrerà la chiave del servizio.To find the Instrumentation Key, you will need to scroll down the list of Service functions, and click on Properties, the tab displayed will reveal the Service Key.

    Portale di Azure

  10. Di seguito sono riportate alcune Proprietà che consentono di accedere all'API, che è necessario fare clic su.A little below Properties, you will find API Access, which you need to click. Il pannello a destra fornirà l' ID applicazione dell'app.The panel to the right will provide the Application ID of your app.

    Portale di Azure

  11. Con il pannello ID applicazione ancora aperto, fare clic su Crea chiave API, che consente di aprire il pannello Crea chiave API .With the Application ID panel still open, click Create API Key, which will open the Create API key panel.

    Portale di Azure

  12. All'interno del pannello Apri chiave API crea Digitare una descrizione e quindi le tre caselle.Within the now open Create API key panel, type a description, and tick the three boxes.

  13. Fare clic su Genera chiave.Click Generate Key. La chiave API verrà creata e visualizzata.Your API Key will be created and displayed.

    Portale di Azure

    Avviso

    Questa è l'unica volta in cui verrà visualizzata la chiave del servizio , quindi assicurarsi di crearne una copia adesso.This is the only time your Service Key will be displayed, so ensure you make a copy of it now.

Capitolo 2: configurare il progetto UnityChapter 2 - Set up the Unity project

Di seguito è riportata una configurazione tipica per lo sviluppo con la realtà mista e, di conseguenza, un modello valido per altri progetti.The following is a typical set up for developing with the mixed reality, and as such, is a good template for other projects.

  1. Aprire Unity e fare clic su New.Open Unity and click New.

    Configurare il progetto Unity

  2. A questo punto è necessario specificare un nome di progetto Unity, inserire _ Azure _ Application _ Insights.You will now need to provide a Unity Project name, insert MR_Azure_Application_Insights. Verificare che il modello sia impostato su 3D.Make sure the Template is set to 3D. Impostare il percorso su un punto appropriato (ricordare che più vicino alle directory radice è migliore).Set the Location to somewhere appropriate for you (remember, closer to root directories is better). Fare quindi clic su Crea progetto.Then, click Create project.

    Configurare il progetto Unity

  3. Con Unity aperto, vale la pena controllare che l' editor di script predefinito sia impostato su Visual Studio.With Unity open, it is worth checking the default Script Editor is set to Visual Studio. Passare a modifica > Preferenze e quindi dalla nuova finestra passare a strumenti esterni.Go to Edit > Preferences and then from the new window, navigate to External Tools. Modificare l' editor di script esterno in Visual Studio 2017.Change External Script Editor to Visual Studio 2017. Chiudere la finestra delle Preferenze .Close the Preferences window.

    Configurare il progetto Unity

  4. Passare quindi a impostazioni di > compilazione file e passare alla piattaforma piattaforma UWP (Universal Windows Platform), facendo clic sul pulsante Switch Platform .Next, go to File > Build Settings and switch the platform to Universal Windows Platform, by clicking on the Switch Platform button.

    Configurare il progetto Unity

  5. Passare a > impostazioni di compilazione file e verificare che:Go to File > Build Settings and make sure that:

    1. Il dispositivo di destinazione è impostato su qualsiasi dispositivoTarget Device is set to Any device

      Per Microsoft HoloLens, impostare dispositivo di destinazione su HoloLens.For the Microsoft HoloLens, set Target Device to HoloLens.

    2. Il tipo di compilazione è impostato su D3DBuild Type is set to D3D

    3. SDK è impostato sull' ultima versione installataSDK is set to Latest installed

    4. Compilazione ed esecuzione è impostato su computer localeBuild and Run is set to Local Machine

    5. Salvare la scena e aggiungerla alla compilazione.Save the scene and add it to the build.

      1. A tale scopo, selezionare Aggiungi scene aperte.Do this by selecting Add Open Scenes. Verrà visualizzata una finestra Salva.A save window will appear.

        Configurare il progetto Unity

      2. Creare una nuova cartella per questo e qualsiasi scena futura, quindi fare clic sul pulsante nuova cartella per creare una nuova cartella, denominarla Scenes.Create a new folder for this, and any future scene, then click the New folder button, to create a new folder, name it Scenes.

        Configurare il progetto Unity

      3. Aprire la cartella Scenes appena creata e quindi nel campo nome file: testo digitare ApplicationInsightsScene e quindi fare clic su Salva.Open your newly created Scenes folder, and then in the File name: text field, type ApplicationInsightsScene, then click Save.

        Configurare il progetto Unity

  6. Le impostazioni rimanenti, nelle impostazioni di compilazione, devono essere lasciate come predefinite per il momento.The remaining settings, in Build Settings, should be left as default for now.

  7. Nella finestra impostazioni di compilazione fare clic sul pulsante Impostazioni lettore . verrà aperto il pannello correlato nello spazio in cui si trova il controllo .In the Build Settings window, click on the Player Settings button, this will open the related panel in the space where the Inspector is located.

    Configurare il progetto Unity

  8. In questo pannello è necessario verificare alcune impostazioni:In this panel, a few settings need to be verified:

    1. Nella scheda altre impostazioni :In the Other Settings tab:

      1. La versione di runtime di Scripting deve essere sperimentale (equivalente a .NET 4,6), che attiverà la necessità di riavviare l'editor.Scripting Runtime Version should be Experimental (.NET 4.6 Equivalent), which will trigger a need to restart the Editor.

      2. Il back-end di scripting deve essere .NETScripting Backend should be .NET

      3. Il livello di compatibilità API deve essere .NET 4,6API Compatibility Level should be .NET 4.6

      Configurare il progetto Unity

    2. Nella scheda impostazioni di pubblicazione , in funzionalità, selezionare:Within the Publishing Settings tab, under Capabilities, check:

      • InternetClientInternetClient

        Configurare il progetto Unity

    3. Nella parte inferiore del pannello, nelle impostazioni di XR (disponibili sotto le impostazioni di pubblicazione), verificare la realtà virtuale supportata, verificare che sia stato aggiunto Windows Mixed Reality SDK .Further down the panel, in XR Settings (found below Publishing Settings), tick Virtual Reality Supported, make sure the Windows Mixed Reality SDK is added.

      Configurare il progetto Unity

  9. Nelle impostazioni di compilazione, i progetti C# Unity non sono più disattivati; Selezionare la casella di controllo accanto a questo.Back in Build Settings, Unity C# Projects is no longer greyed out; tick the checkbox next to this.

  10. Chiudere la finestra Build Settings (Impostazioni di compilazione).Close the Build Settings window.

  11. Salva la scena e il progetto (progetto Salva > scena/ > Salva file).Save your Scene and Project (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Capitolo 3: importare il pacchetto UnityChapter 3 - Import the Unity package

Importante

Se si vuole ignorare i componenti di configurazione di Unity di questo corso e continuare direttamente con il codice, è possibile scaricare questo Azure-Mr-309. file unitypackage Toolse importarlo nel progetto come pacchetto personalizzato.If you wish to skip the Unity Set up components of this course, and continue straight into code, feel free to download this Azure-MR-309.unitypackage, import it into your project as a Custom Package. Questo conterrà anche le dll del capitolo successivo.This will also contain the DLLs from the next Chapter. Dopo l'importazione, continuare con il capitolo 6.After import, continue from Chapter 6.

Importante

Per usare Application Insights in Unity, è necessario importare la DLL, insieme alla DLL Newtonsoft.To use Application Insights within Unity, you need to import the DLL for it, along with the Newtonsoft DLL. Attualmente esiste un problema noto in Unity che richiede che i plug-in vengano riconfigurati dopo l'importazione.There is currently a known issue in Unity which requires plugins to be reconfigured after import. Questi passaggi (4-7 in questa sezione) non saranno più necessari dopo la risoluzione del bug.These steps (4 - 7 in this section) will no longer be required after the bug has been resolved.

Per importare Application Insights nel progetto, assicurarsi di aver scaricato il '. file unitypackage Tools ', contenente i plug-in.To import Application Insights into your own project, make sure you have downloaded the '.unitypackage', containing the plugins. Procedere quindi come segue:Then, do the following:

  1. Aggiungere il file unitypackage Tools a Unity usando l'opzione di menu Asset > Import Package > Custom Package .Add the .unitypackage to Unity by using the Assets > Import Package > Custom Package menu option.

  2. Nella casella Importa pacchetto Unity visualizzata verificare che siano selezionati tutti gli elementi in (e inclusi) plug -in.In the Import Unity Package box that pops up, ensure everything under (and including) Plugins is selected.

    Importare il pacchetto Unity

  3. Fare clic sul pulsante Importa per aggiungere gli elementi al progetto.Click the Import button, to add the items to your project.

  4. Passare alla cartella Insights in plug -in nella visualizzazione del progetto e selezionare solo i plug-in seguenti:Go to the Insights folder under Plugins in the Project view and select the following plugins only:

    • Microsoft.ApplicationInsightsMicrosoft.ApplicationInsights

    Importare il pacchetto Unity

  5. Con questo plug -in selezionato, verificare che qualsiasi piattaforma sia deselezionata, quindi assicurarsi che WSAPlayer sia deselezionata, quindi fare clic su applica.With this plugin selected, ensure that Any Platform is unchecked, then ensure that WSAPlayer is also unchecked, then click Apply. Questa operazione è sufficiente per confermare che i file sono configurati correttamente.Doing this is just to confirm that the files are configured correctly.

    Importare il pacchetto Unity

    Nota

    Contrassegnando i plug-in come questo, questi vengono configurati per essere usati solo nell'editor di Unity.Marking the plugins like this, configures them to only be used in the Unity Editor. Nella cartella WSA è presente un set di dll diverso che verrà usato dopo l'esportazione del progetto da Unity.There are a different set of DLLs in the WSA folder which will be used after the project is exported from Unity.

  6. Successivamente, è necessario aprire la cartella WSA , all'interno della cartella Insights .Next, you need to open the WSA folder, within the Insights folder. Viene visualizzata una copia dello stesso file appena configurato.You will see a copy of the same file you just configured. Selezionare questo file, quindi nel controllo verificare che qualsiasi piattaforma sia deselezionata, quindi assicurarsi che sia selezionato solo WSAPlayer .Select this file, and then in the inspector, ensure that Any Platform is unchecked, then ensure that only WSAPlayer is checked. Fare clic su Applica.Click Apply.

    Importare il pacchetto Unity

  7. A questo punto, è necessario seguire i passaggi 4-6, ma per i plug-in Newtonsoft .You will now need to follow steps 4-6, but for the Newtonsoft plugins instead. Vedere lo screenshot seguente per il risultato dell'aspetto.See the below screenshot for what the outcome should look like.

    Importare il pacchetto Unity

Capitolo 4: impostare la fotocamera e i controlli utenteChapter 4 - Set up the camera and user controls

In questo capitolo verrà illustrato come configurare la fotocamera e i controlli per consentire all'utente di visualizzare e spostare la scena.In this Chapter you will set up the camera and the controls to allow the user to see and move in the scene.

  1. Fare clic con il pulsante destro del mouse in un'area vuota nel pannello gerarchia e quindi su Crea > vuoto.Right-click in an empty area in the Hierarchy Panel, then on Create > Empty.

    Configurare la fotocamera e i controlli utente

  2. Rinominare il nuovo GameObject vuoto nell' elemento padre della fotocamera.Rename the new empty GameObject to Camera Parent.

    Configurare la fotocamera e i controlli utente

  3. Fare clic con il pulsante destro del mouse in un'area vuota nel pannello gerarchia, quindi su oggetto 3D, quindi su sfera.Right-click in an empty area in the Hierarchy Panel, then on 3D Object, then on Sphere.

  4. Rinominare la sfera nella parte destra.Rename the Sphere to Right Hand.

  5. Imposta la scala di trasformazione della mano destra su 0,1, 0,1, 0,1Set the Transform Scale of the Right Hand to 0.1, 0.1, 0.1

    Configurare la fotocamera e i controlli utente

  6. Rimuovere il componente Sphere Collider dalla destra facendo clic sull' ingranaggio nel componente Sphere Collider , quindi rimuovere Component.Remove the Sphere Collider component from the Right Hand by clicking on the Gear in the Sphere Collider component, and then Remove Component.

    Configurare la fotocamera e i controlli utente

  7. Nel pannello gerarchia trascinare la fotocamera principale e gli oggetti destro nell'oggetto padre della fotocamera .In the Hierarchy Panel drag the Main Camera and the Right Hand objects onto the Camera Parent object.

    Configurare la fotocamera e i controlli utente

  8. Impostare la posizione di trasformazione della fotocamera principale e dell'oggetto destro su 0, 0, 0.Set the Transform Position of both the Main Camera and the Right Hand object to 0, 0, 0.

    Configurare la fotocamera e i controlli utente

    Configurare la fotocamera e i controlli utente

Capitolo 5: configurare gli oggetti nella scena UnityChapter 5 - Set up the objects in the Unity scene

Verranno ora create alcune forme di base per la scena, con cui l'utente può interagire.You will now create some basic shapes for your scene, with which the user can interact.

  1. Fare clic con il pulsante destro del mouse in un'area vuota nel Pannello gerarchia, quindi su oggetto 3D, quindi selezionare piano.Right-click in an empty area in the Hierarchy Panel, then on 3D Object, then select Plane.

  2. Impostare la posizione di trasformazione del piano su 0,-1, 0.Set the Plane Transform Position to 0, -1, 0.

  3. Impostare scala trasformazione piano su 5, 1, 5.Set the Plane Transform Scale to 5, 1, 5.

    Configurare gli oggetti nella scena Unity

  4. Creare un materiale di base da usare con l'oggetto piano , in modo che le altre forme siano più semplici da vedere.Create a basic material to use with your Plane object, so that the other shapes are easier to see. Passare al Pannello del progetto, fare clic con il pulsante destro del mouse, quindi scegliere Crea, seguito da cartella, per creare una nuova cartella.Navigate to your Project Panel, right-click, then Create, followed by Folder, to create a new folder. Assegnare un nome ai materiali.Name it Materials.

    Configurare gli oggetti nella scena Unity Configurare gli oggetti nella scena Unity

  5. Aprire la cartella Materials , quindi fare clic con il pulsante destro del mouse, scegliere Crea, quindi Material, per creare un nuovo materiale.Open the Materials folder, then right-click, click Create, then Material, to create a new material. Denominarlo blu.Name it Blue.

    Configurare gli oggetti nella scena Unity Configurare gli oggetti nella scena Unity

  6. Con il nuovo materiale blu selezionato, esaminare il controllo e fare clic sulla finestra rettangolare accanto a albedo.With the new Blue material selected, look at the Inspector, and click the rectangular window alongside Albedo. Selezionare un colore blu (l'immagine seguente è il colore esadecimale: # 3592FFFF).Select a blue color (the one picture below is Hex Color: #3592FFFF). Una volta scelto, fare clic sul pulsante Chiudi.Click the close button once you have chosen.

    Configurare gli oggetti nella scena Unity

  7. Trascinare il nuovo materiale dalla cartella Materials , nel piano appena creato, all'interno della scena o rilasciarlo sull'oggetto piano all'interno della gerarchia.Drag your new material from the Materials folder, onto your newly created Plane, within your scene (or drop it on the Plane object within the Hierarchy).

    Configurare gli oggetti nella scena Unity

  8. Fare clic con il pulsante destro del mouse in un'area vuota nel Pannello gerarchia, quindi su oggetto 3D, capsula.Right-click in an empty area in the Hierarchy Panel, then on 3D Object, Capsule.

    • Con la capsula selezionata, modificare la posizione di trasformazione in: -10, 1, 0.With the Capsule selected, change its Transform Position to: -10, 1, 0.
  9. Fare clic con il pulsante destro del mouse in un'area vuota nel Pannello gerarchia, quindi su oggetto 3D, cubo.Right-click in an empty area in the Hierarchy Panel, then on 3D Object, Cube.

    • Con il cubo selezionato, modificare la posizione di trasformazione in: 0, 0, 10.With the Cube selected, change its Transform Position to: 0, 0, 10.
  10. Fare clic con il pulsante destro del mouse in un'area vuota nel Pannello gerarchia, quindi su oggetto 3D, sfera.Right-click in an empty area in the Hierarchy Panel, then on 3D Object, Sphere.

    • Con la sfera selezionata, modificare la posizione di trasformazione in: 10, 0, 0.With the Sphere selected, change its Transform Position to: 10, 0, 0.

    Configurare gli oggetti nella scena Unity

    Nota

    Questi valori di posizione sono suggerimenti.These Position values are suggestions. È possibile impostare le posizioni degli oggetti su quello che si desidera, sebbene sia più semplice per l'utente dell'applicazione se le distanze degli oggetti non sono troppo distanti dalla fotocamera.You are free to set the positions of the objects to whatever you would like, though it is easier for the user of the application if the objects distances are not too far from the camera.

  11. Quando l'applicazione è in esecuzione, deve essere in grado di identificare gli oggetti all'interno della scena, a tale scopo è necessario contrassegnarli.When your application is running, it needs to be able to identify the objects within the scene, to achieve this, they need to be tagged. Selezionare uno degli oggetti e nel pannello di controllo fare clic su Aggiungi tag..., che consente di scambiare il controllo con il pannello tag & livelli .Select one of the objects, and in the Inspector panel, click Add Tag..., which will swap the Inspector with the Tags & Layers panel.

    Configurare gli oggetti nella scena Unity Set up the objects in the Unity Scene

  12. Fare clic sul simbolo + (segno più) , quindi digitare il nome del tag come ObjectInScene.Click the + (plus) symbol, then type the tag name as ObjectInScene.

    Configurare gli oggetti nella scena Unity

    Avviso

    Se si usa un nome diverso per il tag, è necessario assicurarsi che questa modifica sia anche DataFromAnalytics, ObjectTrigger e sguardi, script in un secondo momento, in modo che gli oggetti vengano trovati e rilevati all'interno della scena.If you use a different name for your tag, you will need to ensure this change is also made the DataFromAnalytics, ObjectTrigger, and Gaze, scripts later, so that your objects are found, and detected, within your scene.

  13. Con il tag creato, è ora necessario applicarlo a tutti e tre gli oggetti.With the tag created, you now need to apply it to all three of your objects. Dalla gerarchia tenere premuto il tasto MAIUSC , quindi fare clic su capsula, cubo e sfera, oggetti, quindi, nel controllo, fare clic sul menu a discesa insieme a tag, quindi fare clic sul tag ObjectInScene creato.From the Hierarchy, hold the Shift key, then click the Capsule, Cube, and Sphere, objects, then in the Inspector, click the dropdown menu alongside Tag, then click the ObjectInScene tag you created.

    Configurare gli oggetti nella scena Unity Set up the objects in the Unity Scene

Capitolo 6: creare la classe ApplicationInsightsTrackerChapter 6 - Create the ApplicationInsightsTracker class

Il primo script che è necessario creare è ApplicationInsightsTracker, responsabile di:The first script you need to create is ApplicationInsightsTracker, which is responsible for:

  1. Creazione di eventi in base alle interazioni dell'utente da inviare ad applicazione Azure Insights.Creating events based on user interactions to submit to Azure Application Insights.

  2. Creazione di nomi di evento appropriati, a seconda dell'interazione dell'utente.Creating appropriate Event names, depending on user interaction.

  3. Invio di eventi all'istanza del servizio Application Insights.Submitting events to the Application Insights Service instance.

Per creare questa classe:To create this class:

  1. Fare clic con il pulsante destro del mouse sul Pannello del progetto, quindi scegliere Crea > cartella.Right-click in the Project Panel, then Create > Folder. Denominare gli script della cartella.Name the folder Scripts.

    Creazione della classe ApplicationInsightsTracker Creazione della classe ApplicationInsightsTracker

  2. Con la cartella Scripts creata, fare doppio clic su di essa per aprirla.With the Scripts folder created, double-click it, to open. Quindi, all'interno di tale cartella, fare clic con il pulsante destro del mouse su Crea > script C#.Then, within that folder, right-click, Create > C# Script. Denominare lo script ApplicationInsightsTracker.Name the script ApplicationInsightsTracker.

  3. Fare doppio clic sul nuovo script ApplicationInsightsTracker per aprirlo con Visual Studio.Double-click on the new ApplicationInsightsTracker script to open it with Visual Studio.

  4. Aggiornare gli spazi dei nomi nella parte superiore dello script come indicato di seguito:Update namespaces at the top of the script to be as below:

        using Microsoft.ApplicationInsights;
        using Microsoft.ApplicationInsights.DataContracts;
        using Microsoft.ApplicationInsights.Extensibility;
        using UnityEngine;
    
  5. All'interno della classe inserire le variabili seguenti:Inside the class insert the following variables:

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

    Nota

    Impostare i valori instrumentationKey, ApplicationId e API_Key in modo appropriato, usando le chiavi del servizio dal portale di Azure, come indicato nel capitolo 1, passaggio 9 e versioni successive.Set the instrumentationKey, applicationId and API_Key values appropriately, using the Service Keys from the Azure Portal as mentioned in Chapter 1, step 9 onwards.

  6. Aggiungere quindi i metodi Start () e svegli () , che verranno chiamati al momento dell'inizializzazione della classe:Then add the Start() and Awake() methods, which will be called when the class initializes:

        /// <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. Aggiungere i metodi responsabili dell'invio degli eventi e delle metriche registrati dall'applicazione:Add the methods responsible for sending the events and metrics registered by your application:

        /// <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. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.Be sure to save your changes in Visual Studio before returning to Unity.

Capitolo 7: creare lo script di sguardiChapter 7 - Create the Gaze script

Lo script successivo da creare è lo sguardo .The next script to create is the Gaze script. Questo script è responsabile della creazione di un Raycast che verrà proiettato in futuro dalla fotocamera principale, per individuare l'oggetto analizzato dall'utente.This script is responsible for creating a Raycast that will be projected forward from the Main Camera, to detect which object the user is looking at. In questo caso, Raycast deve identificare se l'utente sta esaminando un oggetto con il tag ObjectInScene , quindi contare il tempo che l'utente guarda a tale oggetto.In this case, the Raycast will need to identify if the user is looking at an object with the ObjectInScene tag, and then count how long the user gazes at that object.

  1. Fare doppio clic sulla cartella Scripts per aprirla.Double-click on the Scripts folder, to open it.

  2. Fare clic con il pulsante destro del mouse nella cartella Scripts , quindi scegliere Crea > script C#.Right-click inside the Scripts folder, click Create > C# Script. Denominare lo script.Name the script Gaze.

  3. Fare doppio clic sullo script per aprirlo con Visual Studio.Double-click on the script to open it with Visual Studio.

  4. Sostituire il codice esistente con quello seguente:Replace the existing code with the following:

        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. È ora necessario aggiungere il codice per i metodi svegli () e Start () .Code for the Awake() and Start() methods now needs to be added.

        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. All'interno della classe sguardi aggiungere il codice seguente nel metodo Update () per proiettare un Raycast e rilevare il raggiungimento della destinazione:Inside the Gaze class, add the following code in the Update() method to project a Raycast and detect the target hit:

        /// <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. Aggiungere il metodo ResetFocusedObject () per inviare dati a Application Insights quando l'utente ha esaminato un oggetto.Add the ResetFocusedObject() method, to send data to Application Insights when the user has looked at an object.

        /// <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. Lo script di sguardi è stato completato.You have now completed the Gaze script. Salvare le modifiche in Visual Studio prima di tornare a Unity.Save your changes in Visual Studio before returning to Unity.

Capitolo 8: creare la classe ObjectTriggerChapter 8 - Create the ObjectTrigger class

Lo script successivo che è necessario creare è ObjectTrigger, responsabile di:The next script you need to create is ObjectTrigger, which is responsible for:

  • Aggiunta di componenti necessari per la collisione alla fotocamera principale.Adding components needed for collision to the Main Camera.
  • Rilevamento della presenza della fotocamera vicino a un oggetto contrassegnato come ObjectInScene.Detecting if the camera is near an object tagged as ObjectInScene.

Per creare lo script:To create the script:

  1. Fare doppio clic sulla cartella Scripts per aprirla.Double-click on the Scripts folder, to open it.

  2. Fare clic con il pulsante destro del mouse nella cartella Scripts , quindi scegliere Crea > script C#.Right-click inside the Scripts folder, click Create > C# Script. Denominare lo script ObjectTrigger.Name the script ObjectTrigger.

  3. Fare doppio clic sullo script per aprirlo con Visual Studio.Double-click on the script to open it with Visual Studio. Sostituire il codice esistente con quello seguente:Replace the existing code with the following:

        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. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.Be sure to save your changes in Visual Studio before returning to Unity.

Capitolo 9: creare la classe DataFromAnalyticsChapter 9 - Create the DataFromAnalytics class

A questo punto sarà necessario creare lo script DataFromAnalytics , responsabile di:You will now need to create the DataFromAnalytics script, which is responsible for:

  • Recupero dei dati di analisi sull'oggetto che è stato più utilizzato dalla fotocamera.Fetching analytics data about which object has been approached by the camera the most.
  • Usando le chiavi del servizio, che consentono la comunicazione con l'istanza del servizio applicazione Azure Insights.Using the Service Keys, that allow communication with your Azure Application Insights Service instance.
  • Ordinamento degli oggetti in scena, in base al quale ha il numero massimo di eventi.Sorting the objects in scene, according to which has the highest event count.
  • Modifica del colore del materiale, dell'oggetto più affrontato, in verde.Changing the material color, of the most approached object, to green.

Per creare lo script:To create the script:

  1. Fare doppio clic sulla cartella Scripts per aprirla.Double-click on the Scripts folder, to open it.

  2. Fare clic con il pulsante destro del mouse nella cartella Scripts , quindi scegliere Crea > script C#.Right-click inside the Scripts folder, click Create > C# Script. Denominare lo script DataFromAnalytics.Name the script DataFromAnalytics.

  3. Fare doppio clic sullo script per aprirlo con Visual Studio.Double-click on the script to open it with Visual Studio.

  4. Inserire gli spazi dei nomi seguenti:Insert the following namespaces:

        using Newtonsoft.Json;
        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.Linq;
        using UnityEngine;
        using UnityEngine.Networking;
    
  5. All'interno dello script, inserire quanto segue:Inside the script, insert the following:

        /// <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. All'interno della classe DataFromAnalytics , subito dopo il metodo Start () , aggiungere il metodo seguente denominato FetchAnalytics ().Within the DataFromAnalytics class, right after the Start() method, add the following method called FetchAnalytics(). Questo metodo è responsabile del popolamento dell'elenco di coppie chiave-valore, con GameObject e un numero di conteggio eventi segnaposto.This method is responsible for populating the list of key value pairs, with a GameObject and a placeholder event count number. Inizializza quindi la coroutine GetWebRequest () .It then initializes the GetWebRequest() coroutine. La struttura di query della chiamata a Application Insights è disponibile anche all'interno di questo metodo, come endpoint dell' URL della query .The query structure of the call to Application Insights can be found within this method also, as the Query URL endpoint.

        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. Al di sotto del metodo FetchAnalytics () aggiungere un metodo denominato GetWebRequest () che restituisce un IEnumerator.Right below the FetchAnalytics() method, add a method called GetWebRequest(), which returns an IEnumerator. Questo metodo è responsabile della richiesta del numero di volte in cui un evento, corrispondente a un GameObject specifico, è stato chiamato all'interno Application Insights.This method is responsible for requesting the number of times an event, corresponding with a specific GameObject, has been called within Application Insights. Quando tutte le query inviate sono state restituite, viene chiamato il metodo DetermineWinner () .When all the sent queries have returned, the DetermineWinner() method is called.

        /// <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. Il metodo successivo è DetermineWinner (), che ordina l'elenco di coppie GameObject e int , in base al numero massimo di eventi.The next method is DetermineWinner(), which sorts the list of GameObject and Int pairs, according to the highest event count. Il colore del materiale di tale GameObject viene quindi modificato in verde (come feedback per il numero più alto).It then changes the material color of that GameObject to green (as feedback for it having the highest count). Viene visualizzato un messaggio con i risultati dell'analisi.This displays a message with the analytics results.

        /// <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. Aggiungere la struttura della classe che verrà usata per deserializzare l'oggetto JSON, ricevuto da Application Insights.Add the class structure which will be used to deserialize the JSON object, received from Application Insights. Aggiungere queste classi nella parte inferiore del file della classe DataFromAnalytics , al di fuori della definizione della classe.Add these classes at the very bottom of your DataFromAnalytics class file, outside of the class definition.

        /// <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. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.Be sure to save your changes in Visual Studio before returning to Unity.

Capitolo 10: creare la classe MovementChapter 10 - Create the Movement class

Lo script di spostamento è lo script successivo che sarà necessario creare.The Movement script is the next script you will need to create. È responsabile di:It is responsible for:

  • Lo sposti della fotocamera principale in base alla direzione che la fotocamera sta cercando.Moving the Main Camera according to the direction the camera is looking towards.
  • Aggiunta di tutti gli altri script agli oggetti scena.Adding all other scripts to scene objects.

Per creare lo script:To create the script:

  1. Fare doppio clic sulla cartella Scripts per aprirla.Double-click on the Scripts folder, to open it.

  2. Fare clic con il pulsante destro del mouse nella cartella Scripts , quindi scegliere Crea > script C#.Right-click inside the Scripts folder, click Create > C# Script. Assegnare un nome allo spostamento dello script.Name the script Movement.

  3. Fare doppio clic sullo script per aprirlo con Visual Studio.Double-click on the script to open it with Visual Studio.

  4. Sostituire il codice esistente con quello seguente:Replace the existing code with the following:

        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. All'interno della classe Movement , sotto il metodo Update () vuoto, inserire i metodi seguenti che consentono all'utente di usare il controller della mano per spostarsi nello spazio virtuale:Within the Movement class, below the empty Update() method, insert the following methods that allow the user to use the hand controller to move in the virtual space:

        /// <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. Aggiungere infine la chiamata al metodo all'interno del metodo Update () .Lastly add the method call within the Update() method.

        // Update is called once per frame
        void Update()
        {
            UpdateControllerState();
        }
    
  7. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.Be sure to save your changes in Visual Studio before returning to Unity.

Capitolo 11-Configurazione dei riferimenti agli scriptChapter 11 - Setting up the scripts references

In questo capitolo è necessario inserire lo script di spostamento sull' elemento padre della fotocamera e impostare le relative destinazioni di riferimento.In this Chapter you need to place the Movement script onto the Camera Parent and set its reference targets. Tale script gestirà quindi l'inserimento degli altri script in cui devono essere.That script will then handle placing the other scripts where they need to be.

  1. Dalla cartella Scripts nel Pannello Project trascinare lo script Movement nell'oggetto padre della fotocamera , che si trova nel Pannello gerarchia.From the Scripts folder in the Project Panel, drag the Movement script to the Camera Parent object, located in the Hierarchy Panel.

    Configurazione dei riferimenti agli script nella scena Unity

  2. Fare clic sull' elemento padre della fotocamera.Click on the Camera Parent. Nel Pannello gerarchia trascinare l'oggetto destro dal Pannello gerarchia alla destinazione di riferimento, controller, nel Pannello di controllo.In the Hierarchy Panel, drag the Right Hand object from the Hierarchy Panel to the reference target, Controller, in the Inspector Panel. Impostare la velocità utente su 5, come illustrato nell'immagine seguente.Set the User Speed to 5, as shown in the image below.

    Configurazione dei riferimenti agli script nella scena Unity

Capitolo 12: creare il progetto UnityChapter 12 - Build the Unity project

Tutti gli elementi necessari per la sezione Unity di questo progetto sono stati completati, quindi è giunto il momento di compilarli da Unity.Everything needed for the Unity section of this project has now been completed, so it is time to build it from Unity.

  1. Passare a impostazioni di compilazione( > impostazioni di compilazione file).Navigate to Build Settings, (File > Build Settings).

  2. Nella finestra impostazioni di compilazione fare clic su Compila.From the Build Settings window, click Build.

    Compilare il progetto Unity per la soluzione UWP

  3. Verrà visualizzata una finestra di Esplora file con la richiesta di un percorso per la compilazione.A File Explorer window will pop-up, prompting you for a location for the build. Creare una nuova cartella (facendo clic su nuova cartella nell'angolo superiore sinistro) e denominarla compilata.Create a new folder (by clicking New Folder in the top-left corner), and name it BUILDS.

    Compilare il progetto Unity per la soluzione UWP

    1. Aprire la nuova cartella compilazioni e creare un'altra cartella (usando una nuova cartella ancora una volta) e denominarla _ Azure _ Application _ Insights.Open the new BUILDS folder, and create another folder (using New Folder once more), and name it MR_Azure_Application_Insights.

      Compilare il progetto Unity per la soluzione UWP

    2. Con la cartella di _ Azure _ Application _ Insights selezionata, fare clic su Seleziona cartella.With the MR_Azure_Application_Insights folder selected, click Select Folder. La compilazione del progetto verrà eseguita per un minuto.The project will take a minute or so to build.

  4. Nella compilazione seguente verrà visualizzato Esplora file che indica il percorso del nuovo progetto.Following Build, File Explorer will appear showing you the location of your new project.

Capitolo 13: distribuire MR_Azure_Application_Insights app nel computerChapter 13 - Deploy MR_Azure_Application_Insights app to your machine

Per distribuire l' app _ _ Application _ Insights di Azure nel computer locale:To deploy the MR_Azure_Application_Insights app on your Local Machine:

  1. Aprire il file di soluzione dell' app _ Azure _ Application _ Insights in Visual Studio.Open the solution file of your MR_Azure_Application_Insights app in Visual Studio.

  2. Nella piattaforma soluzione selezionare x86, computer locale.In the Solution Platform, select x86, Local Machine.

  3. Nella configurazione della soluzione selezionare debug.In the Solution Configuration select Debug.

    Compilare il progetto Unity per la soluzione UWP

  4. Passare al menu Compila e fare clic su Distribuisci soluzione per sideload l'applicazione al computer.Go to Build menu and click on Deploy Solution to sideload the application to your machine.

  5. L'app verrà visualizzata nell'elenco delle app installate, pronte per l'avvio.Your app should now appear in the list of installed apps, ready to be launched.

  6. Avviare l'applicazione di realtà mista.Launch the mixed reality application.

  7. Spostarsi nella scena, avvicinarsi agli oggetti e esaminarli, quando il servizio Azure Insight ha raccolto un numero sufficiente di dati degli eventi, imposta l'oggetto che è stato avvicinato al più verde.Move around the scene, approaching objects and looking at them, when the Azure Insight Service has collected enough event data, it will set the object that has been approached the most to green.

Importante

Il tempo medio di attesa per la raccolta di eventi e metriche da parte del servizio richiede circa 15 minuti, in alcune occasioni potrebbe richiedere fino a 1 ora.While the average waiting time for the Events and Metrics to be collected by the Service takes around 15 min, in some occasions it might take up to 1 hour.

Capitolo 14-portale del servizio Application InsightsChapter 14 - The Application Insights Service portal

Dopo aver eseguito il roaming nella scena e aver guardato diversi oggetti, è possibile visualizzare i dati raccolti nel portale del servizio Application Insights .Once you have roamed around the scene and gazed at several objects you can see the data collected in the Application Insights Service portal.

  1. Tornare al portale del servizio Application Insights.Go back to your Application Insights Service portal.

  2. Fare clic su Esplora metriche.Click on Metrics Explorer.

    Esaminare i dati raccolti

  3. Verrà aperto in una scheda contenente il grafico che rappresenta gli eventi e le metriche correlate all'applicazione.It will open in a tab containing the graph which represent the Events and Metrics related to your application. Come indicato in precedenza, la visualizzazione dei dati nel grafico potrebbe richiedere del tempo (fino a un'ora)As mentioned above, it might take some time (up to 1 hour) for the data to be displayed in the graph

    Esaminare i dati raccolti

  4. Fare clic sulla barra degli eventi nel totale degli eventi in base alla versione dell'applicazione per visualizzare una suddivisione dettagliata degli eventi con i relativi nomi.Click on the Events bar in the Total of Events by Application Version, to see a detailed breakdown of the events with their names.

    Esaminare i dati raccolti

L'applicazione di servizio Application Insights completataYour finished your Application Insights Service application

Congratulazioni, è stata creata un'app per realtà mista che sfrutta il servizio Application Insights per monitorare l'attività dell'utente all'interno dell'app.Congratulations, you built a mixed reality app that leverages the Application Insights Service to monitor user's activity within your app.

risultato del corso

Esercizi bonusBonus Exercises

Esercizio 1Exercise 1

Provare a generare, anziché creare manualmente gli oggetti ObjectInScene e impostare le rispettive coordinate sul piano all'interno degli script.Try spawning, rather than manually creating, the ObjectInScene objects and set their coordinates on the plane within your scripts. In questo modo, è possibile richiedere ad Azure l'oggetto più diffuso (da uno sguardo o risultati di prossimità) e generare un altro oggetto.In this way, you could ask Azure what the most popular object was (either from gaze or proximity results) and spawn an extra one of those objects.

Esercizio 2Exercise 2

Ordinare i risultati del Application Insights in base all'ora, in modo da ottenere i dati più rilevanti e implementare tali dati sensibili all'ora nell'applicazione.Sort your Application Insights results by time, so that you get the most relevant data, and implement that time sensitive data in your application.