HoloLens (första generationen) och Azure 312: Robotintegrering

  • Artikel

Anteckning

Självstudierna Mixed Reality Academy har utformats med HoloLens (första generationen) och Mixed Reality integrerande headset i åtanke. Därför tycker vi att det är viktigt att låta de här självstudierna vara kvar för utvecklare som fortfarande behöver vägledning för att utveckla för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygsuppsättningarna eller interaktionerna som används för HoloLens 2. De kommer att underhållas för att fortsätta arbeta på de enheter som stöds. Det kommer att finnas en ny serie självstudier som kommer att publiceras i framtiden som visar hur man utvecklar för HoloLens 2. Det här meddelandet uppdateras med en länk till dessa självstudier när de publiceras.

I den här kursen får du lära dig hur du skapar och distribuerar en robot med hjälp av Microsoft Bot Framework V4 och kommunicerar med den via ett Windows Mixed Reality program.

Skärmbild som visar kommunikation via ett Windows Mixed Reality program.

Microsoft Bot Framework V4 är en uppsättning API:er som har utformats för att ge utvecklare verktyg för att skapa ett utökningsbart och skalbart robotprogram. Mer information finns på sidan Microsoft Bot Framework eller V4 Git-lagringsplatsen.

När du har slutfört den här kursen har du skapat ett Windows Mixed Reality program som kan göra följande:

  1. Använd en tryckgest för att starta roboten som lyssnar efter användarnas röst.
  2. När användaren har sagt något försöker roboten ge ett svar.
  3. Visa robotarna svara som text, placerad nära roboten, i Unity-scenen.

I ditt program är det upp till dig hur du ska integrera resultaten med din design. Den här kursen är utformad för att lära dig hur du integrerar en Azure-tjänst med ditt Unity-projekt. Det är ditt jobb att använda den kunskap du får från den här kursen för att förbättra ditt mixed reality-program.

Stöd för enheter

Kurs HoloLens Integrerande headset
MR och Azure 312: Robotintegrering ✔️ ✔️

Anteckning

Kursen fokuserar främst på HoloLens, men du kan också använda det du lär dig i den här kursen för att Windows Mixed Reality integrerande (VR)-headset. Eftersom integrerande (VR) headset inte har tillgängliga kameror, behöver du en extern kamera ansluten till datorn. När du följer kursen visas anteckningar om eventuella ändringar som du kan behöva använda för att stödja integrerande (VR)-headset.

Förutsättningar

Anteckning

Den här självstudien är utformad för utvecklare som har grundläggande erfarenhet av Unity och C#. Tänk också på att kraven och de skriftliga instruktionerna i det här dokumentet representerar det som har testats och verifierats i skrivande stund (juli 2018). Du är fri att använda den senaste programvaran, som anges i artikeln installera verktyg , men det bör inte antas att informationen i denna kurs kommer att matcha perfekt vad du hittar i nyare programvara än vad som anges nedan.

Vi rekommenderar följande maskinvara och programvara för den här kursen:

Innan du börjar

  1. För att undvika problem med att skapa det här projektet rekommenderar vi starkt att du skapar projektet som nämns i den här självstudien i en rotmapp eller nära rotmapp (långa mappsökvägar kan orsaka problem vid byggtiden).
  2. Konfigurera och testa HoloLens. Om du behöver stöd för att konfigurera HoloLens kan du läsa artikeln om HoloLens-konfiguration.
  3. Det är en bra idé att utföra kalibrering och sensorjustering när du börjar utveckla en ny HoloLens-app (ibland kan det hjälpa att utföra dessa uppgifter för varje användare).

Om du behöver hjälp med kalibrering följer du den här länken till holoLenskalibreringsartikeln.

Om du vill ha hjälp med sensorjustering följer du den här länken till artikeln HoloLens Sensor Tuning.

Kapitel 1 – Skapa robotprogrammet

