HoloLens (prima generazione) e Azure 312: Integrazione di Bot

Nota

Le esercitazioni di Mixed Reality Academy sono state progettate in base a HoloLens (prima generazione) e ai visori VR immersive di realtà mista. Pertanto, riteniamo importante lasciarle a disposizione degli sviluppatori a cui serve ancora materiale sussidiario per lo sviluppo di questi dispositivi. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Rimarranno invariate per consentire di continuare a lavorare sui dispositivi supportati. Saranno disponibili nuove serie di esercitazioni che verranno pubblicate in futuro che mostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali esercitazioni quando vengono pubblicati.

In questo corso si apprenderà come creare e distribuire un bot usando il Microsoft Bot Framework V4 e comunicare con esso tramite un'applicazione Windows Mixed Reality.

Screenshot that shows communication through a Windows Mixed Reality application.

Il Microsoft Bot Framework V4 è un set di API progettate per fornire agli sviluppatori gli strumenti per creare un'applicazione bot estendibile e scalabile. Per altre informazioni, visitare la pagina Microsoft Bot Framework o il repository Git V4.

Dopo aver completato questo corso, si avrà creato un'applicazione Windows Mixed Reality, che sarà in grado di eseguire le operazioni seguenti:

  1. Usare un movimento di tocco per avviare il bot in ascolto per la voce degli utenti.
  2. Quando l'utente ha detto qualcosa, il bot tenterà di fornire una risposta.
  3. Visualizzare le risposte dei bot come testo, posizionate vicino al bot, nella scena unity.

Nell'applicazione è possibile integrare i risultati con la progettazione. Questo corso è progettato per insegnare come integrare un servizio di Azure con il progetto Unity. È il tuo lavoro per usare le conoscenze acquisite da questo corso per migliorare l'applicazione di realtà mista.

Supporto di dispositivi

Corso HoloLens Visori VR immersive
MR e Azure 312: Integrazione di bot ✔️ ✔️

Nota

Anche se questo corso si concentra principalmente su HoloLens, è anche possibile applicare ciò che si impara in questo corso per Windows Mixed Reality visori VR (Immersive). Poiché i visori vr (VR) immersivi non dispongono di fotocamere accessibili, sarà necessaria una fotocamera esterna connessa al PC. Mentre segui il corso, vedrai le note su eventuali modifiche che potresti dover usare per supportare visori VR immersivi.

Prerequisiti

Nota

Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Unity e C#. Tenere presente anche che i prerequisiti e le istruzioni scritte all'interno di questo documento rappresentano ciò che è stato testato e verificato al momento della scrittura (luglio 2018). Si è liberi di usare il software più recente, come elencato all'interno dell'articolo degli strumenti di installazione , anche se non dovrebbe essere considerato che le informazioni in questo corso corrisponderanno perfettamente a ciò che troverete nel software più recente rispetto a quello elencato di seguito.

Per questo corso è consigliabile usare l'hardware e il software seguenti:

Prima di iniziare

  1. Per evitare problemi durante la compilazione di questo progetto, è consigliabile creare il progetto menzionato in questa esercitazione in una cartella radice o quasi radice (i percorsi di cartelle lunghe possono causare problemi in fase di compilazione).
  2. Configurare e testare la HoloLens. Se è necessario supportare la configurazione del HoloLens, assicurarsi di visitare l'articolo HoloLens configurazione.
  3. È consigliabile eseguire l'ottimizzazione della calibrazione e del sensore quando si inizia a sviluppare una nuova app HoloLens (a volte può aiutare a eseguire queste attività per ogni utente).

Per informazioni sulla calibrazione, seguire questo collegamento all'articolo HoloLens Calibrazione.

Per informazioni sull'ottimizzazione del sensore, seguire questo collegamento all'articolo Ottimizzazione del sensore HoloLens.

Capitolo 1 : Creare l'applicazione Bot

