HoloLens (1. generace) a Azure 312: Integrace robota

Poznámka

Kurzy Mixed Reality Academy byly navrženy s ohledem na HoloLens (1. generace) a Mixed Reality Asistivní náhlavní soupravy. Proto se domníváme, že je důležité ponechat tyto kurzy pro vývojáře, kteří stále hledají pokyny k vývoji pro tato zařízení. Tyto kurzy nebudou aktualizovány nejnovějšími sadami nástrojů nebo interakcemi používanými pro HoloLens 2. Budou zachovány, aby mohly pokračovat v práci na podporovaných zařízeních. V budoucnu bude k dispozici nová série kurzů, které předvedou, jak vyvíjet pro HoloLens 2. Toto oznámení bude aktualizováno odkazem na tyto kurzy, jakmile budou publikovány.

V tomto kurzu se naučíte vytvořit a nasadit robota pomocí Microsoft Bot Framework V4 a komunikovat s ním prostřednictvím Windows Mixed Reality aplikace.

Microsoft Bot Framework V4 je sada rozhraní API navržená tak, aby vývojářům poskytovala nástroje k vytvoření rozšiřitelné a škálovatelné aplikace robota. Další informace najdete na stránce Microsoft Bot Framework nebo v úložišti Git verze 4.

Po dokončení tohoto kurzu vytvoříte Windows Mixed Reality aplikaci, která bude umět následující:

1. Pomocí gesta klepnutím spusťte robota, který naslouchá hlasu uživatelů.
2. Když uživatel něco řekl, robot se pokusí poskytnout odpověď.
3. Zobrazte odpověď robotů jako text umístěný v blízkosti robota ve scéně Unity.

Ve vaší aplikaci je na vás, jak do návrhu integrujete výsledky. Tento kurz je navržený tak, aby vás naučil integrovat službu Azure s projektem Unity. Vaším úkolem je využít znalosti, které z tohoto kurzu získáte, k vylepšení aplikace hybridní reality.

Podpora zařízení

Kurz	HoloLens	Imerzivní náhlavní soupravy
MR a Azure 312: Integrace robota	✔️	✔️

Poznámka

I když se tento kurz primárně zaměřuje na HoloLens, můžete také použít to, co se v tomto kurzu naučíte, k Windows Mixed Reality imerzivní náhlavní soupravy (VR). Vzhledem k tomu, že imerzivní náhlavní soupravy (VR) nemají přístupné kamery, budete potřebovat externí kameru připojenou k počítači. V průběhu kurzu uvidíte poznámky ke všem změnám, které možná budete muset použít pro podporu imerzivních náhlavních souprav (VR).

Požadavky

Poznámka

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

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

• Vývojový počítač kompatibilní s Windows Mixed Reality pro vývoj imerzivních náhlavních souprav (VR)
• Windows 10 Fall Creators Update (nebo novější) s povoleným vývojářským režimem
• Nejnovější sada Windows 10 SDK
• Unity 2017.4
• Visual Studio 2017
• Náhlavní souprava Windows Mixed Reality imerzivní (VR) nebo Microsoft HoloLens s povoleným vývojářským režimem
• Přístup k internetu pro Azure a pro načítání robota Azure. Další informace najdete na tomto odkazu.

Než začnete

1. Aby nedocházelo k problémům při sestavování tohoto projektu, důrazně doporučujeme vytvořit projekt uvedený v tomto kurzu v kořenové nebo téměř kořenové složce (dlouhé cesty ke složkám můžou způsobovat problémy v době sestavení).
2. Nastavte a otestujte HoloLens. Pokud potřebujete podporu při nastavování HoloLensu, navštivte článek o nastavení HoloLensu.
3. Při zahájení vývoje nové aplikace HoloLens je vhodné provést kalibraci a ladění senzorů (někdy může pomoct provádět tyto úlohy pro každého uživatele).

Nápovědu k kalibraci najdete na tomto odkazu v článku Kalibrace HoloLens.