Det första steget är att skapa roboten som en lokal ASP.Net Core-webbapp. När du har slutfört och testat den publicerar du den till Azure-portalen.

  1. Öppna Visual Studio. Skapa ett nytt projekt, välj ASP NET Core-webbprogram som projekttyp (du hittar det under underavsnittet .NET Core) och kalla det MyBot. Klicka på OK.

  2. I fönstret som visas väljer du Tom. Kontrollera också att målet är inställt på ASP NET Core 2.0 och att autentiseringen är inställd på Ingen autentisering. Klicka på OK.

    Skärmbild som visar fönstret Nytt A S P-punkt N E T Core-webbprogram.

  3. Lösningen öppnas nu. Högerklicka på Solution Mybot i Solution Explorer och klicka på Hantera NuGet-paket för lösningen.

    Skärmbild som visar den öppnade lösningen med

  4. På fliken Bläddra söker du efter Microsoft.Bot.Builder.Integration.AspNet.Core (se till att inkludera förhandsversion är markerat). Välj paketversion 4.0.1-preview och markera projektrutorna. Klicka sedan på Installera. Nu har du installerat de bibliotek som behövs för Bot Framework v4. Stäng NuGet-sidan.

    Skärmbild som visar Nu-Get Solution Manager.

  5. Högerklicka på projektetMyBot i Solution Explorer och klicka på Lägg till|klass.

    Skärmbild som visar processen för att lägga till en ny klass i MyBot.

  6. Ge klassen namnet MyBot och klicka på Lägg till.

    Skärmbild som visar den nya klassgenereringen

  7. Upprepa föregående punkt för att skapa en annan klass med namnet ConversationContext.

  8. Högerklicka på wwwroot i Solution Explorer och klicka på Lägg till|nytt objekt. Välj HTML-sida (du hittar den under underavsnittet Webb). Ge filen namnet default.html. Klicka på Lägg till.

    Skärmbild som visar skapandet av en ny H T M L-sida inifrån Solution Explorer fönstret.

  9. Listan över klasser/objekt i Solution Explorer bör se ut som på bilden nedan.

    Skärmbild av fönstret Solution Explorer med en lista över klasser.

  10. Dubbelklicka på klassen ConversationContext . Den här klassen ansvarar för att lagra de variabler som används av roboten för att upprätthålla kontexten för konversationen. Dessa konversationskontextvärden upprätthålls i en instans av den här klassen, eftersom alla instanser av klassen MyBot uppdateras varje gång en aktivitet tas emot. Lägg till följande kod i klassen :

    namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}

  11. Dubbelklicka på klassen MyBot . Den här klassen är värd för de hanterare som anropas av inkommande aktivitet från kunden. I den här klassen lägger du till koden som används för att skapa konversationen mellan roboten och kunden. Som tidigare nämnts initieras en instans av den här klassen varje gång en aktivitet tas emot. Lägg till följande kod i den här klassen:

    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. Dubbelklicka på startklassen . Den här klassen initierar roboten. Lägg till följande kod i klassen :

    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. Öppna programklassfilen och kontrollera att koden i den är samma som följande:

    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. Kom ihåg att spara ändringarna. Om du vill göra det går du till Spara>alla i fil, från verktygsfältet högst upp i Visual Studio.

Kapitel 2 – Skapa Azure Bot Service