Il primo passaggio consiste nel creare il bot come applicazione Web ASP.Net Core locale. Al termine e testato, verrà pubblicato nel portale di Azure.

  1. Aprire Visual Studio. Creare un nuovo progetto, selezionare Applicazione Web ASP NET Core come tipo di progetto (verrà trovato nella sottosezione .NET Core) e chiamarlo MyBot. Fare clic su OK.

  2. Nella finestra visualizzata selezionare Vuoto. Assicurarsi inoltre che la destinazione sia impostata su ASP NET Core 2.0 e l'autenticazione sia impostata su Nessuna autenticazione. Fare clic su OK.

    Screenshot that shows the New A S P dot N E T Core Web Application window.

  3. La soluzione verrà aperta. Fare clic con il pulsante destro del mouse su Solution Mybot nella Esplora soluzioni e fare clic su Gestisci pacchetti NuGet per la soluzione.

    Screenshot that shows the opened solution with 'MyBot' and 'Manage NuGet Packages for Solution' highlighted.

  4. Nella scheda Sfoglia cercare Microsoft.Bot.Builder.Integration.AspNet.Core (assicurarsi di aver verificato la versione non rilasciata ). Selezionare la versione del pacchetto 4.0.1-preview e selezionare le caselle di progetto. Fare quindi clic su Installa. Sono state ora installate le librerie necessarie per Bot Framework v4. Chiudere la pagina NuGet.

    Screenshot that shows the Nu-Get Solution manager.

  5. Fare clic con il pulsante destro del mouse sul Project, MyBot, nella Esplora soluzioni e fare clic su Aggiungi|classe.

    Screenshot that shows the process to add a new class to MyBot.

  6. Assegnare un nome alla classe MyBot e fare clic su Aggiungi.

    Screenshot that shows the new class creation 'MyBot'.

  7. Ripetere il punto precedente per creare un'altra classe denominata ConversationContext.

  8. Fare clic con il pulsante destro del mouse su wwwroot nella Esplora soluzioni e fare clic su Aggiungi|nuovo elemento. Selezionare Pagina HTML (la si troverà nella sottosezione Web). Assegnare al file default.html. Fare clic su Aggiungi.

    Screenshot that shows the creation of a new H T M L page from within the Solution Explorer window.

  9. L'elenco di classi/oggetti nella Esplora soluzioni dovrebbe essere simile all'immagine seguente.

    Screenshot of the Solution Explorer window with list of classes.

  10. Fare doppio clic sulla classe ConversationContext . Questa classe è responsabile della conservazione delle variabili usate dal bot per mantenere il contesto della conversazione. Questi valori di contesto della conversazione vengono mantenuti in un'istanza di questa classe, perché qualsiasi istanza della classe MyBot verrà aggiornata ogni volta che viene ricevuta un'attività. Aggiungere il codice seguente alla classe:

    namespace MyBot
    {
        public static class ConversationContext
        {
            internal static string userName;
    
            internal static string userMsg;
        }
    }
    
  11. Fare doppio clic sulla classe MyBot . Questa classe ospiterà i gestori chiamati da qualsiasi attività in ingresso dal cliente. In questa classe si aggiungerà il codice usato per compilare la conversazione tra il bot e il cliente. Come accennato in precedenza, viene inizializzata un'istanza di questa classe ogni volta che viene ricevuta un'attività. Aggiungere il codice seguente a questa classe:

    using Microsoft.Bot;
    using Microsoft.Bot.Builder;
    using Microsoft.Bot.Schema;
    using System.Threading.Tasks;
    
    namespace MyBot
    {
        public class MyBot : IBot
        {       
            public async Task OnTurn(ITurnContext context)
            {
                ConversationContext.userMsg = context.Activity.Text;
    
                if (context.Activity.Type is ActivityTypes.Message)
                {
                    if (string.IsNullOrEmpty(ConversationContext.userName))
                    {
                        ConversationContext.userName = ConversationContext.userMsg;
                        await context.SendActivity($"Hello {ConversationContext.userName}. Looks like today it is going to rain. \nLuckily I have umbrellas and waterproof jackets to sell!");
                    }
                    else
                    {
                        if (ConversationContext.userMsg.Contains("how much"))
                        {
                            if (ConversationContext.userMsg.Contains("umbrella")) await context.SendActivity($"Umbrellas are $13.");
                            else if (ConversationContext.userMsg.Contains("jacket")) await context.SendActivity($"Waterproof jackets are $30.");
                            else await context.SendActivity($"Umbrellas are $13. \nWaterproof jackets are $30.");
                        }
                        else if (ConversationContext.userMsg.Contains("color") || ConversationContext.userMsg.Contains("colour"))
                        {
                            await context.SendActivity($"Umbrellas are black. \nWaterproof jackets are yellow.");
                        }
                        else
                        {
                            await context.SendActivity($"Sorry {ConversationContext.userName}. I did not understand the question");
                        }
                    }
                }
                else
                {
    
                    ConversationContext.userMsg = string.Empty;
                    ConversationContext.userName = string.Empty;
                    await context.SendActivity($"Welcome! \nI am the Weather Shop Bot \nWhat is your name?");
                }
    
            }
        }
    }
    
  12. Fare doppio clic sulla classe Startup . Questa classe inizializzerà il bot. Aggiungere il codice seguente alla classe:

    using Microsoft.AspNetCore.Builder;
    using Microsoft.AspNetCore.Hosting;
    using Microsoft.Bot.Builder.BotFramework;
    using Microsoft.Bot.Builder.Integration.AspNet.Core;
    using Microsoft.Extensions.Configuration;
    using Microsoft.Extensions.DependencyInjection;
    
    namespace MyBot
    {
    public class Startup
        {
            public IConfiguration Configuration { get; }
    
            public Startup(IHostingEnvironment env)
            {
                var builder = new ConfigurationBuilder()
                    .SetBasePath(env.ContentRootPath)
                    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                    .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                    .AddEnvironmentVariables();
                Configuration = builder.Build();
            }
    
            // This method gets called by the runtime. Use this method to add services to the container.
            public void ConfigureServices(IServiceCollection services)
            {
                services.AddSingleton(_ => Configuration);
                services.AddBot<MyBot>(options =>
                {
                    options.CredentialProvider = new ConfigurationCredentialProvider(Configuration);
                });
            }
    
            // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
            public void Configure(IApplicationBuilder app, IHostingEnvironment env)
            {
                if (env.IsDevelopment())
                {
                    app.UseDeveloperExceptionPage();
                }
    
                app.UseDefaultFiles();
                app.UseStaticFiles();
                app.UseBotFramework();
            }
        }
    }
    
  13. Aprire il file di classe Program e verificare che il codice sia uguale al seguente:

    using Microsoft.AspNetCore;
    using Microsoft.AspNetCore.Hosting;
    
    namespace MyBot
    {
        public class Program
        {
            public static void Main(string[] args)
            {
                BuildWebHost(args).Run();
            }
    
            public static IWebHost BuildWebHost(string[] args) =>
                WebHost.CreateDefaultBuilder(args)
                    .UseStartup<Startup>()
                    .Build();
        }
    }
    
  14. Ricordarsi di salvare le modifiche, a tale scopo, passare a Salva>tutto, dalla barra degli strumenti nella parte superiore di Visual Studio.

Capitolo 2 - Creare l'servizio Bot di Azure

