HoloLens (prima generazione) e Azure 312: Integrazione dei 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. Ci sarà una nuova serie di esercitazioni che verranno pubblicate in futuro che dimostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali esercitazioni quando vengono pubblicate.

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 che mostra la comunicazione tramite un'applicazione Windows Mixed Reality.

Il Microsoft Bot Framework V4 è un set di API progettate per offrire 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 creerà 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 della voce degli utenti.
  2. Quando l'utente ha detto qualcosa, il bot tenterà di fornire una risposta.
  3. Visualizzare i bot rispondino come testo, posizionati vicino al bot, nella scena unity.

Nell'applicazione spetta all'utente come integrare i risultati con la progettazione. Questo corso è progettato per illustrare come integrare un servizio di Azure con il progetto Unity. È il compito di 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 è incentrato principalmente su HoloLens, è anche possibile applicare ciò che si impara in questo corso per Windows Mixed Reality visori VR immersive. Poiché i visori VR immersive non dispongono di fotocamere accessibili, è necessaria una fotocamera esterna connessa al PC. Mentre segui il corso, vedrai note su eventuali modifiche che potresti dover usare per supportare visori VR immersive.

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 stesura del documento (luglio 2018). Si è liberi di usare il software più recente, come elencato all'interno dell'articolo installare gli strumenti , 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 di riscontrare 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 lunghi possono causare problemi in fase di compilazione).
  2. Configurare e testare HoloLens. Se è necessario supportare la configurazione di HoloLens, vedere l'articolo relativo alla configurazione di HoloLens.
  3. È consigliabile eseguire la calibrazione e l'ottimizzazione dei sensori quando si inizia a sviluppare una nuova app HoloLens (talvolta può essere utile per eseguire tali attività per ogni utente).

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