Pokud potřebujete pomoc s laděním senzorů, postupujte podle tohoto odkazu na článek o ladění snímačů HoloLens.

Kapitola 1 – Vytvoření aplikace robota

Prvním krokem je vytvoření robota jako místní webové aplikace ASP.Net Core. Jakmile ho dokončíte a otestujete, publikujete ho na webu Azure Portal.

1. Otevřete sadu Visual Studio. Vytvořte nový projekt, jako typ projektu vyberte Webová aplikace ASP NET Core (najdete ho v pododdílu .NET Core) a nazvěte ho MyBot. Klikněte na OK.

2. V okně, které se zobrazí, vyberte Prázdné. Ujistěte se také, že je cíl nastavený na ASP NET Core 2.0 a ověřování je nastavené na Bez ověřování. Klikněte na OK.

   

3. Řešení se teď otevře. V Průzkumník řešení klikněte pravým tlačítkem na Řešení Mybot a klikněte na Spravovat balíčky NuGet pro řešení.

   

4. Na kartě Procházet vyhledejte Microsoft.Bot.Builder.Integration.AspNet.Core (ujistěte se, že je zaškrtnuté políčko Zahrnout předběžnou verzi ). Vyberte balíček verze 4.0.1-preview a zaškrtněte políčka projektu. Pak klikněte na Nainstalovat. Teď jste nainstalovali knihovny potřebné pro Bot Framework v4. Zavřete stránku NuGet.

   

5. V Průzkumník řešení klikněte pravým tlačítkem na projektMyBot a klikněte na Přidat|třídu.

   

6. Pojmenujte třídu MyBot a klikněte na Přidat.

   

7. Opakováním předchozího bodu vytvořte další třídu s názvem ConversationContext.

8. Klikněte pravým tlačítkem na wwwroot v Průzkumník řešení a klikněte na Přidat|novou položku. Vyberte Stránka HTML (najdete ji v pododdílu Web). Pojmenujte soubor default.html. Klikněte na Přidat.

   

9. Seznam tříd a objektů v Průzkumník řešení by měl vypadat jako na následujícím obrázku.

   

10. Poklikejte na třídu ConversationContext . Tato třída zodpovídá za udržování proměnných, které robot používá k udržování kontextu konverzace. Tyto kontextové hodnoty konverzace jsou zachovány v instanci této třídy, protože každá instance třídy MyBot se aktualizuje při každém přijetí aktivity. Do třídy přidejte následující kód:

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

11. Poklikejte na třídu MyBot . Tato třída bude hostovat obslužné rutiny volané jakoukoli příchozí aktivitou od zákazníka. V této třídě přidáte kód použitý k vytvoření konverzace mezi robotem a zákazníkem. Jak bylo zmíněno dříve, instance této třídy je inicializována při každém přijetí aktivity. Do této třídy přidejte následující kód:

    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. Poklikejte na třídu Startup . Tato třída inicializuje robota. Do třídy přidejte následující kód:

    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. Otevřete soubor třídy Program a ověřte, že kód v něm je stejný jako následující:

    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. Nezapomeňte uložit změny. Uděláte to tak, že na panelu nástrojů v horní části sady Visual Studio přejdete na Soubor>Uložit vše.

Kapitola 2 – Vytvoření azure Bot Service

Teď, když jste vytvořili kód robota, musíte ho publikovat do instance služby Web App Bot Service na webu Azure Portal. V této kapitole se dozvíte, jak vytvořit a nakonfigurovat Bot Service v Azure a pak do něj publikovat kód.