Dopo aver creato il codice per il bot, è necessario pubblicarlo in un'istanza del servizio Bot app Web nel portale di Azure. Questo capitolo illustra come creare e configurare l'servizio Bot in Azure e quindi pubblicarne il codice.

  1. Per prima cosa, accedere al portale di Azure (https://portal.azure.com).

    1. Se non si dispone già di un account Azure, sarà necessario crearne uno. Se si segue questa esercitazione in una classe o in una situazione del lab, chiedere all'insegnante o a uno dei proctor di configurare il nuovo account.
  2. Dopo aver eseguito l'accesso, fare clic su Crea una risorsa nell'angolo superiore sinistro e cercare bot app Web e fare clic su Invio.

    Screenshot of the Microsoft Azure dashboard with 'Create a resource' highlighted in the upper left.

  3. La nuova pagina fornisce una descrizione del servizio Bot app Web . Nella parte inferiore sinistra di questa pagina selezionare il pulsante Crea per creare un'associazione con questo servizio.

    Screenshot of the Web App Bot page and the 'Create' button in the bottom left.

  4. Dopo aver fatto clic su Crea:

    1. Inserire il nome desiderato per questa istanza del servizio.

    2. Selezionare una Sottoscrizione.

    3. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, il provisioning e gestire la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio questi corsi) in un gruppo di risorse comune.

      Per altre informazioni sui gruppi di risorse di Azure, seguire questo collegamento

    4. Determinare la posizione per il gruppo di risorse ( se si sta creando un nuovo gruppo di risorse). La posizione si trova idealmente nell'area in cui l'applicazione verrà eseguita. Alcuni asset di Azure sono disponibili solo in determinate aree.

    5. Selezionare il piano tariffario appropriato per l'utente, se si tratta della prima volta che si crea un servizio Bot app Web , è necessario che sia disponibile un livello gratuito (denominato F0)

    6. Il nome dell'app può essere appena lasciato uguale al nome del bot.

    7. Lasciare il modello bot come Basic (C#).

    8. Il piano di servizio app/Posizione deve essere stato compilato automaticamente per l'account.

    9. Impostare l'Archiviazione di Azure da usare per ospitare il bot. Se non ne hai già uno, puoi crearlo qui.

    10. Dovrai anche confermare che hai capito le Condizioni e le condizioni applicate al servizio.

    11. Fare clic su Crea.

      Screenshot that shows the required fields needed to create the new Service.

  5. Dopo aver fatto clic su Crea, sarà necessario attendere che il servizio venga creato, potrebbe richiedere un minuto.

  6. Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio.

    Screenshot that shows the notification icon highlighted after the Service instance is created.

  7. Fare clic sulla notifica per esplorare la nuova istanza del servizio.

    Screenshot that shows deployment succeeded and the 'Go to resources' button.

  8. Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio. Verrà visualizzata la nuova istanza del servizio di Azure.

    Screenshot of the Resources windows after clicking the 'Go to resources' button in the previous window.

  9. A questo punto è necessario configurare una funzionalità denominata Direct Line per consentire all'applicazione client di comunicare con questa servizio Bot. Fare clic su Canali, quindi nella sezione Aggiungi un canale in primo piano fare clic su Configura canale Direct Line.

    Screenshot that shows the Configure Direct Line channel highlighted in MyHoloLensBot.

  10. In questa pagina sono disponibili le chiavi segrete che consentiranno all'app client di eseguire l'autenticazione con il bot. Fare clic sul pulsante Mostra e prendere una copia di una delle chiavi visualizzate, come sarà necessario più avanti nel progetto.

    Screenshot of the secret keys highlighted in MyHoloLensBot Configure Direct Line channel.

Capitolo 3: pubblicare il bot nell'app Web di Azure servizio Bot

Ora che il servizio è pronto, è necessario pubblicare il codice bot, creato in precedenza, nell'app Web appena creata servizio Bot.

Nota

È necessario pubblicare il bot nel servizio Azure ogni volta che si apportano modifiche alla soluzione Bot/codice.

  1. Indietro alla soluzione Visual Studio creata in precedenza.

  2. Fare clic con il pulsante destro del mouse sul progetto MyBot, nella Esplora soluzioni, quindi scegliere Pubblica.

    Screenshot that shows the 'MyBot' project drop down menu after a right-click.

  3. Nella pagina Seleziona una destinazione di pubblicazione fare clic su servizio app, quindi selezionare esistente, infine fare clic su Crea profilo (potrebbe essere necessario fare clic sulla freccia a discesa accanto al pulsante Pubblica, se non è visibile).

    Screenshot that shows the Pick a publish target page with 'App Service', 'Select Existing', and 'Create Profile' highlighted.

  4. Se non si è ancora connessi all'account Microsoft, è necessario farlo qui.

  5. Nella pagina Pubblica è necessario impostare la stessa sottoscrizione usata per la creazione del servizio Bot app Web . Impostare quindi La visualizzazione come gruppo di risorse e, nella struttura della cartella a discesa, selezionare il gruppo di risorse creato in precedenza. Fare clic su OK.

    Screenshot that shows the App Service window with the same Subscription used for the Web App Bot Service creation selected.

  6. Fare clic sul pulsante Pubblica e attendere che il bot venga pubblicato (potrebbe richiedere alcuni minuti).

    Screenshot that shows the Publish window with Publish button.

Capitolo 4 : Configurare il progetto Unity

Di seguito è riportata una configurazione tipica per lo sviluppo con realtà mista e, di conseguenza, è un modello valido per altri progetti.

  1. Aprire Unity e fare clic su Nuovo.

    Screenshot that shows the Unity Projects window with the 'New' project icon highlighted in the upper right.

  2. Sarà ora necessario specificare un nome di progetto Unity. Inserire HoloLens Bot. Assicurarsi che il modello di progetto sia impostato su 3D. Impostare La posizione su un punto appropriato per l'utente (ricordarsi, più vicino alle directory radice è meglio). Fare quindi clic su Crea progetto.

    Screenshot that shows the new Unity Project name field highlighted.

  3. Con Unity aperto, vale la pena verificare che l'editor di script predefinito sia impostato su Visual Studio. Passare a Modifica > preferenze e quindi dalla nuova finestra passare a Strumenti esterni. Modificare l'editor di script esterniin Visual Studio 2017. Chiudere la finestra Preferenze .

    Screenshot that shows the Unity Preferences window with the required settings.

  4. Passare quindi a Compilazione file > Impostazioni e selezionare piattaforma UWP (Universal Windows Platform), quindi fare clic sul pulsante Cambia piattaforma per applicare la selezione.

    Screenshot that shows the Build Settings window with the 'Switch Platform' button highlighted.

  5. Sebbene sia ancora in Compilazione file > Impostazioni e assicurarsi che:

    1. Il dispositivo di destinazione è impostato su HoloLens

      Per i visori vr immersivi, impostare Dispositivo di destinazione su Qualsiasi dispositivo.

    2. Il tipo di compilazione è impostato su D3D

    3. SDK è impostato su Più recente installato

    4. Visual Studio Versione è impostata su Più recente installata

    5. Compilare ed eseguire è impostato su Computer locale

    6. Salvare la scena e aggiungerla alla compilazione.

      1. Eseguire questa operazione selezionando Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.

        Screenshot that shows the Build Settings window with the 'Add Open Scenes' button highlighted.

      2. Creare una nuova cartella per questa e qualsiasi scena futura, quindi selezionare il pulsante Nuova cartella per creare una nuova cartella, denominarla Scene.

        Screenshot that shows the creation of a new 'Scenes' folder.

      3. Aprire la cartella Scene appena creata e quindi nel campo Nome file: campo di testo, digitare BotScene, quindi fare clic su Salva.

        Screenshot of the Scenes folder and the newly created file being saved.

    7. Le impostazioni rimanenti, in Compilazione Impostazioni, devono essere lasciate come impostazione predefinita per il momento.

  6. Nella finestra Compila Impostazioni fare clic sul pulsante Lettore Impostazioni, verrà aperto il pannello correlato nello spazio in cui si trova il controllo.

    Screenshot that shows the Build Settings window in the Inspector tab.

  7. In questo pannello è necessario verificare alcune impostazioni:

    1. Nella scheda Altre Impostazioni:

      1. La versione del runtime di script deve essere sperimentale (NET 4.6 Equivalent); la modifica richiederà il riavvio dell'editor.

      2. Scripting Back-end deve essere .NET

      3. Il livello di compatibilità api deve essere .NET 4.6

        Screenshot that shows the Other Settings tab with the required settings.

    2. Nella scheda Pubblicazione Impostazioniselezionare Funzionalità:

      • InternetClient

      • Microfono

        Screenshot that shows 'InternetClient' and 'Microphone' enabled in the Publishing Settings tab.

    3. Più avanti nel pannello, in XR Impostazioni (disponibile sotto Pubblica Impostazioni), selezionare Virtual Reality Supportato, assicurarsi che l'SDK di Windows Mixed Reality sia stato aggiunto.

      Screenshot that shows Virtual Reality Supported enabled and Windows Mixed Reality S D K added.

  8. Tornare in Build ImpostazioniUnity C# Projects non è più disattivato. Selezionare la casella di controllo accanto a questa.

  9. Chiudere la finestra Build Settings (Impostazioni di compilazione).

  10. Salvare la scena e il progetto (>FILE SAVE SCENE/FILE > SAVE PROJECT).

Capitolo 5 : configurazione Fotocamera

Importante

Se si desidera ignorare il componente Configurazione unity di questo corso e continuare direttamente nel codice, è possibile scaricare questo pacchetto Azure-MR-312-Package.unitypackage, importarlo nel progetto come pacchetto personalizzato e quindi continuare dal capitolo 7.

  1. Nel pannello Gerarchia selezionare l'Fotocamera principale.

  2. Dopo aver selezionato, sarà possibile visualizzare tutti i componenti del Fotocamera principale nel pannello Controllo.

    1. L'oggetto Fotocamera deve essere denominato Main Fotocamera (nota l'ortografia)
    2. Il tag main Fotocamera deve essere impostato su MainCamera (nota l'ortografia)
    3. Assicurarsi che la posizione di trasformazione sia impostata su 0, 0, 0
    4. Impostare Flag cancella su colore a tinta unita.
    5. Impostare il colore di sfondo del componente Fotocamera su Nero, Alfa 0 (codice hex: #0000000000)

    Screenshot that shows all the components of the Main Camera in the Inspector panel.

Capitolo 6 : Importare la libreria Newtonsoft

Per facilitare la deserializzazione e la serializzazione degli oggetti ricevuti e inviati alla servizio Bot è necessario scaricare la libreria Newtonsoft. Qui troverai una versione compatibile già organizzata con la struttura di cartelle Unity corretta.

Per importare la libreria Newtonsoft nel progetto, usare il pacchetto Unity fornito con questo corso.

  1. Aggiungere .unitypackage a Unityusando l'opzione> di menuAsset Importa pacchetto>personalizzato pacchetto.

    Screenshot that shows the Assets drop down menu with 'Import Package' then 'Custom Package' selected.

  2. Nella casella Importa pacchetto Unity visualizzata assicurarsi che tutti i plug-in (e inclusi) siano selezionati.

    Screenshot of the Import Unity Package popup box with'Plugins' selected.

  3. Fare clic sul pulsante Importa per aggiungere gli elementi al progetto.

  4. Passare alla cartella Newtonsoft in Plug-in nella visualizzazione progetto e selezionare il plug-in Newtonsoft.

    Screenshot that shows the Newtonsoft folder in the project view.

  5. Con il plug-in Newtonsoft selezionato, assicurarsi che Any Platform sia deselezionato, quindi assicurarsi che WSAPlayer sia deselezionato, quindi fare clic su Applica. Si tratta solo di confermare che i file sono configurati correttamente.

    Screenshot that shows the correct selections for the Newtonsoft plugin.

    Nota

    Contrassegnare questi plug-in consente di configurarli solo nell'editor di Unity. Esistono diversi set di essi nella cartella WSA che verrà usata dopo l'esportazione del progetto da Unity.

  6. È quindi necessario aprire la cartella WSA all'interno della cartella Newtonsoft . Verrà visualizzata una copia dello stesso file appena configurato. Selezionare il file e quindi nel controllo assicurarsi che

    • Qualsiasi piattaformanon selezionata
    • viene controllatosoloWSAPlayer
    • Il processo Dont viene controllato

    Screenshot that shows the correct selections for the Newtonsoft plugin in the WSA folder.

Capitolo 7 : Creare botTag

  1. Creare un nuovo oggetto Tag denominato BotTag. Selezionare la Fotocamera principale nella scena. Fare clic sul menu a discesa Tag nel pannello Controllo. Fare clic su Aggiungi tag.

    Screenshot of the Main Camera Tag drop down menu in the Inspector panel with 'Add Tag' highlighted.

  2. Fare clic sul + simbolo. Assegnare un nome al nuovo tag come BotTag, salvare.

    Screenshot of the Inspector panel with the new BotTag name, plus symbol, and Save button.

Avviso

Non applicare BotTag al Fotocamera principale. Se questa operazione è stata eseguita accidentalmente, assicurarsi di modificare nuovamente il tag Main Fotocamera in MainCamera.

Capitolo 8 - Creare la classe BotObjects

Il primo script da creare è la classe BotObjects , che è una classe vuota creata in modo che una serie di altri oggetti di classe possa essere archiviata all'interno dello stesso script e accessibile da altri script nella scena.

La creazione di questa classe è puramente una scelta architettonica, questi oggetti potrebbero essere invece ospitati nello script Bot che verrà creato più avanti in questo corso.

Per creare questa classe:

  1. Fare clic con il pulsante destro del mouse nel pannello Project, quindi crea > cartella. Assegnare un nome alla cartella Script.

    Create scripts folder.

  2. Fare doppio clic sulla cartella Script per aprirla. Quindi all'interno di tale cartella fare clic con il pulsante destro del mouse e selezionare Crea > script C#. Assegnare allo script BotObjects.

  3. Fare doppio clic sul nuovo script BotObjects per aprirlo con Visual Studio.

  4. Eliminare il contenuto dello script e sostituirlo con il codice seguente:

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class BotObjects : MonoBehaviour{}
    
    /// <summary>
    /// Object received when first opening a conversation
    /// </summary>
    [Serializable]
    public class ConversationObject
    {
        public string ConversationId;
        public string token;
        public string expires_in;
        public string streamUrl;
        public string referenceGrammarId;
    }
    
    /// <summary>
    /// Object including all Activities
    /// </summary>
    [Serializable]
    public class ActivitiesRootObject
    {
        public List<Activity> activities { get; set; }
        public string watermark { get; set; }
    }
    [Serializable]
    public class Conversation
    {
        public string id { get; set; }
    }
    [Serializable]
    public class From
    {
        public string id { get; set; }
        public string name { get; set; }
    }
    [Serializable]
    public class Activity
    {
        public string type { get; set; }
        public string channelId { get; set; }
        public Conversation conversation { get; set; }
        public string id { get; set; }
        public From from { get; set; }
        public string text { get; set; }
        public string textFormat { get; set; }
        public DateTime timestamp { get; set; }
        public string serviceUrl { get; set; }
    }
    
  5. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.

Capitolo 9 - Creare la classe GazeInput

La classe successiva da creare è la classe GazeInput . Questa classe è responsabile di:

  • Creazione di un cursore che rappresenta lo sguardo del giocatore.
  • Rilevamento di oggetti colpiti dallo sguardo del giocatore e tenendo premuto un riferimento agli oggetti rilevati.

Per creare questa classe:

  1. Passare alla cartella Script creata in precedenza.

  2. Fare clic con il pulsante destro del mouse all'interno della cartella, Creare > script C#. Chiamare lo script GazeInput.

  3. Fare doppio clic sul nuovo script GazeInput per aprirlo con Visual Studio.

  4. Inserire la riga seguente sopra il nome della classe:

    /// <summary>
    /// Class responsible for the User's gaze interactions
    /// </summary>
    [System.Serializable]
    public class GazeInput : MonoBehaviour
    
  5. Aggiungere quindi le variabili seguenti all'interno della classe GazeInput, sopra il metodo Start():

        [Tooltip("Used to compare whether an object is to be interacted with.")]
        internal string InteractibleTag = "BotTag";
    
        /// <summary>
        /// Length of the gaze
        /// </summary>
        internal float GazeMaxDistance = 300;
    
        /// <summary>
        /// Object currently gazed
        /// </summary>
        internal GameObject FocusedObject { get; private set; }
    
        internal GameObject _oldFocusedObject { get; private set; }
    
        internal RaycastHit HitInfo { get; private set; }
    
        /// <summary>
        /// Cursor object visible in the scene
        /// </summary>
        internal GameObject Cursor { get; private set; }
    
        internal bool Hit { get; private set; }
    
        internal Vector3 Position { get; private set; }
    
        internal Vector3 Normal { get; private set; }
    
        private Vector3 _gazeOrigin;
    
        private Vector3 _gazeDirection;
    
  6. Il codice per il metodo Start() deve essere aggiunto. Verrà chiamato quando la classe inizializza:

        /// <summary>
        /// Start method used upon initialization.
        /// </summary>
        internal virtual void Start()
        {
            FocusedObject = null;
            Cursor = CreateCursor();
        }
    
  7. Implementare un metodo che creerà un'istanza e imposta il cursore dello sguardo:

        /// <summary>
        /// Method to create a cursor object.
        /// </summary>
        internal GameObject CreateCursor()
        {
            GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            newCursor.SetActive(false);
            // Remove the collider, so it does not block Raycast.
            Destroy(newCursor.GetComponent<SphereCollider>());
            newCursor.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
            Material mat = new Material(Shader.Find("Diffuse"));
            newCursor.GetComponent<MeshRenderer>().material = mat;
            mat.color = Color.HSVToRGB(0.0223f, 0.7922f, 1.000f);
            newCursor.SetActive(true);
    
            return newCursor;
        }
    
  8. Implementare i metodi che configurano Raycast dal Fotocamera Main e manterranno traccia dell'oggetto attivo corrente.

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

Capitolo 10 - Creare la classe Bot

Lo script che verrà creato ora è denominato Bot. Si tratta della classe principale dell'applicazione, che archivia:

  • Credenziali del bot dell'app Web
  • Metodo che raccoglie i comandi vocali dell'utente
  • Metodo necessario per avviare conversazioni con il bot di app Web
  • Metodo necessario per inviare messaggi al bot di app Web

Per inviare messaggi alla servizio Bot, la coroutine SendMessageToBot() creerà un'attività, ovvero un oggetto riconosciuto da Bot Framework come dati inviati dall'utente.

Per creare questa classe:

  1. Fare doppio clic sulla cartella Script per aprirla.

  2. Fare clic con il pulsante destro del mouse all'interno della cartella Script , fare clic su Crea > script C#. Assegnare al bot lo script.

  3. Fare doppio clic sul nuovo script per aprirlo con Visual Studio.

  4. Aggiornare gli spazi dei nomi in modo che corrispondano ai seguenti, nella parte superiore della classe Bot :

    using Newtonsoft.Json;
    using System.Collections;
    using System.Text;
    using UnityEngine;
    using UnityEngine.Networking;
    using UnityEngine.Windows.Speech;
    
  5. All'interno della classe Bot aggiungere le variabili seguenti:

        /// <summary>
        /// Static instance of this class
        /// </summary>
        public static Bot Instance;
    
        /// <summary>
        /// Material of the sphere representing the Bot in the scene
        /// </summary>
        internal Material botMaterial;
    
        /// <summary>
        /// Speech recognizer class reference, which will convert speech to text.
        /// </summary>
        private DictationRecognizer dictationRecognizer;
    
        /// <summary>
        /// Use this variable to identify the Bot Id
        /// Can be any value
        /// </summary>
        private string botId = "MRBotId";
    
        /// <summary>
        /// Use this variable to identify the Bot Name
        /// Can be any value
        /// </summary>
        private string botName = "MRBotName";
    
        /// <summary>
        /// The Bot Secret key found on the Web App Bot Service on the Azure Portal
        /// </summary>
        private string botSecret = "-- Add your Secret Key here --"; 
    
        /// <summary>
        /// Bot Endpoint, v4 Framework uses v3 endpoint at this point in time
        /// </summary>
        private string botEndpoint = "https://directline.botframework.com/v3/directline";
    
        /// <summary>
        /// The conversation object reference
        /// </summary>
        private ConversationObject conversation;
    
        /// <summary>
        /// Bot states to regulate the application flow
        /// </summary>
        internal enum BotState {ReadyToListen, Listening, Processing}
    
        /// <summary>
        /// Flag for the Bot state
        /// </summary>
        internal BotState botState;
    
        /// <summary>
        /// Flag for the conversation status
        /// </summary>
        internal bool conversationStarted = false;
    

    Nota

    Assicurarsi di inserire la chiave privata bot nella variabile botSecret . All'inizio di questo corso, nel capitolo 2, passaggio 10, verrà annotata la chiave privata del bot.

  6. Il codice per Awake() e Start() deve ora essere aggiunto.

        /// <summary>
        /// Called on Initialization
        /// </summary>
        void Awake()
        {
            Instance = this;
        }
    
        /// <summary>
        /// Called immediately after Awake method
        /// </summary>
        void Start()
        {
            botState = BotState.ReadyToListen;
        }
    
  7. Aggiungere i due gestori chiamati dalle librerie vocali quando l'acquisizione vocale inizia e termina. DictationRecognizer arresterà automaticamente l'acquisizione della voce dell'utente quando l'utente smette di parlare.

        /// <summary>
        /// Start microphone capture.
        /// </summary>
        public void StartCapturingAudio()
        {
            botState = BotState.Listening;
            botMaterial.color = Color.red;
    
            // Start dictation
            dictationRecognizer = new DictationRecognizer();
            dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;
            dictationRecognizer.Start();
        }
    
    
        /// <summary>
        /// Stop microphone capture.
        /// </summary>
        public void StopCapturingAudio()
        {
            botState = BotState.Processing;
            dictationRecognizer.Stop();
        }
    
    
  8. Il gestore seguente raccoglie il risultato dell'input vocale dell'utente e chiama la coroutine responsabile dell'invio del messaggio all'app Web servizio Bot.

        /// <summary>
        /// This handler is called every time the Dictation detects a pause in the speech. 
        /// </summary>
        private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
        {
            // Update UI with dictation captured
            Debug.Log($"User just said: {text}");      
    
            // Send dictation to Bot
            StartCoroutine(SendMessageToBot(text, botId, botName, "message"));
            StopCapturingAudio();
        }     
    
  9. La coroutine seguente viene chiamata per iniziare una conversazione con bot. Si noterà che una volta completata la chiamata di conversazione, chiamerà SendMessageToCoroutine() passando una serie di parametri che impostano l'attività da inviare alla servizio Bot come messaggio vuoto. Questa operazione viene eseguita per richiedere all'servizio Bot di avviare il dialogo.

        /// <summary>
        /// Request a conversation with the Bot Service
        /// </summary>
        internal IEnumerator StartConversation()
        {
            string conversationEndpoint = string.Format("{0}/conversations", botEndpoint);
    
            WWWForm webForm = new WWWForm();
    
            using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(conversationEndpoint, webForm))
            {
                unityWebRequest.SetRequestHeader("Authorization", "Bearer " + botSecret);
                unityWebRequest.downloadHandler = new DownloadHandlerBuffer();
    
                yield return unityWebRequest.SendWebRequest();
                string jsonResponse = unityWebRequest.downloadHandler.text;
    
                conversation = new ConversationObject();
                conversation = JsonConvert.DeserializeObject<ConversationObject>(jsonResponse);
                Debug.Log($"Start Conversation - Id: {conversation.ConversationId}");
                conversationStarted = true; 
            }
    
            // The following call is necessary to create and inject an activity of type //"conversationUpdate" to request a first "introduction" from the Bot Service.
            StartCoroutine(SendMessageToBot("", botId, botName, "conversationUpdate"));
        }    
    
  10. La coroutine seguente viene chiamata per compilare l'attività da inviare al servizio Bot.

        /// <summary>
        /// Send the user message to the Bot Service in form of activity
        /// and call for a response
        /// </summary>
        private IEnumerator SendMessageToBot(string message, string fromId, string fromName, string activityType)
        {
            Debug.Log($"SendMessageCoroutine: {conversation.ConversationId}, message: {message} from Id: {fromId} from name: {fromName}");
    
            // Create a new activity here
            Activity activity = new Activity();
            activity.from = new From();
            activity.conversation = new Conversation();
            activity.from.id = fromId;
            activity.from.name = fromName;
            activity.text = message;
            activity.type = activityType;
            activity.channelId = "DirectLineChannelId";
            activity.conversation.id = conversation.ConversationId;     
    
            // Serialize the activity
            string json = JsonConvert.SerializeObject(activity);
    
            string sendActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);
    
            // Send the activity to the Bot
            using (UnityWebRequest www = new UnityWebRequest(sendActivityEndpoint, "POST"))
            {
                www.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));
    
                www.downloadHandler = new DownloadHandlerBuffer();
                www.SetRequestHeader("Authorization", "Bearer " + botSecret);
                www.SetRequestHeader("Content-Type", "application/json");
    
                yield return www.SendWebRequest();
    
                // extrapolate the response Id used to keep track of the conversation
                string jsonResponse = www.downloadHandler.text;
                string cleanedJsonResponse = jsonResponse.Replace("\r\n", string.Empty);
                string responseConvId = cleanedJsonResponse.Substring(10, 30);
    
                // Request a response from the Bot Service
                StartCoroutine(GetResponseFromBot(activity));
            }
        }
    
  11. La coroutine seguente viene chiamata per richiedere una risposta dopo l'invio di un'attività al servizio Bot.

        /// <summary>
        /// Request a response from the Bot by using a previously sent activity
        /// </summary>
        private IEnumerator GetResponseFromBot(Activity activity)
        {
            string getActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);
    
            using (UnityWebRequest unityWebRequest1 = UnityWebRequest.Get(getActivityEndpoint))
            {
                unityWebRequest1.downloadHandler = new DownloadHandlerBuffer();
                unityWebRequest1.SetRequestHeader("Authorization", "Bearer " + botSecret);
    
                yield return unityWebRequest1.SendWebRequest();
    
                string jsonResponse = unityWebRequest1.downloadHandler.text;
    
                ActivitiesRootObject root = new ActivitiesRootObject();
                root = JsonConvert.DeserializeObject<ActivitiesRootObject>(jsonResponse);
    
                foreach (var act in root.activities)
                {
                    Debug.Log($"Bot Response: {act.text}");
                    SetBotResponseText(act.text);
                }
    
                botState = BotState.ReadyToListen;
                botMaterial.color = Color.blue;
            }
        } 
    
  12. L'ultimo metodo da aggiungere a questa classe è necessario per visualizzare il messaggio nella scena:

        /// <summary>
        /// Set the UI Response Text of the bot
        /// </summary>
        internal void SetBotResponseText(string responseString)
        {        
            SceneOrganiser.Instance.botResponseText.text =  responseString;
        }
    

    Nota

    È possibile che venga visualizzato un errore all'interno della console dell'editor di Unity, sulla mancanza della classe SceneOrganiser . Ignorare questo messaggio, come si creerà questa classe più avanti nell'esercitazione.

  13. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.