Per informazioni sull'ottimizzazione dei sensori, 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 locale ASP.Net Core. Al termine e al test, verrà pubblicato nel portale di Azure.

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

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

    Screenshot che mostra la finestra New A S P dot N E T Core Web Application .Screenshot che mostra la finestra New A S P dot N E T Core Web Application.

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

    Screenshot che mostra la soluzione aperta con

  4. Nella scheda Sfoglia cercare Microsoft.Bot.Builder.Integration.AspNet.Core (verificare che sia selezionata l'opzione Includi 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 installate le librerie necessarie per Bot Framework v4. Chiudere la pagina NuGet.

    Screenshot che mostra Nu-Get Solution Manager.

  5. Fare clic con il pulsante destro del mouse sul progetto, MyBot, nel Esplora soluzioni e scegliere Aggiungi|classe.

    Screenshot che mostra il processo per aggiungere una nuova classe a MyBot.

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

    Screenshot che mostra la creazione della nuova classe 'MyBot'.

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

  8. Fare clic con il pulsante destro del mouse su wwwroot nel Esplora soluzioni e scegliere Aggiungi|nuovo elemento. Selezionare Pagina HTML (si trova sotto la sottosezione Web). Denominare il file default.html. Fare clic su Aggiungi.

    Screenshot che mostra la creazione di una nuova pagina H T M L dall'interno della finestra di Esplora soluzioni.

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

    Screenshot della finestra Esplora soluzioni con l'elenco di classi.

  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 del contesto di 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, un'istanza di questa classe viene inizializzata 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 in esso 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 il 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 il servizio Bot in Azure e quindi pubblicarvi il codice.

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

    1. Se non si ha già un account Azure, è necessario crearne uno. Se si segue questa esercitazione in una classe o in una situazione di laboratorio, chiedere all'insegnante o a uno dei proctor di assistenza per configurare il nuovo account.
  2. Dopo aver eseguito l'accesso, fare clic su Crea una risorsa nell'angolo in alto a sinistra e cercare Bot app Web e fare clic su Invio.

    Screenshot del dashboard di Microsoft Azure con

  3. La nuova pagina fornirà 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 della pagina Bot dell'app Web e del pulsante

  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, effettuare 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 verrà eseguita l'applicazione. Alcuni asset di Azure sono disponibili solo in determinate aree.

    5. Selezionare il piano tariffario appropriato, se questa è la prima volta che si crea un servizio Bot app Web , dovrebbe essere disponibile un livello gratuito (denominato F0)

    6. Il nome dell'app può essere lasciato come il nome del bot.

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

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

    9. Impostare Archiviazione di Azure che si vuole usare per ospitare il bot. Se non è già disponibile, è possibile crearlo qui.

    10. Sarà anche necessario verificare di aver compreso le condizioni e le condizioni applicate al servizio.

    11. Fare clic su Crea.

      Screenshot che mostra i campi necessari per creare il nuovo servizio.

  5. Dopo aver fatto clic su Crea, è necessario attendere che il servizio venga creato, l'operazione potrebbe richiedere un minuto.

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

    Screenshot che mostra l'icona di notifica evidenziata dopo la creazione dell'istanza del servizio.

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

    Screenshot che mostra la distribuzione riuscita e il pulsante

  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 delle finestre Risorse dopo aver fatto clic sul pulsante

  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 Direct Line canale.

    Screenshot che mostra il canale Configura Direct Line evidenziato 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, perché sarà necessario più avanti nel progetto.

    Screenshot delle chiavi segrete evidenziate nel canale MyHoloLensBot Configure Direct Line.

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

Sarà necessario pubblicare il bot nel servizio di Azure ogni volta che si apportano modifiche alla soluzione o al codice bot.

  1. Indietro alla soluzione di Visual Studio creata in precedenza.

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

    Screenshot che mostra il menu a discesa

  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 che mostra la pagina Seleziona una destinazione di pubblicazione con

  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 Visualizza come gruppo di risorse e, nella struttura della cartella a discesa, selezionare il gruppo di risorse creato in precedenza. Fare clic su OK.

    Screenshot che mostra la finestra servizio app con la stessa sottoscrizione usata per l'app Web servizio Bot creazione selezionata.

  6. A questo punto fare clic sul pulsante Pubblica e attendere che il bot venga pubblicato (potrebbero essere necessari alcuni minuti).

    Screenshot che mostra la finestra Pubblica con il pulsante Pubblica.

Capitolo 4: Configurare il progetto Unity

Di seguito è riportato un tipico set up per lo sviluppo con la realtà mista e, di conseguenza, è un modello valido per altri progetti.

  1. Aprire Unity e fare clic su Nuovo.

    Screenshot che mostra la finestra Progetti Unity con l'icona del progetto

  2. È ora necessario specificare un nome di progetto Unity. Inserire il bot HoloLens. Assicurarsi che il modello di progetto sia impostato su 3D. Impostare La posizione su un punto appropriato per l'utente (tenere presente che più vicino alle directory radice è preferibile). Fare quindi clic su Crea progetto.

    Screenshot che mostra il nuovo campo Nome progetto Unity evidenziato.

  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 esterni in Visual Studio 2017. Chiudere la finestra Preferenze .

    Screenshot che mostra la finestra Preferenze di Unity con le impostazioni necessarie.

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

    Screenshot che mostra la finestra Build Settings con il pulsante 'Switch Platform' evidenziato.

  5. Sempre in Impostazioni di compilazione file > e assicurarsi che:

    1. Il dispositivo di destinazione è impostato su HoloLens

      Per i visori VR immersive, impostare Dispositivo di destinazione su Qualsiasi dispositivo.

    2. Il tipo di compilazione è impostato su D3D

    3. L'SDK è impostato su Più recente installato

    4. La versione di Visual Studio è impostata su Più recente installata

    5. Compilazione ed esecuzione è impostata su Computer locale

    6. Salvare la scena e aggiungerla alla compilazione.

      1. A tale scopo, selezionare Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.

        Screenshot che mostra la finestra Impostazioni di compilazione con il pulsante

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

        Screenshot che mostra la creazione di una nuova cartella

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

        Screenshot della cartella Scenes e del file appena creato salvato.

    7. Le impostazioni rimanenti, in Impostazioni di compilazione, devono essere lasciate come predefinite per il momento.

  6. Nella finestra Build Settings (Impostazioni compilazione) fare clic sul pulsante Player Settings (Impostazioni lettore ) per aprire il pannello correlato nello spazio in cui si trova il controllo .

    Screenshot che mostra la finestra Build Settings (Impostazioni compilazione) nella scheda Inspector (Controllo).

  7. In questo pannello è necessario verificare alcune impostazioni:

    1. Nella scheda Altre impostazioni :

      1. La versione del runtime di scripting deve essere sperimentale (NET 4.6 Equivalente); la modifica di questo richiederà un riavvio dell'editor.

      2. Il back-end di scripting deve essere .NET

      3. Il livello di compatibilità dell'API deve essere .NET 4.6

        Screenshot che mostra la scheda Altre impostazioni con le impostazioni necessarie.

    2. Nella scheda Impostazioni di pubblicazione , in Funzionalità, selezionare:

      • InternetClient

      • Microfono

        Screenshot che mostra

    3. Più avanti nel pannello, in Impostazioni XR (disponibile sotto Impostazioni di pubblicazione), selezionare Virtual Reality Supported (Realtà virtuale supportata), assicurarsi che sia stato aggiunto Windows Mixed Reality SDK.

      Screenshot che mostra l'opzione Virtual Reality Supported enabled (Realtà virtuale supportata) e Windows Mixed Reality S D K aggiunta.

  8. In Build SettingsUnity C# Projects (Impostazioni di compilazione) I progetti C# non sono più disattivati; 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 della fotocamera

Importante

Se si vuole ignorare il componente Configura 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 Hierarchy (Gerarchia) selezionare main camera (Fotocamera principale).

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

    1. L'oggetto Camera deve essere denominato Main Camera (annotare l'ortografia)
    2. Il tag della fotocamera principale deve essere impostato su MainCamera (si noti l'ortografia)
    3. Assicurarsi che la posizione di trasformazione sia impostata su 0, 0, 0
    4. Impostare Cancella flag suColore a tinta unita.
    5. Impostare il colore di sfondo del componente Fotocamera su Nero, Alfa 0 (Codice esadecimale: #00000000)

    Screenshot che mostra tutti i componenti della fotocamera principale nel pannello Controllo.

Capitolo 6 - Importare la libreria Newtonsoft

Per facilitare la deserializzazione e la serializzazione di oggetti ricevuti e inviati al servizio Bot è necessario scaricare la libreria Newtonsoft. Qui è disponibile 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 Unity usando l'opzione di menu Asset>Importa pacchetto>personalizzato pacchetto .

    Screenshot che mostra il menu a discesa Asset con

  2. Nella casella Import Unity Package (Importa pacchetto Unity ) visualizzata verificare che sia selezionata l'opzione Plug-in (e inclusi) in .

    Screenshot della casella popup Importa pacchetto Unity con l'opzione 'Plugins' selezionata.

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

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

    Screenshot che mostra la cartella Newtonsoft nella visualizzazione del progetto.

  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 che mostra le selezioni corrette per il plug-in Newtonsoft.

    Nota

    Contrassegnando questi plug-in, questi plug-in vengono configurati in modo che vengano usati solo nell'editor di Unity. Nella cartella WSA è presente un set diverso che verrà usato dopo l'esportazione del progetto da Unity.

  6. Successivamente, è 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 verificare che

    • Qualsiasi piattaformanon selezionata
    • viene selezionatosoloWSAPlayer
    • Il processo non è selezionato

    Screenshot che mostra le selezioni corrette per il plug-in Newtonsoft nella cartella WSA.

Capitolo 7: Creare il BotTag

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

    Screenshot del menu a discesa Tag fotocamera principale nel pannello Controllo con 'Aggiungi tag' evidenziato.

  2. Fare clic sul + simbolo. Assegnare al nuovo tag il nome BotTag, Salva.

    Screenshot del pannello Inspector con il nuovo nome BotTag, il simbolo e il pulsante Salva.

Avviso

Non applicare BotTag alla fotocamera principale. Se l'operazione è stata eseguita accidentalmente, assicurarsi di modificare nuovamente il tag Main Camera in MainCamera.

Capitolo 8: Creare la classe BotObjects

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

La creazione di questa classe è puramente una scelta architetturale. Questi oggetti possono invece essere 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 Progetto, quindi scegliere Crea > cartella. Assegnare alla cartella il nome Scripts.

    Creare la cartella scripts.

  2. Fare doppio clic sulla cartella Scripts per aprirla. Quindi all'interno di tale cartella fare clic con il pulsante destro del mouse e scegliere Crea > script C#. Assegnare allo script il nome 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 che creerai è la classe GazeInput . Questa classe è responsabile di:

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

Per creare questa classe:

  1. Passare alla cartella Scripts creata in precedenza.

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

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

  4. Inserire la riga seguente a destra 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. È necessario aggiungere il codice per il metodo Start( ). 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 per creare un'istanza e configurare il cursore sguardo fisso:

        /// <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 dalla fotocamera principale e tengono 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 si intende creare ora è denominato Bot. Questa è la 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 dell'app Web
  • Metodo necessario per inviare messaggi al bot dell'app Web

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

Per creare questa classe:

  1. Fare doppio clic sulla cartella Scripts per aprirla.

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

  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 del bot nella variabile botSecret . All'inizio di questo corso si noterà la chiave privata del bot , nel capitolo 2, passaggio 10.

  6. È ora necessario aggiungere il codice per Awake() e Start().

        /// <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 all'inizio e alla fine dell'acquisizione vocale. DictationRecognizer interrompe 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 avviare una conversazione con il bot. Si noterà che una volta completata la chiamata di conversazione, chiamerà SendMessageToCoroutine() passando una serie di parametri che imposteranno l'attività da inviare al servizio Bot come messaggio vuoto. Questa operazione viene eseguita per richiedere al 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. Viene chiamata la coroutine seguente 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, in merito alla mancanza della classe SceneOrganiser . Ignorare questo messaggio, perché questa classe verrà creata 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 si intende creare ora è denominata Interazioni. Questa classe viene usata per rilevare l'input tocco di HoloLens dall'utente.

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

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

Per creare questa classe:

  1. Fare doppio clic sulla cartella Scripts per aprirla.

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

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

  4. Aggiornare gli spazi dei nomi e l'ereditarietà della classe in modo che corrispondano ai seguenti, all'inizio della classe Interactions :

    using UnityEngine.XR.WSA.Input;
    
    public class Interactions : GazeInput
    {
    
  5. All'interno della classe Interactions 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 alla fotocamera principale e creando gli oggetti appropriati nella scena.

Per creare questa classe:

  1. Fare doppio clic sulla cartella Scripts per aprirla.

  2. Fare clic con il pulsante destro del mouse all'interno della cartella Script , scegliere Crea > script C#. Assegnare allo script il nome 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 dell'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 Scripts alla fotocamera principale. Il componente Organizzatore scena dovrebbe ora essere visualizzato sull'oggetto Main Camera, come illustrato nell'immagine seguente.

    Screenshot che mostra lo script Scene Organizer aggiunto all'oggetto Main Camera nell'editor di Unity.

Capitolo 13 – Prima dell'edificio

Per eseguire un test approfondito dell'applicazione, è necessario trasferire localmente l'applicazione in HoloLens. Prima di procedere, assicurarsi che:

  • Tutte le impostazioni indicate nel capitolo 4 vengono impostate correttamente.
  • Lo script SceneOrganiser è associato all'oggetto Main Camera .
  • Nella classe Bot assicurarsi di aver inserito la chiave privata del bot nella variabile botSecret .

Capitolo 14: Compilazione e trasferimento locale in HoloLens

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

  1. Passare a Impostazioni di compilazione, Impostazioni compilazione file > ....

  2. Nella finestra Build Settings (Impostazioni compilazione ) fare clic su Build (Compila).

    Compilazione dell'app da Unity

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

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

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

  6. Una volta completata la compilazione di Unity (potrebbe essere necessario del tempo), verrà aperta una finestra di Esplora file nella posizione della compilazione (controllare la barra delle applicazioni, perché potrebbe non essere sempre visualizzata sopra le finestre, ma invierà una notifica dell'aggiunta di una nuova finestra).

Capitolo 15 - Distribuire in HoloLens

Per eseguire la distribuzione in HoloLens:

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

    1. Mentre indossa holoLens, apri le impostazioni.
    2. Passare a & Internet > Wi-Fi > Opzioni avanzate
    3. Prendere nota dell'indirizzo IPv4 .
    4. Tornare quindi a Impostazioni e quindi aggiornare & sicurezza > per sviluppatori
    5. Impostare la modalità sviluppatore attivata.
  2. Passare alla nuova compilazione di Unity (cartella App ) e aprire il file della soluzione con Visual Studio.

  3. In Configurazione soluzione selezionare Debug.

  4. Nella piattaforma della soluzione selezionare x86, Computer remoto.

    Distribuire la soluzione da Visual Studio.

  5. Passare al menu Compila e fare clic su Distribuisci soluzione per trasferire localmente l'applicazione in HoloLens.

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

    Nota

    Per eseguire la distribuzione in visore VR immersive, impostare La piattaforma della soluzione su Computer locale e impostare Configurazione su Debug, con x86 come piattaforma. Distribuire quindi nel computer locale, usando il menu Compila, selezionando Distribuisci soluzione.

Capitolo 16 : uso dell'applicazione in HoloLens

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

  • Usa il movimento di tocco mentre stai guardando la 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 il bot in modo che sia rosso e inizierà ad ascoltare la voce.

  • Una volta interrotta la comunicazione, l'applicazione invierà il messaggio al bot e si riceverà immediatamente una risposta che verrà visualizzata nell'interfaccia utente.

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

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

Alcune domande da porre al bot:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Applicazione bot app Web (v4) completata

È stata creata un'app di realtà mista che usa il bot app Web di Azure, Microsoft Bot Framework v4.

Prodotto finale

Esercizi aggiuntivi

Esercizio 1

La struttura della conversazione in questo lab è molto semplice. 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.