Nu när du har skapat koden för din robot måste du publicera den till en instans av Web App Bot Service på Azure-portalen. Det här kapitlet visar hur du skapar och konfigurerar Bot Service i Azure och sedan publicerar koden till den.

  1. Logga först in på Azure Portal (https://portal.azure.com).

    1. Om du inte redan har ett Azure-konto måste du skapa ett. Om du följer den här självstudien i ett klassrum eller en labbsituation ber du instruktören eller någon av rektorerna om hjälp med att konfigurera ditt nya konto.

  2. När du är inloggad klickar du på Skapa en resurs i det övre vänstra hörnet och söker efter webapprobot och klickar på Retur.

    Skärmbild av Microsoft Azure-instrumentpanelen med

  3. Den nya sidan innehåller en beskrivning av Web App Bot Service. Längst ned till vänster på den här sidan väljer du knappen Skapa för att skapa en association med den här tjänsten.

    Skärmbild av sidan Webbapprobot och knappen Skapa längst ned till vänster.

  4. När du har klickat på Skapa:

    1. Infoga önskat namn för den här tjänstinstansen.

    2. Välj en prenumeration.

    3. Välj en resursgrupp eller skapa en ny. En resursgrupp är ett sätt att övervaka, kontrollera åtkomst, etablera och hantera fakturering för en samling Azure-tillgångar. Vi rekommenderar att du behåller alla Azure-tjänster som är associerade med ett enskilt projekt (t.ex. dessa kurser) under en gemensam resursgrupp).

      Om du vill läsa mer om Azure-resursgrupper följer du den här länken

    4. Fastställa platsen för resursgruppen (om du skapar en ny resursgrupp). Platsen skulle helst finnas i den region där programmet skulle köras. Vissa Azure-tillgångar är bara tillgängliga i vissa regioner.

    5. Välj den prisnivå som är lämplig för dig, om det är första gången du skapar en webbappsrobottjänst bör en kostnadsfri nivå (med namnet F0) vara tillgänglig för dig

    6. Appnamnet kan bara lämnas på samma sätt som robotnamnet.

    7. Lämna robotmallen som Basic (C#).

    8. App Service-planen/platsen bör ha fyllts i automatiskt för ditt konto.

    9. Ange den Azure Storage som du vill använda som värd för roboten. Om du inte redan har en kan du skapa den här.

    10. Du måste också bekräfta att du har förstått de villkor som tillämpas på den här tjänsten.

    11. Klicka på Skapa.

      Skärmbild som visar de fält som krävs för att skapa den nya tjänsten.

  5. När du har klickat på Skapa måste du vänta tills tjänsten har skapats. Det kan ta en minut.

  6. Ett meddelande visas i portalen när tjänstinstansen har skapats.

    Skärmbild som visar meddelandeikonen markerad när tjänstinstansen har skapats.

  7. Klicka på meddelandet för att utforska din nya tjänstinstans.

    Skärmbild som visar att distributionen lyckades och knappen Gå till resurser.

  8. Klicka på knappen Gå till resurs i meddelandet för att utforska din nya tjänstinstans. Du kommer till din nya Azure Service-instans.

    Skärmbild av fönstret Resurser när du har klickat på knappen Gå till resurser i föregående fönster.

  9. Nu måste du konfigurera en funktion som heter Direct Line så att klientprogrammet kan kommunicera med den här Bot Service. Klicka på Kanaler och klicka sedan på Konfigurera Direct Line kanal i avsnittet Lägg till en aktuell kanal.

    Skärmbild som visar kanalen Konfigurera Direct Line markerad i MyHoloLensBot.

  10. På den här sidan hittar du de hemliga nycklar som gör att klientappen kan autentisera med roboten. Klicka på knappen Visa och ta en kopia av en av de nycklar som visas, eftersom du behöver detta senare i projektet.

    Skärmbild av de hemliga nycklarna som är markerade i MyHoloLensBot Configure Direct Line-kanalen.

Kapitel 3 – Publicera roboten till Azure Web App Bot Service

Nu när tjänsten är klar måste du publicera robotkoden, som du skapade tidigare, till den nyligen skapade webbappen Bot Service.

Anteckning

Du måste publicera din robot till Azure Service varje gång du gör ändringar i robotlösningen/koden.

  1. Gå tillbaka till din Visual Studio-lösning som du skapade tidigare.

  2. Högerklicka på mybot-projektet i Solution Explorer och klicka sedan på Publicera.

    Skärmbild som visar den nedrullningsbara menyn MyBot-projekt efter ett högerklicka.

  3. På sidan Välj ett publiceringsmål klickar du på App Service och sedan på Välj befintlig. Klicka slutligen på Skapa profil (du kan behöva klicka på listrutepilen tillsammans med knappen Publicera, om detta inte visas).

    Skärmbild som visar sidan Välj ett publiceringsmål med

  4. Om du ännu inte är inloggad på ditt Microsoft-konto måste du göra det här.

  5. På sidan Publicera ser du att du måste ange samma prenumeration som du använde för att skapa Web App Bot Service. Ange sedan Visa som resursgrupp och i listrutans mappstruktur väljer du den resursgrupp som du skapade tidigare. Klicka på OK.

    Skärmbild som visar det App Service fönstret med samma prenumeration som används för webbappen Bot Service skapande valt.

  6. Klicka nu på knappen Publicera och vänta tills roboten har publicerats (det kan ta några minuter).

    Skärmbild som visar knappen Publicera med knappen Publicera.

Kapitel 4 – Inrätta Unity-projektet

Följande är en typisk konfiguration för utveckling med mixad verklighet och är därför en bra mall för andra projekt.

  1. Öppna Unity och klicka på Nytt.

    Skärmbild som visar Unity Projects-fönstret med projektikonen

  2. Nu måste du ange ett Unity-projektnamn. Infoga HoloLens Bot. Kontrollera att projektmallen är inställd på 3D. Ange plats till någonstans som passar dig (kom ihåg att närmare rotkataloger är bättre). Klicka sedan på Skapa projekt.

    Skärmbild som visar det nya Unity Project-namnfältet markerat.

  3. När Unity är öppet är det värt att kontrollera att standardskriptredigeraren är inställd på Visual Studio. Gå till Redigera > inställningar och gå sedan till Externa verktyg från det nya fönstret. Ändra extern skriptredigerare till Visual Studio 2017. Stäng fönstret Inställningar .

    Skärmbild som visar fönstret Unity-inställningar med de inställningar som krävs.

  4. Gå sedan till Inställningar för filbygge > och välj Universell Windows-plattform och klicka sedan på knappen Växla plattform för att tillämpa ditt val.

    Skärmbild som visar fönstret Skapa inställningar med knappen

  5. När du fortfarande är i Inställningar för filbygge > och kontrollera att:

    1. Målenheten är inställd på HoloLens

      För de uppslukande headseten anger du Målenhet till Valfri enhet.

    2. Byggtyp är inställt på D3D

    3. SDK är inställt på Senaste installerat

    4. Visual Studio-versionen är inställd på Senaste installerad

    5. Build and Run är inställt på Lokal dator

    6. Spara scenen och lägg till den i bygget.

      1. Gör detta genom att välja Lägg till öppna scener. Ett spara-fönster visas.

        Skärmbild som visar fönstret Skapa inställningar med knappen Lägg till öppna scener markerad.

      2. Skapa en ny mapp för detta, och eventuell framtida scen, välj sedan knappen Ny mapp , för att skapa en ny mapp, ge den namnet Scener.

        Skärmbild som visar skapandet av en ny mapp med scener.

      3. Öppna den nyligen skapade mappen Scener och i textfältet Filnamn: skriver du BotScene och klickar sedan på Spara.

        Skärmbild av mappen Scener och den nyligen skapade filen som sparas.

    7. De återstående inställningarna i Bygginställningar bör vara kvar som standard för tillfället.

  6. I fönstret Build Settings (Skapa inställningar ) klickar du på knappen Spelarinställningar . Då öppnas den relaterade panelen i det utrymme där kontrollanten finns.

    Skärmbild som visar fönstret Bygginställningar på fliken Kontroll.

  7. I den här panelen måste några inställningar verifieras:

    1. På fliken Andra inställningar :

      1. Körningsversionen för skript ska vara experimentell (NET 4.6-motsvarighet); Om du ändrar detta krävs en omstart av redigeraren.

      2. Skriptserverdelen ska vara .NET

      3. API-kompatibilitetsnivån ska vara .NET 4.6

        Skärmbild som visar fliken Andra inställningar med de inställningar som krävs.

    2. På fliken Publiceringsinställningar går du till Funktioner och kontrollerar:

      • InternetClient

      • Mikrofon

        Skärmbild som visar

    3. Längre ned på panelen, i XR-inställningar (finns nedan Publicera inställningar), markerar du Virtual Reality Supported (Virtual Reality Supported) och kontrollerar att Windows Mixed Reality SDK har lagts till.

      Skärmbild som visar aktiverad virtual reality och Windows Mixed Reality S D K har lagts till.

  8. Tillbaka i Build SettingsUnity C# Projects är inte längre nedtonat. markera kryssrutan bredvid detta.

  9. Stäng fönstret Build Settings (Bygginställningar).

  10. Spara din scen och ditt projekt (FILE > SAVE SCENE/FILE > SAVE PROJECT).

Kapitel 5 – Kamerainstallation

Viktigt

Om du vill hoppa över Unity Set up-komponenten i den här kursen och fortsätta direkt till koden kan du ladda ned den här Azure-MR-312-Package.unitypackage, importera den till ditt projekt som ett anpassat paket och sedan fortsätta från kapitel 7.

  1. I panelen Hierarki väljer du huvudkameran.

  2. När du har valt kan du se alla komponenter i huvudkameran på panelen Inspector.

    1. Kameraobjektet måste ha namnet Main Camera (observera stavningen)
    2. Huvudkamerataggen måste vara inställd på MainCamera (observera stavningen)
    3. Kontrollera att transformeringspositionen är inställd på 0, 0, 0
    4. Ange Ta bort flaggor till Enfärgad.
    5. Ange bakgrundsfärgen för kamerakomponenten till Svart, Alpha 0 (Hexkod: #000000000)

    Skärmbild som visar alla komponenter i huvudkameran på panelen Kontroll.

Kapitel 6 – Importera Newtonsoft-biblioteket

För att hjälpa dig att deserialisera och serialisera objekt som tagits emot och skickats till Bot Service måste du ladda ned Newtonsoft-biblioteket. Du hittar en kompatibel version som redan har organiserats med rätt Unity-mappstruktur här.

Om du vill importera Newtonsoft-biblioteket till projektet använder du Unity-paketet som följde med den här kursen.

  1. Lägg till .unitypackage i Unity med menyalternativetImportera paket>anpassat paket för tillgångar>.

    Skärmbild som visar den nedrullningsbara menyn Tillgångar med Importpaket och sedan Anpassat paket valt.

  2. I rutan Importera Unity-paket som visas kontrollerar du att allt under (och inklusive) plugin-program är markerat.

    Skärmbild av popup-rutan Importera Unity-paket med plugin-program markerade.

  3. Klicka på knappen Importera för att lägga till objekten i projektet.

  4. Gå till mappen Newtonsoft under Plugin-program i projektvyn och välj newtonsoft-plugin-programmet.

    Skärmbild som visar mappen Newtonsoft i projektvyn.

  5. När newtonsoft-plugin-programmet har valts kontrollerar du att Alla plattformar är avmarkerade och kontrollerar sedan att WSAPlayer också är avmarkerat och klickar sedan på Använd. Detta är bara för att bekräfta att filerna är korrekt konfigurerade.

    Skärmbild som visar rätt val för Newtonsoft-plugin-programmet.

    Anteckning

    Om du markerar dessa plugin-program konfigureras de så att de endast används i Unity-redigeraren. Det finns en annan uppsättning av dem i WSA-mappen som ska användas när projektet har exporterats från Unity.

  6. Därefter måste du öppna WSA-mappen i mappen Newtonsoft . Du ser en kopia av samma fil som du just konfigurerade. Välj filen och kontrollera sedan i inspektören att

    • Alla plattformar är avmarkerade
    • endastWSAPlayerär markerat
    • Dont-processenär markerad

    Skärmbild som visar rätt val för Newtonsoft-plugin-programmet i WSA-mappen.

Kapitel 7 – Skapa BotTag

  1. Skapa ett nytt taggobjekt med namnet BotTag. Välj huvudkameran i scenen. Klicka på listrutan Tagg i panelen Kontroll. Klicka på Lägg till tagg.

    Skärmbild av den nedrullningsbara menyn Huvudkameratagg i panelen Kontroll med Lägg till tagg markerad.

  2. Klicka på symbolen + . Ge den nya taggen namnet BotTag, Spara.

    Skärmbild av panelen Inspector med det nya BotTag-namnet, plus symbolen och knappen Spara.

Varning

Använd inteBotTag på huvudkameran. Om du av misstag har gjort detta måste du ändra huvudkamerataggen tillbaka till MainCamera.

Kapitel 8 – Skapa klassen BotObjects

Det första skriptet du behöver skapa är klassen BotObjects , som är en tom klass som skapats så att en serie andra klassobjekt kan lagras i samma skript och nås av andra skript i scenen.

Skapandet av den här klassen är bara ett arkitektoniskt val. Dessa objekt kan i stället finnas i robotskriptet som du skapar senare i den här kursen.

Så här skapar du den här klassen:

  1. Högerklicka på projektpanelen och sedan på Skapa > mapp. Namnge mappen Skript.

    Skapa skriptmapp.

  2. Dubbelklicka på mappen Skript för att öppna den. Högerklicka sedan i mappen och välj Skapa > C#-skript. Ge skriptet namnet BotObjects.

  3. Dubbelklicka på det nya BotObjects-skriptet för att öppna det med Visual Studio.

  4. Ta bort innehållet i skriptet och ersätt det med följande kod:

    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. Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Kapitel 9 – Skapa klassen GazeInput

Nästa klass som du ska skapa är klassen GazeInput . Den här klassen ansvarar för:

  • Skapa en markör som representerar spelarens blick .
  • Identifiera objekt som träffats av spelarens blick och hålla en referens till identifierade objekt.

Så här skapar du den här klassen:

  1. Gå till mappen Skript som du skapade tidigare.

  2. Högerklicka i mappen Skapa > C#-skript. Anropa skriptet GazeInput.

  3. Dubbelklicka på det nya GazeInput-skriptet för att öppna det med Visual Studio.

  4. Infoga följande rad ovanpå klassnamnet:

    /// <summary>
/// Class responsible for the User's gaze interactions
/// </summary>
[System.Serializable]
public class GazeInput : MonoBehaviour

  5. Lägg sedan till följande variabler i klassen GazeInput ovanför metoden 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. Kod för Start() -metoden bör läggas till. Detta anropas när klassen initierar:

        /// <summary>
    /// Start method used upon initialization.
    /// </summary>
    internal virtual void Start()
    {
        FocusedObject = null;
        Cursor = CreateCursor();
    }

  7. Implementera en metod som instansierar och konfigurerar blickmarkören:

        /// <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. Implementera de metoder som konfigurerar Raycast från huvudkameran och håller reda på det aktuella fokuserade objektet.

        /// <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. Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Kapitel 10 – Skapa robotklassen

Skriptet som du ska skapa nu kallas robot. Det här är kärnklassen för ditt program. Det lagrar:

  • Dina autentiseringsuppgifter för webbapprobot
  • Metoden som samlar in användarens röstkommandon
  • Den metod som krävs för att initiera konversationer med din webapprobot
  • Den metod som krävs för att skicka meddelanden till webbapproboten

För att skicka meddelanden till Bot Service skapar Coroutine SendMessageToBot() en aktivitet, som är ett objekt som identifieras av Bot Framework som data som skickas av användaren.

Så här skapar du den här klassen:

  1. Dubbelklicka på mappen Skript för att öppna den.

  2. Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Namnge skriptroboten.

  3. Dubbelklicka på det nya skriptet för att öppna det med Visual Studio.

  4. Uppdatera namnrymderna så att de är desamma som följande överst i robotklassen :

    using Newtonsoft.Json;
using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Windows.Speech;

  5. Lägg till följande variabler i robotklassen :

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

    Anteckning

    Se till att du infogar din bothemlighetsnyckel i variabeln botSecret . Du kommer att ha noterat din bothemlighetsnyckel i början av den här kursen, i kapitel 2, steg 10.

  6. Kod för Awake() och Start() måste nu läggas till.

        /// <summary>
    /// Called on Initialization
    /// </summary>
    void Awake()
    {
        Instance = this;
    }

    /// <summary>
    /// Called immediately after Awake method
    /// </summary>
    void Start()
    {
        botState = BotState.ReadyToListen;
    }

  7. Lägg till de två hanterare som anropas av talbiblioteken när röstinspelningen börjar och slutar. DictationRecognizer slutar automatiskt att samla in användarens röst när användaren slutar tala.

        /// <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. Följande hanterare samlar in resultatet av användarens röstindata och anropar den coroutin som ansvarar för att skicka meddelandet till webappen Bot Service.

        /// <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. Följande coroutine anropas för att starta en konversation med roboten. När konversationsanropet är klart anropas SendMessageToCoroutine() när du skickar en serie parametrar som anger att aktiviteten ska skickas till Bot Service som ett tomt meddelande. Detta görs för att uppmana Bot Service att inleda dialogen.

        /// <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. Följande coroutine anropas för att skapa aktiviteten som ska skickas till Bot Service.

        /// <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. Följande coroutine anropas för att begära ett svar när en aktivitet har skickats till Bot Service.

        /// <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. Den sista metoden som ska läggas till i den här klassen krävs för att visa meddelandet i scenen:

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

    Anteckning

    Du kan se ett fel i Unity Editor Console om att klassen SceneOrganiser saknas. Ignorera det här meddelandet eftersom du kommer att skapa den här klassen senare i självstudien.

  13. Se till att spara ändringarna i Visual Studio innan du återgår till Unity.

Kapitel 11 – Skapa klassen Interaktioner

Klassen som du ska skapa nu kallas Interaktioner. Den här klassen används för att identifiera HoloLens Tap Input från användaren.

Om användaren trycker på när han eller hon tittar på robotobjektet i scenen och roboten är redo att lyssna efter röstindata, ändrar robotobjektet färg till röd och börjar lyssna efter röstindata.

Den här klassen ärver från klassen GazeInput och kan därför referera till metoden Start() och variabler från den klassen, som anges med hjälp av bas.

Så här skapar du den här klassen:

  1. Dubbelklicka på mappen Skript för att öppna den.

  2. Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Ge skriptet namnet Interaktioner.

  3. Dubbelklicka på det nya skriptet för att öppna det med Visual Studio.

  4. Uppdatera namnrymderna och klassarvet så att de är samma som följande överst i klassen Interaktioner:

    using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{

  5. I klassen Interaktioner lägger du till följande variabel:

        /// <summary>
    /// Allows input recognition with the HoloLens
    /// </summary>
    private GestureRecognizer _gestureRecognizer;

  6. Lägg sedan till metoden 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. Lägg till den hanterare som utlöses när användaren utför tryckgesten framför HoloLens-kameran

        /// <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. Se till att spara ändringarna i Visual Studio innan du återgår till Unity.

Kapitel 12 – Skapa klassen SceneOrganiser

Den sista klassen som krävs i den här labbuppgiften kallas SceneOrganiser. Den här klassen konfigurerar scenen programmatiskt genom att lägga till komponenter och skript i huvudkameran och skapa lämpliga objekt i scenen.

Så här skapar du den här klassen:

  1. Dubbelklicka på mappen Skript för att öppna den.

  2. Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Ge skriptet namnet SceneOrganiser.

  3. Dubbelklicka på det nya skriptet för att öppna det med Visual Studio.

  4. Lägg till följande variabler i klassen SceneOrganiser :

        /// <summary>
    /// Static instance of this class
    /// </summary>
    public static SceneOrganiser Instance;

    /// <summary>
    /// The 3D text representing the Bot response
    /// </summary>
    internal TextMesh botResponseText;

  5. Lägg sedan till metoderna Awake() och 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. Lägg till följande metod som ansvarar för att skapa robotobjektet i scenen och konfigurera parametrarna och komponenterna:

        /// <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. Lägg till följande metod, som ansvarar för att skapa UI-objektet i scenen, som representerar svaren från roboten:

        /// <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. Se till att spara ändringarna i Visual Studio innan du återgår till Unity.

  9. I Unity-redigeraren drar du Skriptet SceneOrganiser från mappen Skript till huvudkameran. Komponenten Scene Organizerr bör nu visas på huvudkameraobjektet, enligt bilden nedan.

    Skärmbild som visar skriptet Scene Organizerr som läggs till i huvudkameraobjektet i Unity-redigeraren.

Kapitel 13 – Innan du bygger

Om du vill utföra ett grundligt test av ditt program måste du läsa in det separat på HoloLens. Innan du gör det kontrollerar du att:

  • Alla inställningar som anges i kapitel 4 är korrekt inställda.
  • Skriptet SceneOrganiser är kopplat till huvudkameraobjektet .
  • I robotklassen kontrollerar du att du har infogat din robothemlighetsnyckel i variabeln botSecret .

Kapitel 14 – Skapa och läsa in separat till HoloLens

Allt som behövs för Unity-avsnittet i det här projektet har nu slutförts, så det är dags att bygga det från Unity.

  1. Gå till Bygginställningar, Inställningar för filbygge > ....

  2. I fönstret Build Settings (Bygginställningar) klickar du på Build (Skapa).

    Skapa appen från Unity

  3. Om du inte redan gjort det markerar du Unity C#-projekt.

  4. Klicka på Skapa. Unity startar ett Utforskaren fönster där du behöver skapa och väljer sedan en mapp som appen ska byggas in i. Skapa mappen nu och ge den namnet App. Klicka sedan på Välj mappnär appmappen är markerad.

  5. Unity börjar skapa projektet i mappen App .

  6. När Unity har byggt klart (det kan ta lite tid) öppnas ett Utforskaren fönster på platsen för bygget (kontrollera aktivitetsfältet eftersom det kanske inte alltid visas ovanför fönstren, men meddelar dig om att ett nytt fönster har lagts till).

Kapitel 15 – Distribuera till HoloLens

Så här distribuerar du på HoloLens:

  1. Du behöver IP-adressen för din HoloLens (för fjärrdistribution) och för att säkerställa att HoloLens är i utvecklarläge. Gör så här:

    1. När du har på dig HoloLens öppnar du Inställningar.
    2. Gå till Avancerade alternativ för Nätverk & Internet > Wi-Fi >
    3. Anteckna IPv4-adressen .
    4. Gå sedan tillbaka till Inställningar och sedan till Uppdatera & Säkerhet > för utvecklare
    5. Ställ in Utvecklarläge på.

  2. Gå till din nya Unity-version (mappen App ) och öppna lösningsfilen med Visual Studio.

  3. I Lösningskonfiguration väljer du Felsök.

  4. I Lösningsplattform väljer du x86, Fjärrdator.

    Distribuera lösningen från Visual Studio.

  5. Gå till menyn Skapa och klicka på Distribuera lösning för att läsa in programmet separat till HoloLens.

  6. Din app bör nu visas i listan över installerade appar på HoloLens, redo att startas!

    Anteckning

    Om du vill distribuera till integrerande headset ställer du in Lösningsplattform på Lokal dator och ställer in Konfiguration på Felsök med x86 som Plattform. Distribuera sedan till den lokala datorn med hjälp av menyn Skapa och välj Distribuera lösning.

Kapitel 16 – Använda programmet på HoloLens

  • När du har startat programmet ser du roboten som en blå sfär framför dig.

  • Använd tryckgesten medan du tittar på sfären för att initiera en konversation.

  • Vänta tills konversationen startar (användargränssnittet visar ett meddelande när det händer). När du får det inledande meddelandet från roboten trycker du igen på roboten så att den blir röd och börjar lyssna på din röst.

  • När du slutar prata skickar programmet meddelandet till roboten och du får snabbt ett svar som visas i användargränssnittet.

  • Upprepa processen för att skicka fler meddelanden till roboten (du måste trycka varje gång du vill känna av ett meddelande).

Den här konversationen visar hur roboten kan behålla information (ditt namn), samtidigt som den tillhandahåller känd information (till exempel de artiklar som finns i lager).

Några frågor att ställa till roboten:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Ditt färdiga webbappsrobotprogram (v4)

Grattis! Du har skapat en mixed reality-app som använder Azure Web App Bot Microsoft Bot Framework v4.

Slutprodukt

Bonusövningar

Övning 1

Konversationsstrukturen i den här labbuppgiften är mycket grundläggande. Använd Microsoft LUIS för att ge roboten funktioner för förståelse av naturligt språk.

Övning 2

Det här exemplet omfattar inte att avsluta en konversation och starta om en ny. Om du vill att robotfunktionen ska slutföras kan du försöka implementera stängning av konversationen.