Capitolo 11 - Creare la classe Interazioni

La classe che verrà creata ora è denominata Interazioni. Questa classe viene usata per rilevare l'HoloLens Toccare Input dall'utente.

Se l'utente tocca durante l'analisi dell'oggetto Bot nella scena e bot è pronto per l'ascolto degli input vocali, l'oggetto Bot cambierà il colore in rosso e inizierà ad ascoltare gli input vocali.

Questa classe eredita dalla classe GazeInput e quindi è in grado di fare riferimento al metodo Start() e alle variabili di tale classe, denotate dall'uso della base.

Per creare questa classe:

  1. Fare doppio clic sulla cartella Script per aprirla.

  2. Fare clic con il pulsante destro del mouse all'interno della cartella Script , fare clic su Crea > script C#. Assegnare un nome all'interazione dello script.

  3. Fare doppio clic sul nuovo script per aprirlo con Visual Studio.

  4. Aggiornare gli spazi dei nomi e l'ereditarietà della classe come segue, nella parte superiore della classe Interazioni :

    using UnityEngine.XR.WSA.Input;
    
    public class Interactions : GazeInput
    {
    
  5. All'interno della classe Interazioni aggiungere la variabile seguente:

        /// <summary>
        /// Allows input recognition with the HoloLens
        /// </summary>
        private GestureRecognizer _gestureRecognizer;
    
  6. Aggiungere quindi il metodo Start():

        /// <summary>
        /// Called on initialization, after Awake
        /// </summary>
        internal override void Start()
        {
            base.Start();
    
            //Register the application to recognize HoloLens user inputs
            _gestureRecognizer = new GestureRecognizer();
            _gestureRecognizer.SetRecognizableGestures(GestureSettings.Tap);
            _gestureRecognizer.Tapped += GestureRecognizer_Tapped;
            _gestureRecognizer.StartCapturingGestures();
        }
    
  7. Aggiungere il gestore che verrà attivato quando l'utente esegue il movimento di tocco davanti alla fotocamera HoloLens

        /// <summary>
        /// Detects the User Tap Input
        /// </summary>
        private void GestureRecognizer_Tapped(TappedEventArgs obj)
        {
            // Ensure the bot is being gazed upon.
            if(base.FocusedObject != null)
            {
                // If the user is tapping on Bot and the Bot is ready to listen
                if (base.FocusedObject.name == "Bot" && Bot.Instance.botState == Bot.BotState.ReadyToListen)
                {
                    // If a conversation has not started yet, request one
                    if(Bot.Instance.conversationStarted)
                    {
                        Bot.Instance.SetBotResponseText("Listening...");
                        Bot.Instance.StartCapturingAudio();
                    }
                    else
                    {
                        Bot.Instance.SetBotResponseText("Requesting Conversation...");
                        StartCoroutine(Bot.Instance.StartConversation());
                    }                                  
                }
            }
        }
    
  8. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.

Capitolo 12 - Creare la classe SceneOrganiser

L'ultima classe richiesta in questo Lab è denominata SceneOrganiser. Questa classe configura la scena a livello di codice aggiungendo componenti e script all'Fotocamera Main e creando gli oggetti appropriati nella scena.

Per creare questa classe:

  1. Fare doppio clic sulla cartella Script per aprirla.

  2. Fare clic con il pulsante destro del mouse all'interno della cartella Script , fare clic su Crea > script C#. Assegnare allo script SceneOrganiser.

  3. Fare doppio clic sul nuovo script per aprirlo con Visual Studio.

  4. All'interno della classe SceneOrganiser aggiungere le variabili seguenti:

        /// <summary>
        /// Static instance of this class
        /// </summary>
        public static SceneOrganiser Instance;
    
        /// <summary>
        /// The 3D text representing the Bot response
        /// </summary>
        internal TextMesh botResponseText;
    
  5. Aggiungere quindi i metodi Awake() e Start():

        /// <summary>
        /// Called on Initialization
        /// </summary>
        private void Awake()
        {
            Instance = this;
        }
    
        /// <summary>
        /// Called immediately after Awake method
        /// </summary>
        void Start ()
        {
            // Add the GazeInput class to this object
            gameObject.AddComponent<GazeInput>();
    
            // Add the Interactions class to this object
            gameObject.AddComponent<Interactions>();
    
            // Create the Bot in the scene
            CreateBotInScene();
        }
    
  6. Aggiungere il metodo seguente, responsabile della creazione dell'oggetto Bot nella scena e della configurazione dei parametri e dei componenti:

        /// <summary>
        /// Create the Sign In button object in the scene
        /// and sets its properties
        /// </summary>
        private void CreateBotInScene()
        {
            GameObject botObjInScene = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            botObjInScene.name = "Bot";
    
            // Add the Bot class to the Bot GameObject
            botObjInScene.AddComponent<Bot>();
    
            // Create the Bot UI
            botResponseText = CreateBotResponseText();
    
            // Set properties of Bot GameObject
            Bot.Instance.botMaterial = new Material(Shader.Find("Diffuse"));
            botObjInScene.GetComponent<Renderer>().material = Bot.Instance.botMaterial;
            Bot.Instance.botMaterial.color = Color.blue;
            botObjInScene.transform.position = new Vector3(0f, 2f, 10f);
            botObjInScene.tag = "BotTag";
        }
    
  7. Aggiungere il metodo seguente, responsabile della creazione dell'oggetto interfaccia utente nella scena, che rappresenta le risposte del bot:

        /// <summary>
        /// Spawns cursor for the Main Camera
        /// </summary>
        private TextMesh CreateBotResponseText()
        {
            // Create a sphere as new cursor
            GameObject textObject = new GameObject();
            textObject.transform.parent = Bot.Instance.transform;
            textObject.transform.localPosition = new Vector3(0,1,0);
    
            // Resize the new cursor
            textObject.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
    
            // Creating the text of the Label
            TextMesh textMesh = textObject.AddComponent<TextMesh>();
            textMesh.anchor = TextAnchor.MiddleCenter;
            textMesh.alignment = TextAlignment.Center;
            textMesh.fontSize = 50;
            textMesh.text = "Hi there, tap on me and I will start listening.";
    
            return textMesh;
        }
    
  8. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.

  9. Nell'editor di Unity trascinare lo script SceneOrganiser dalla cartella Script alla Fotocamera principale. Il componente Organizzatore scena dovrebbe ora essere visualizzato nell'oggetto Main Fotocamera, come illustrato nell'immagine seguente.

    Screenshot that shows the Scene Organiser script being added to the Main Camera object in the Unity Editor.

Capitolo 13 - Prima dell'edificio

Per eseguire un test approfondito dell'applicazione, è necessario caricarlo sul HoloLens. Prima di eseguire, assicurarsi che:

  • Tutte le impostazioni indicate nel capitolo 4 sono impostate correttamente.
  • Lo script SceneOrganiser è collegato all'oggetto Main Fotocamera.
  • Nella classe Bot assicurarsi di aver inserito bot Secret Key nella variabile botSecret .

Capitolo 14 : Compilazione e sideload nel HoloLens

Tutto ciò che è necessario per la sezione Unity di questo progetto è stato completato, quindi è il momento di compilarlo da Unity.

  1. Passare a Build Impostazioni, File > Build Impostazioni....

  2. Nella finestra Compila Impostazioni fare clic su Compila.

    Building the app from Unity

  3. In caso contrario, selezionare Progetti Unity C#.

  4. Fare clic su Compila. Unity avvierà una finestra Esplora file, in cui è necessario creare e quindi selezionare una cartella in cui compilare l'app. Creare la cartella ora e denominarla App. Quindi, con la cartella App selezionata, fare clic su Seleziona cartella.

  5. Unity inizierà a creare il progetto nella cartella App .

  6. Dopo aver completato la compilazione di Unity (potrebbe richiedere qualche tempo), aprirà una finestra Esplora file nella posizione della compilazione (controllare la barra delle applicazioni, perché potrebbe non essere sempre visualizzata sopra le finestre, ma vi notifica l'aggiunta di una nuova finestra).

Capitolo 15 - Distribuire in HoloLens

Per la distribuzione in HoloLens:

  1. Sarà necessario l'indirizzo IP del HoloLens (per distribuzione remota) e assicurarsi che il HoloLens sia in modalità sviluppatore. Per eseguire questa operazione:

    1. Mentre indossa il tuo HoloLens, apri il Impostazioni.
    2. Passare a Rete & Internet > Wi-Fi > opzioni avanzate
    3. Si noti l'indirizzo IPv4 .
    4. Tornare quindi a Impostazioni e quindi aggiornare & la sicurezza > per gli sviluppatori
    5. Impostare la modalità sviluppatore su.
  2. Passare alla nuova compilazione di Unity (cartella App) e aprire il file di soluzione con Visual Studio.

  3. Nella configurazione della soluzione selezionare Debug.

  4. Nella piattaforma della soluzione selezionare x86, Remote Machine.

    Deploy the solution from Visual Studio.

  5. Passare al menu Compila e fare clic su Distribuisci soluzione per eseguire il sideload dell'applicazione nel HoloLens.

  6. L'app dovrebbe ora essere visualizzata nell'elenco delle app installate nel HoloLens, pronto per l'avvio.

    Nota

    Per distribuire in visore vr immersivo, impostare La piattaforma soluzione su Computer locale e impostare Configurazione su Debug, con x86 come piattaforma. Quindi distribuire nel computer locale, usando il menu Build, selezionando Distribuisci soluzione.

Capitolo 16 : Uso dell'applicazione nel HoloLens

  • Dopo aver avviato l'applicazione, il bot verrà visualizzato come una sfera blu davanti all'utente.

  • Usare il movimento di tocco mentre si sta guardando alla sfera per avviare una conversazione.

  • Attendere l'avvio della conversazione (l'interfaccia utente visualizzerà un messaggio quando si verifica). Dopo aver ricevuto il messaggio introduttivo dal bot, toccare di nuovo sul Bot in modo che venga attivato il rosso e inizierà ad ascoltare la voce.

  • Dopo aver interrotto la discussione, l'applicazione invierà il messaggio al bot e riceverà immediatamente una risposta che verrà visualizzata nell'interfaccia utente.

  • Ripetere il processo per inviare più messaggi al bot ( è necessario toccare ogni volta che si vuole senare un messaggio).

Questa conversazione illustra come il bot può conservare le informazioni (nome), fornendo anche informazioni note (ad esempio gli elementi in magazzino).

Alcune domande da porre al bot:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Applicazione Web App Bot (v4) completata

Congratulazioni, è stata creata un'app di realtà mista che sfrutta azure Web App Bot, Microsoft Bot Framework v4.

Final Product

Esercizi aggiuntivi

Esercizio 1

La struttura della conversazione in questo lab è molto di base. Usare Microsoft LUIS per offrire alle funzionalità di comprensione del linguaggio naturale del bot.

Esercizio 2

Questo esempio non include la terminazione di una conversazione e il riavvio di uno nuovo. Per completare la funzionalità Bot, provare a implementare la chiusura alla conversazione.