1. Nejprve se přihlaste k webu Azure Portal (https://portal.azure.com).

   1. Pokud ještě nemáte účet Azure, budete si ho muset vytvořit. Pokud tento kurz sledujete v situaci ve třídě nebo testovacím prostředí, požádejte o pomoc s nastavením nového účtu svého instruktora nebo některého z specialistů.

2. Po přihlášení klikněte v levém horním rohu na Vytvořit prostředek , vyhledejte Web App Bot a klikněte na Enter.

   

3. Na nové stránce bude popis služby Web App Bot Service. V levém dolním rohu této stránky vyberte tlačítko Vytvořit a vytvořte přidružení k této službě.

   

4. Po kliknutí na Vytvořit:

   1. Vložte požadovaný název pro tuto instanci služby.

   2. Vyberte předplatné.

   3. Zvolte skupinu prostředků nebo vytvořte novou. Skupina prostředků poskytuje způsob, jak monitorovat, řídit přístup, zřizovat a spravovat fakturaci kolekce prostředků Azure. Doporučujeme udržovat všechny služby Azure přidružené k jednomu projektu (např. tyto kurzy) ve společné skupině prostředků.

      Pokud si chcete přečíst další informace o skupinách prostředků Azure, použijte tento odkaz.

   4. Určete umístění vaší skupiny prostředků (pokud vytváříte novou skupinu prostředků). Umístění by v ideálním případě bylo v oblasti, ve které by se aplikace spustila. Některé prostředky Azure jsou dostupné jenom v určitých oblastech.

   5. Vyberte cenovou úroveň , která je pro vás vhodná. Pokud vytváříte službu Web App Bot Service poprvé, měla by vám být k dispozici bezplatná úroveň (s názvem F0).

   6. Název aplikace může zůstat stejný jako název robota.

   7. Ponechte šablonu robota jako základní (C#).

   8. Plán služby App Service nebo umístění by měly být pro váš účet automaticky vyplněné.

   9. Nastavte Službu Azure Storage , kterou chcete použít k hostování robota. Pokud ho ještě nemáte, můžete ho tady vytvořit.

   10. Budete také muset potvrdit, že rozumíte podmínkám a ujednáním, které se na tuto službu vztahují.

   11. Klikněte na Vytvořit.

       

5. Po kliknutí na Vytvořit budete muset počkat na vytvoření služby, což může chvíli trvat.

6. Po vytvoření instance služby se na portálu zobrazí oznámení.

   

7. Kliknutím na oznámení prozkoumejte novou instanci služby.

   

8. V oznámení klikněte na tlačítko Přejít k prostředku a prozkoumejte novou instanci služby. Budete přesměrováni na novou instanci služby Azure.

   

9. V tomto okamžiku musíte nastavit funkci s názvem Direct Line, která klientské aplikaci umožní komunikovat s tímto Bot Service. Klikněte na Kanály a pak v části Přidat doporučený kanál klikněte na Konfigurovat Direct Line kanál.

   

10. Na této stránce najdete tajné klíče , které umožní ověření klientské aplikace pomocí robota. Klikněte na tlačítko Zobrazit a pořiďte kopii jednoho ze zobrazených klíčů, protože to budete potřebovat později v projektu.

    

Kapitola 3 – Publikování robota do webové aplikace Azure Bot Service

Teď, když je služba připravená, musíte publikovat kód robota, který jste vytvořili dříve, do nově vytvořené webové aplikace Bot Service.

Poznámka

Robota budete muset publikovat ve službě Azure Service pokaždé, když provedete změny v řešení nebo kódu robota.

1. Zpět řešení sady Visual Studio, které jste vytvořili dříve.

2. Klikněte pravým tlačítkem na projekt MyBot v Průzkumník řešení a pak klikněte na Publikovat.

   

3. Na stránce Vyberte cíl publikování klikněte na App Service, pak vyberte Existující a nakonec klikněte na Vytvořit profil (možná budete muset kliknout na šipku rozevíracího seznamu vedle tlačítka Publikovat, pokud ho nevidíte).

   

4. Pokud ještě nejste přihlášení ke svému účtu Microsoft, musíte to udělat tady.

5. Na stránce Publikovat zjistíte, že musíte nastavit stejné předplatné , které jste použili k vytvoření služby Web App Bot Service. Pak nastavte Zobrazit jako skupinu prostředků a ve struktuře složek rozevíracího seznamu vyberte skupinu prostředků , kterou jste vytvořili dříve. Klikněte na OK.

   

6. Teď klikněte na tlačítko Publish (Publikovat ) a počkejte, až se robot publikuje (může to trvat několik minut).

   

Kapitola 4 – Nastavení projektu Unity

Následující příklad je typickým nastavením pro vývoj s hybridní realitou a jako takový je dobrou šablonou pro jiné projekty.

1. Otevřete Unity a klikněte na Nový.

   

2. Teď budete muset zadat název projektu Unity. Vložte robota HoloLens. Ujistěte se, že je šablona projektu nastavená na 3D. Umístění nastavte na místo, které je pro vás vhodné (nezapomeňte, že lepší je blíž ke kořenovým adresářům). Potom klikněte na Vytvořit projekt.

   

3. Když je Unity otevřená, stojí za to zkontrolovat, jestli je výchozí Editor skriptů nastavený na Visual Studio. Přejděte na Upravit > předvolby a v novém okně přejděte na Externí nástroje. Změňte Editor externích skriptů na Visual Studio 2017. Zavřete okno Předvolby .

   

4. Pak přejděte na Nastavení sestavení souboru>, vyberte Univerzální platforma Windows a pak kliknutím na tlačítko Přepnout platformu svůj výběr použijte.

   

5. Zůstaňte v nastavení sestavení souboru > a ujistěte se, že:

   1. Cílové zařízení je nastavené na HoloLens.

      U imerzivních náhlavních souprav nastavte Cílové zařízení na Libovolné zařízení.

   2. Typ sestavení je nastavený na D3D.

   3. Sada SDK je nastavená na nejnovější nainstalovanou verzi.

   4. Verze sady Visual Studio je nastavená na nejnovější nainstalovanou verzi

   5. Sestavení a spuštění je nastavené na místní počítač.

   6. Uložte scénu a přidejte ji do sestavení.

      1. Uděláte to tak, že vyberete Přidat otevřené scény. Zobrazí se okno pro uložení.

         

      2. Vytvořte novou složku pro tuto a jakoukoli budoucí scénu a pak vyberte tlačítko Nová složka a vytvořte novou složku s názvem Scény.

         

      3. Otevřete nově vytvořenou složku Scény , do textového pole Název souboru: zadejte BotScene a klikněte na Uložit.

         

   7. Zbývající nastavení v nastavení sestavení by prozatím měla zůstat ve výchozím nastavení.

6. V okně Build Settings (Nastavení sestavení ) klikněte na tlačítko Player Settings (Nastavení přehrávače ). Tím se otevře související panel v prostoru, kde se inspektor nachází.

   

7. Na tomto panelu je potřeba ověřit několik nastavení:

   1. Na kartě Další nastavení :

      1. Skriptovací modul runtime verze by měla být experimentální (EKVIVALENT NET 4.6); Změna tohoto nastavení bude vyžadovat restartování editoru.

      2. Skriptovací back-end by měl být .NET.

      3. Úroveň kompatibility rozhraní API by měla být .NET 4.6.

         

   2. Na kartě Nastavení publikování v části Schopnosti zaškrtněte:

      • InternetClient

      • Mikrofon

        

   3. Dále na panelu v Nastavení XR (najdete pod nastavením publikování) zaškrtněte možnost Virtuální realita podporována a ujistěte se, že je přidaná sada SDK Windows Mixed Reality.

      

8. Zpět v nastavení sestaveníProjekty Unity C# už nejsou neaktivní; zaškrtněte políčko vedle této položky.

9. Zavřete okno Nastavení sestavení.

10. Uložte scénu a projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Kapitola 5 – Nastavení kamery

Důležité

Pokud chcete komponentu Unity Set up v tomto kurzu přeskočit a pokračovat přímo do kódu, můžete si stáhnout tento balíček Azure-MR-312-Package.unitypackage, naimportovat ho do projektu jako vlastní balíček a pak pokračovat od Kapitoly 7.

1. Na panelu Hierarchie vyberte hlavní kameru.

2. Po výběru uvidíte na panelu inspektoru všechny součásti hlavní kamery.

   1. Objekt Kamera musí mít název Hlavní kamera (všimněte si pravopisu).
   2. Značka hlavní kamery musí být nastavená na MainCamera (všimněte si pravopisu).
   3. Ujistěte se, že je pozice transformace nastavená na 0, 0, 0.
   4. Nastavte Vymazat příznaky na plnou barvu.
   5. Nastavte Barvu pozadí komponenty Kamera na Černá, Alfa 0 (šestnáctkový kód: #000000000).

   

Kapitola 6 – Import knihovny Newtonsoft

Chcete-li pomoci deserializovat a serializovat objekty přijaté a odeslané do Bot Service musíte stáhnout knihovnu Newtonsoft. Kompatibilní verzi, která je už uspořádaná se správnou strukturou složek Unity, najdete tady.

K importu knihovny Newtonsoft do projektu použijte balíček Unity, který byl součástí tohoto kurzu.

1. Přidejte soubor .unitypackage do Unity pomocí možnostinabídky Vlastní balíčekimportu balíčků>prostředků>.

   

2. V okně Import Unity Package (Importovat balíček Unity ), které se zobrazí, zkontrolujte, že je vybrané všechno v části Plugins (a včetně).

   

3. Kliknutím na tlačítko Importovat přidejte položky do projektu.

4. V zobrazení projektu přejděte do složky Newtonsoft v části Moduly plug-in a vyberte modul plug-in Newtonsoft.

   

5. S newtonsoft plugin vybraný, ujistěte se, že Any Platform je nezaškrtnutá, pak se ujistěte, že WSAPlayer je také nezaškrtnutá, a pak klikněte na Použít. Stačí jenom ověřit, jestli jsou soubory správně nakonfigurované.

   

   Poznámka

   Označení těchto modulů plug-in se nakonfiguruje tak, aby se používaly jenom v Unity Editoru. Ve složce WSA je jiná sada, která se použije po exportu projektu z Unity.

6. Dále musíte otevřít složku WSA ve složce Newtonsoft . Zobrazí se kopie stejného souboru, který jste právě nakonfigurovali. Vyberte soubor a pak se v inspektoru ujistěte, že

   • Libovolná platforma není zaškrtnutá.
   • Je zaškrtnutpouzeWSAPlayer
   • Je zaškrtnuto políčko Nezpracovát.

   

Kapitola 7 – Vytvoření botTag

1. Vytvořte nový objekt Tag s názvem BotTag. Vyberte hlavní kameru ve scéně. Klikněte na rozevírací nabídku Značka na panelu inspektoru. Klikněte na Přidat značku.

   

2. Klikněte na + symbol. Pojmenujte novou značku jako BotTag, Uložit.

   

Upozornění

NepoužívejtebotTag na hlavní kameru. Pokud jste to udělali omylem, nezapomeňte změnit značku Hlavní kamera zpět na MainCamera.

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

První skript, který musíte vytvořit, je třída BotObjects , což je prázdná třída vytvořená tak, aby bylo možné uložit řadu dalších objektů třídy ve stejném skriptu a přistupovat k němu z jiných skriptů ve scéně.

Vytvoření této třídy je čistě volbou architektury. Tyto objekty můžou být místo toho hostované ve skriptu robota, který vytvoříte později v tomto kurzu.

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

1. Klikněte pravým tlačítkem na panel Projekt a pak na Vytvořit > složku. Složku pojmenujte Scripts.

   

2. Poklikáním na složku Scripts ji otevřete. Pak v této složce klikněte pravým tlačítkem myši a vyberte Vytvořit > skript jazyka C#. Skript pojmenujte BotObjects.

3. Poklikáním na nový skript BotObjects ho otevřete v sadě Visual Studio.

4. Odstraňte obsah skriptu a nahraďte ho následujícím kódem:

   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. Před návratem do Unity nezapomeňte uložit změny v sadě Visual Studio.

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

Další třída, kterou chcete vytvořit, je třída GazeInput . Tato třída zodpovídá za:

• Vytvoření kurzoru, který bude představovat pohled hráče.
• Detekce objektů zasažených pohledem hráče a držení odkazu na zjištěné objekty.

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

1. Přejděte do složky Scripts , kterou jste vytvořili dříve.

2. Klikněte pravým tlačítkem do složky Vytvořit > skript jazyka C#. Zavolejte skript GazeInput.

3. Poklikáním na nový skript GazeInput ho otevřete v sadě Visual Studio.

4. Vpravo nad název třídy vložte následující řádek:

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

5. Pak přidejte následující proměnné do třídy GazeInput nad metodu 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. Měl by se přidat kód metody Start(). Toto se zavolá, když třída inicializuje:

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

7. Implementujte metodu, která vytvoří instanci a nastaví kurzor pohledu:

       /// <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. Implementujte metody, které nastaví Raycast z hlavní kamery a budou sledovat aktuální objekt s fokusem.

       /// <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. Před návratem do Unity nezapomeňte uložit změny v sadě Visual Studio.

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

Skript, který teď vytvoříte, se nazývá Bot. Toto je základní třída vaší aplikace, která ukládá:

• Vaše přihlašovací údaje Web App Bota
• Metoda, která shromažďuje hlasové příkazy uživatele
• Metoda nezbytná k zahájení konverzací s web app botem
• Metoda potřebná k odesílání zpráv do web app bota

Pokud chcete odesílat zprávy do Bot Service, sestaví korutina SendMessageToBot() aktivitu, což je objekt, který Bot Framework rozpozná jako data odeslaná uživatelem.

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

1. Poklikáním na složku Scripts ji otevřete.

2. Klikněte pravým tlačítkem do složky Scripts (Skripty ) a klikněte na Create C# Script (Vytvořit > skript jazyka C#). Skript pojmenujte Robot.

3. Poklikáním na nový skript ho otevřete v sadě Visual Studio.

4. V horní části třídy Bot aktualizujte obory názvů tak, aby byly stejné jako v následujícím příkladu:

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

5. Do třídy Robot přidejte následující proměnné:

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

   Poznámka

   Nezapomeňte vložit tajný klíč robota do proměnné botSecret . Tajný klíč robota jste si poznamenali na začátku tohoto kurzu v kapitole 2, krok 10.

6. Teď je potřeba přidat kód pro Probuzené() a Start( ).

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

7. Přidejte dvě obslužné rutiny, které knihovny řeči volají při zahájení a ukončení záznamu hlasu. DictationRecognizer automaticky zastaví zachytávání hlasu uživatele, když uživatel přestane mluvit.

       /// <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. Následující obslužná rutina shromáždí výsledek uživatelského hlasového vstupu a zavolá korutin zodpovědný za odeslání zprávy do webové aplikace 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. Zavolá se následující korutina, která zahájí konverzaci s robotem. Všimněte si, že po dokončení hovoru konverzace zavolá SendMessageToCoroutine() předáním řady parametrů, které nastaví aktivitu, která se má odeslat do Bot Service jako prázdná zpráva. To se provádí tak, aby se Bot Service zobrazila výzva k zahájení dialogu.

       /// <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. Volá se následující korutina, která sestaví aktivitu, která se má odeslat do 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. Volá se následující korutina, která požaduje odpověď po odeslání aktivity do 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. Poslední metoda, která má být přidána do této třídy, je nutná k zobrazení zprávy ve scéně:

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

    Poznámka

    V konzole Unity Editoru se může zobrazit chyba týkající se chybějící třídy SceneOrganiser . Tuto zprávu ignorujte, protože tuto třídu vytvoříte později v tomto kurzu.

13. Před návratem do Unity nezapomeňte uložit změny v sadě Visual Studio.

Kapitola 11 – Vytvoření třídy Interactions

Třída, kterou teď vytvoříte, se nazývá Interakce. Tato třída se používá ke zjištění vstupu HoloLens Tap od uživatele.

Pokud uživatel klepne při pohledu na objekt robota ve scéně a robot je připravený naslouchat hlasovým vstupům, změní se barva objektu robota na červenou a začne naslouchat hlasovým vstupům.

Tato třída dědí z GazeInput třídy, a proto je schopna odkazovat na Metodu Start() a proměnné z této třídy, označené použitím base.

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

1. Poklikáním na složku Scripts ji otevřete.

2. Klikněte pravým tlačítkem do složky Scripts (Skripty ) a klikněte na Create C# Script (Vytvořit > skript jazyka C#). Skript pojmenujte Interakce.

3. Poklikáním na nový skript ho otevřete v sadě Visual Studio.

4. V horní části třídy Interactions aktualizujte obory názvů a dědičnost tříd tak, aby byly stejné jako v následujícím příkladu:

   using UnityEngine.XR.WSA.Input;
   
   public class Interactions : GazeInput
   {
   

5. Do třídy Interactions přidejte následující proměnnou:

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

6. Pak přidejte metodu 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. Přidejte obslužnou rutinu, která se aktivuje, když uživatel před kamerou HoloLens provede gesto klepnutí.

       /// <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. Před návratem do Unity nezapomeňte uložit změny v sadě Visual Studio.

Kapitola 12 – Vytvoření třídy SceneOrganiser

Poslední třída požadovaná v tomto cvičení se nazývá SceneOrganiser. Tato třída programově nastaví scénu přidáním komponent a skriptů do hlavní kamery a vytvořením příslušných objektů ve scéně.

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

1. Poklikáním na složku Scripts ji otevřete.

2. Klikněte pravým tlačítkem do složky Scripts (Skripty ) a klikněte na Create C# Script (Vytvořit > skript jazyka C#). Skript pojmenujte SceneOrganiser.

3. Poklikáním na nový skript ho otevřete v sadě Visual Studio.

4. Do třídy SceneOrganiser přidejte následující proměnné:

       /// <summary>
       /// Static instance of this class
       /// </summary>
       public static SceneOrganiser Instance;
   
       /// <summary>
       /// The 3D text representing the Bot response
       /// </summary>
       internal TextMesh botResponseText;
   

5. Pak přidejte metody Awake() a 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. Přidejte následující metodu, která je zodpovědná za vytvoření objektu Bot ve scéně a nastavení parametrů a komponent:

       /// <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. Přidejte následující metodu, která je zodpovědná za vytvoření objektu uživatelského rozhraní ve scéně představující odpovědi od robota:

       /// <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. Před návratem do Unity nezapomeňte uložit změny v sadě Visual Studio.

9. V Unity Editoru přetáhněte skript SceneOrganiser ze složky Scripts do hlavní kamery. Komponenta Organizátor scény by se teď měla objevit na objektu hlavní kamery, jak je znázorněno na následujícím obrázku.

   

Kapitola 13 – Před zahájením stavby

Pokud chcete provést důkladný test aplikace, budete ji muset zkušebně načíst do HoloLensu. Než to uděláte, ujistěte se, že:

• Všechna nastavení uvedená v kapitole 4 jsou nastavena správně.
• Skript SceneOrganiser je připojený k objektu Hlavní kamera .
• Ve třídě Robot se ujistěte, že jste do proměnné botSecret vložili tajný klíč robota.

Kapitola 14 – Sestavení a zkušební načtení HoloLensu

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

1. Přejděte na Nastavení sestavení, Nastavení sestavení souboru > ....

2. V okně Nastavení sestavení klikněte na Sestavit.

   

3. Pokud tomu tak ještě není, zaškrtněte políčko Projekty Unity C#.

4. Klikněte na Sestavit. Unity spustí Průzkumník souborů okno, ve kterém musíte vytvořit a vybrat složku, do které chcete aplikaci sestavit. Vytvořte teď složku a pojmenujte ji App. Pak s vybranou složkou Aplikace klikněte na Vybrat složku.

5. Unity začne váš projekt vytvářet do složky Aplikace .

6. Jakmile Unity dokončí sestavování (může to nějakou dobu trvat), otevře se okno Průzkumník souborů v umístění sestavení (zkontrolujte hlavní panel, protože se nemusí vždy zobrazovat nad okny, ale upozorní vás na přidání nového okna).

Kapitola 15 – Nasazení do HoloLensu

Nasazení na HoloLens:

1. Budete potřebovat IP adresu vašeho HoloLensu (pro vzdálené nasazení) a zajistit, aby byl HoloLens ve vývojářském režimu. Použijte následující postup:

   1. Při nošení HoloLensu otevřete Nastavení.
   2. Přejděte na Upřesnit možnosti síťového & internetu > Wi-Fi>.
   3. Poznamenejte si adresu IPv4 .
   4. Pak přejděte zpět na Nastavení a pak na Aktualizace zabezpečení > & pro vývojáře.
   5. Nastavte režim vývojáře na Zapnuto.

2. Přejděte do nového sestavení Unity (složka Aplikace ) a otevřete soubor řešení v sadě Visual Studio.

3. V části Konfigurace řešení vyberte Ladit.

4. Na platformě řešení vyberte x86, Vzdálený počítač.

   

5. Přejděte do nabídky Sestavení a klikněte na Nasadit řešení a načtěte aplikaci do HoloLensu bokem.

6. Vaše aplikace by se teď měla zobrazit v seznamu nainstalovaných aplikací na HoloLensu a měla by být připravená ke spuštění.

   Poznámka

   Pokud chcete nasazení nasadit do imerzivní náhlavní soupravy, nastavte Platformu řešení na Místní počítač a konfiguraci nastavte na Ladění s platformou x86. Pak proveďte nasazení na místní počítač pomocí nabídky Sestavení a vyberte Nasadit řešení.

Kapitola 16 – Používání aplikace na HoloLensu

• Jakmile aplikaci spustíte, uvidíte robota jako modrou kouli před vámi.

• Pomocí gesta klepnutí při pohledu na kouli zahajte konverzaci.

• Počkejte, až konverzace začne (uživatelské rozhraní zobrazí zprávu, když k tomu dojde). Jakmile od robota obdržíte úvodní zprávu, klepněte na robota znovu, aby zčervenal a začal poslouchat váš hlas.

• Jakmile přestanete mluvit, aplikace odešle zprávu robotovi a okamžitě obdržíte odpověď, která se zobrazí v uživatelském rozhraní.

• Opakováním postupu odešlete robotovi další zprávy (musíte klepnout pokaždé, když chcete zprávu odeslat).

Tato konverzace ukazuje, jak může robot uchovávat informace (vaše jméno) a zároveň poskytuje známé informace (například skladované položky).

Robotovi je třeba položit několik otázek:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Dokončená aplikace Web App Bot (v4)

Blahopřejeme, vytvořili jste aplikaci pro hybridní realitu, která využívá Azure Web App Bot, Microsoft Bot Framework v4.

Bonusová cvičení

Cvičení 1

Struktura konverzace v tomto cvičení je velmi základní. Pomocí Služby Microsoft LUIS můžete robotovi poskytnout možnosti porozumění přirozenému jazyku.

Cvičení 2

Tento příklad nezahrnuje ukončení konverzace a restartování nové konverzace. Pokud chcete funkci robota dokončit, zkuste implementovat uzavření konverzace.