HoloLens (1. generace) a Azure 312: Integrace robotů

Poznámka

Kurzy Mixed Reality Academy byly navrženy s HoloLens (1. generace) a Mixed Reality na imerzivní náhlavní soupravy. Proto si myslíme, že je důležité ponechat tyto kurzy na místě pro vývojáře, kteří stále hledají pokyny při vývoji těchto zařízení. Tyto kurzy nebudou aktualizovány nejnovějšími sady nástrojů nebo interakcemi používanými pro HoloLens 2. Budou zachovány, aby pokračovaly v práci na podporovaných zařízeních. V budoucnu bude k dispozici nová série kurzů, které předvede vývoj pro HoloLens 2. Toto oznámení bude aktualizováno odkazem na tyto kurzy, když jsou publikovány.

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

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

Po dokončení tohoto kurzu budete mít vytvořenou Windows Mixed Reality, která bude moct provést následující akce:

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

V aplikaci je na vás, jak budete integrovat výsledky s vaším návrhem. 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ískáte z tohoto kurzu, k vylepšení aplikace hybridní reality.

Podpora zařízení

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

Poznámka

I když se tento kurz zaměřuje především HoloLens, můžete také použít to, co se v tomto kurzu naučíte, Windows Mixed Reality imerzivní náhlavní soupravy (VR). Vzhledem k tomu, že imerzivní náhlavní soupravy (VR) nemají přístupné kamery, budete k počítači potřebovat externí fotoaparát. Jak budete postupovat podle kurzu, uvidíte poznámky ke 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#. Upozorňujeme také, že požadavky a napsané pokyny v tomto dokumentu představují to, co bylo otestováno a ověřeno v době psaní tohoto dokumentu (červenec 2018). Můžete používat nejnovější software, jak je uvedeno v článku o instalaci nástrojů, i když se předpokládá, že informace v tomto kurzu budou dokonale odpovídat informacím, které najdete v novějším softwaru, než je uvedeno níže.

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

Než začnete

  1. Pokud se chcete vyhnout problémům se sestavováním tohoto projektu, důrazně doporučujeme vytvořit projekt uvedený v tomto kurzu v kořenové nebo blízké kořenové složce (dlouhé cesty ke složce mohou způsobit problémy v době sestavení).
  2. Nastavení a otestování HoloLens. Pokud potřebujete podporu k nastavení HoloLens, nezapomeňte navštívit článek o HoloLens instalaci.
  3. Při zahájení vývoje nové aplikace pro HoloLens je vhodné provést ladění senzorů a senzorů (někdy může být vhodné tyto úlohy provést pro každého uživatele).

Pokud chcete pomoct s nesnázmi, použijte tento odkaz na článek HoloLens a chystění.

Pokud chcete pomoc s laděním senzorů, použijte tento odkaz na článek HoloLens ladění senzorů.

Kapitola 1 – Vytvoření aplikace robota

Prvním krokem je vytvoření robota jako místní webové aplikace ASP.Net Core. Po dokončení a otestování ho publikujete na webu Azure Portal.

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

  2. V okně, které se zobrazí, vyberte Prázdné. Také se ujistěte, ž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.

    Vytvoření aplikace robota

  3. Řešení se teď otevře. Klikněte pravým tlačítkem na Solution Mybot (Můj robotřešení) v Průzkumník řešení a pak klikněte na Manage NuGet Packages for Solution (Spravovat balíčky NuGet pro řešení).

    Vytvoření aplikace robota

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

    Vytvoření aplikace robota

  5. Klikněte pravým tlačítkem na Project, MyBot, v okně Průzkumník řešení klikněte na Přidattřídu.

    Vytvoření aplikace robota

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

    Vytvoření aplikace robota

  7. Opakujte předchozí bod a vytvořte další třídu s názvem ConversationContext.

  8. V okně klikněte pravým tlačítkem na wwwroota Průzkumník řešenína Přidatnovou položku. Vyberte Html Page (najdete ji pod pododdílem Web). Pojmete soubordefault.html. Klikněte na Přidat.

    Vytvoření aplikace robota

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

    Vytvoření aplikace robota

  10. Dvakrát klikněte na třídu ConversationContext. Tato třída zodpovídá za udržování proměnných používaných robotem k udržování kontextu konverzace. Tyto hodnoty kontextu konverzace se udržují 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. Dvakrát klikněte na třídu MyBot. Tato třída bude hostovat obslužné rutiny, které volá jakákoli příchozí aktivita od zákazníka. V této třídě přidáte kód použitý k sestavení konverzace mezi robotem a zákazníkem. Jak už 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. Dvakrát klikněte 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 souboru 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 provedené změny uložit a přejděte na Soubor Uložit vše na panelu nástrojů v horní části Visual Studio.

Kapitola 2 – Vytvoření Azure Bot Service

Teď, když jste pro robota sestaví kód, ho musíte 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 službu bot Service v Azure a jak do ní publikovat kód.

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

    1. Pokud ještě nemáte účet Azure, budete ho muset vytvořit. Pokud tento kurz vydržíte v situaci učebny nebo testovacího prostředí, požádejte svého vyučujícího nebo jednoho z proctors o pomoc s nastavením nového účtu.
  2. Po přihlášení klikněte v levém horním rohu na vytvořit prostředek , vyhledejte bot webové aplikacea klikněte na ENTER.

    Vytvoření Azure Bot Service

  3. Nová stránka vám poskytne popis služby Web App bot . V levém dolním rohu této stránky vyberte tlačítko vytvořit , chcete-li vytvořit přidružení s touto službou.

    Vytvoření Azure Bot Service

  4. Po kliknutí na vytvořit:

    1. Vložte požadovaný název této instance služby.

    2. Vyberte předplatné.

    3. Vyberte skupinu prostředků nebo vytvořte novou. Skupina prostředků nabízí způsob, jak monitorovat, řídit přístup, zřizovat a spravovat fakturace pro kolekci prostředků Azure. Doporučuje se udržovat všechny služby Azure přidružené k jednomu projektu (například k těmto kurzům) v rámci společné skupiny prostředků.

      Pokud si chcete přečíst další informace o skupinách prostředků Azure, postupujte prosím podle tohoto odkazu .

    4. Určete umístění pro skupinu prostředků (Pokud vytváříte novou skupinu prostředků). Umístění by v ideálním případě mělo být v oblasti, kde se aplikace spustí. Některé prostředky Azure jsou dostupné jenom v určitých oblastech.

    5. Vyberte si cenovou úroveň , která je pro vás vhodná, pokud se jedná o první vytvoření služby Web App bot Service, k dispozici je bezplatná úroveň (s názvem F0).

    6. Název aplikace může být jenom vlevo jako název bot.

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

    8. Pro váš účet by měl být automaticky vyplněn plán nebo umístění služby App Service .

    9. nastavte Azure Storage , který chcete použít k hostování robota. Pokud už ho nemáte, můžete ho vytvořit tady.

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

    11. Klikněte na Vytvořit.

      Vytvoření Azure Bot Service

  5. Po kliknutí na vytvořitbudete muset počkat na vytvoření služby, což může trvat několik minut.

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

    Vytvoření Azure Bot Service

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

    Vytvoření Azure Bot Service

  8. Kliknutím na tlačítko Přejít k prostředku v oznámení můžete prozkoumat novou instanci služby. Přejdete na novou instanci služby Azure.

    Vytvoření Azure Bot Service

  9. V tomto okamžiku je potřeba nastavit funkci s názvem Direct line , aby klientská aplikace mohla komunikovat s touto službou bot. Klikněte na kanálya potom v části přidat vybraný kanál klikněte na Konfigurace přímého kanálu.

    Vytvoření Azure Bot Service

  10. Na této stránce najdete tajné klíče , které umožní vaší klientské aplikaci ověřit pomocí robota. Klikněte na tlačítko Zobrazit a poznamenejte si jeden ze zobrazených klíčů, protože ho budete potřebovat později v projektu.

    Vytvoření Azure Bot Service

Kapitola 3 – publikování robotu ve službě Azure Web App bot Service

Teď, když je vaše služba připravená, musíte publikovat svůj kód robota, který jste vytvořili dříve, do nově vytvořené služby bot webové aplikace.

Poznámka

Když budete dělat změny v řešení nebo kódu robota, budete muset svůj robot publikovat do služby Azure.

  1. vraťte se do vašeho řešení 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.

    Publikujte robota ve službě Azure Web App bot

  3. Na stránce Vyberte cíl publikování klikněte na App Servicea pak Vyberte existující, nakonec klikněte na tlačítko vytvořit profil (Pokud není tato možnost viditelná), klikněte na šipku rozevíracího seznamu vedle tlačítka publikovat .

    Publikujte robota ve službě Azure Web App bot

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

  5. Na stránce publikovat budete muset nastavit stejné předplatné , které jste použili pro vytvoření služby Web App bot . Pak nastavte Zobrazit jako skupinu prostředků a ve struktuře složky rozevíracího seznamu vyberte skupinu prostředků , kterou jste předtím vytvořili. Klikněte na OK.

    Publikujte robota ve službě Azure Web App bot

  6. Nyní klikněte na tlačítko publikovat a počkejte na publikování robota (může to trvat několik minut).

    Publikujte robota ve službě Azure Web App bot

Kapitola 4 – nastavení projektu Unity

Toto je typická sada pro vývoj se smíšenými realitami a jako taková je dobrá šablona pro jiné projekty.

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

    Nastavení projektu Unity

  2. Teď budete muset zadat název projektu Unity. vložte HoloLens robot. Ujistěte se, že je šablona projektu nastavená na 3D. Nastavte umístění , které je pro vás vhodné (Nezapomeňte, že blíž ke kořenovým adresářům je lepší). Pak klikněte na vytvořit projekt.

    Nastavení projektu Unity

  3. V případě, že je aplikace Unity otevřená, je nutné zkontrolovat, že výchozí Editor skriptů je nastaven na Visual Studio. Přejděte na Upravit Předvolby a pak z nového okna přejděte k externím nástrojům. změňte Editor externích skriptů na Visual Studio 2017. Zavřete okno Předvolby .

    Nastavení projektu Unity

  4. potom přejděte na soubor Build Nastavení a vyberte Univerzální platforma Windowsa potom klikněte na tlačítko přepnout platformu a použijte výběr.

    Nastavení projektu Unity

  5. pořád ještě v sestavování souborů Nastavení a ujistěte se, že:

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

      U moderních sluchátek můžete nastavit cílové zařízení na libovolné zařízení.

    2. Typ sestavení je nastavený na D3D .

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

    4. verze Visual Studio je nastavená na nejnovější instalaci .

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

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

      1. To uděláte tak, že vyberete Přidat otevřené scény. Zobrazí se okno Uložit.

        Nastavení projektu Unity

      2. Vytvořte novou složku pro toto a všechny budoucí, scény a pak vyberte tlačítko Nová složka , abyste vytvořili novou složku, pojmenujte ji na scéně.

        Nastavení projektu Unity

      3. Otevřete nově vytvořenou složku scény a potom do textového pole název souboru: zadejte BotScenea klikněte na Uložit.

        Nastavení projektu Unity

    7. zbývající nastavení v Nastavení sestaveníby měla být nyní ponechána jako výchozí.

  6. v okně sestavit Nastavení klikněte na tlačítko Nastavení přehrávače , tím se otevře související panel v prostoru, kde se nachází kontroler .

    Nastavení projektu Unity

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

    1. na druhé kartě Nastavení :

      1. Verze skriptovacího modulu runtime by měla být experimentální (NET 4,6 ekvivalent); Tato změna 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 .

        Nastavení projektu Unity

    2. na kartě Nastavení publikování v části možnostizaškrtněte:

      • InternetClient

      • Mikrofon

        Nastavení projektu Unity

    3. v dolní části okna XR Nastavení (v části publikovat Nastavení) se podporuje virtuální realitatick. zajistěte, aby se přidala Windows Mixed Reality SDK .

      Nastavení projektu Unity

  8. zpět v sestavách NastaveníprojektůUnity v jazyce C# již není šedá; zaškrtněte políčko vedle něj.

  9. zavřete okno Build Nastavení.

  10. Uložte scénu a projekt (soubor uložte scénu/soubor > uložení projektu).

Kapitola 5 – nastavení kamery

Důležité

Pokud chcete Přeskočit komponentu tohoto kurzu, která je součástí tohoto kurzu, a pokračovat přímo do kódu, můžete 312si ho stáhnout do svého projektu jako vlastní balíčeka potom pokračovat v kapitole 7.

  1. Na panelu hierarchievyberte hlavní fotoaparát.

  2. Po výběru budete moci zobrazit všechny součásti hlavní kamery na panelu inspektora.

    1. Objekt kamery musí být pojmenovaný hlavní fotoaparát (Poznamenejte si jeho pravopis).
    2. Hlavní značka kamery musí být nastavená na MainCamera (Všimněte si pravopisu).
    3. Ujistěte se, že je pozice transformace nastavena na 0, 0, 0 .
    4. Nastavte volbu Clear Flags na Solid Color.
    5. Nastaví barvu pozadí komponenty Camera na černou, alpha 0 (šestnáctkový kód: #00000000).

    Nastavení kamery

Kapitola 6 – import knihovny Newtonsoft

Abychom vám pomohli deserializaci a serializaci objektů přijatých a odeslaných do služby bot, potřebujete stáhnout knihovnu Newtonsoft . Kompatibilní verze, která je už uspořádaná se správnou strukturou složek Unity, najdete tady.

Pokud chcete importovat knihovnu Newtonsoft do svého projektu, použijte balíček Unity, který jste dostali v tomto kurzu.

  1. Přidejte soubor . unitypackage do Unity pomocí možnosti nabídky pro vlastní balíček assetsImport Package .

    Import knihovny Newtonsoft

  2. V poli importovat balíček Unity , které se zobrazí, se ujistěte, že je vybraná možnost všechny moduly plug-in (a včetně).

    Import knihovny Newtonsoft

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

  4. V zobrazení projektu v části moduly plug -in klikněte na složku Newtonsoft a vyberte modul plug-in Newtonsoft.

  5. Když je vybraný modul plug-in Newtonsoft, ujistěte se, že není zaškrtnutážádná z těchto platforem , a pak se ujistěte, že je WSAPlayer také nezaškrtnuté, a pak klikněte na použít. Stačí jenom potvrdit, že jsou soubory správně nakonfigurované.

    Poznámka

    Označení těchto modulů plug-in je nakonfiguruje tak, aby se používalo pouze v editoru Unity. Ve složce WSA je jiná sada, která bude použita po exportu projektu z Unity.

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

    • Žádná platforma není zaškrtnuta .
    • je zaškrtnutopouzeWSAPlayer .
    • Je zaškrtnutýproces není potřeba

Kapitola 7 – vytvoření BotTag

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

    Nastavení kamery

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

    Nastavení kamery

Upozornění

NeaplikujteBotTag na hlavní kameru. Pokud jste to omylem provedli, nezapomeňte změnit hlavní značku kamery zpět na MainCamera.

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

Prvním skriptem, který je třeba vytvořit, je třída BotObjects , která je prázdnou třídou vytvořenou tak, aby bylo možné uložit řadu jiných objektů třídy do stejného skriptu a k nim přistupovaly jiné skripty ve scéně.

Vytvoření této třídy je čistě výběr architektury, tyto objekty by se místo toho daly hostovat ve skriptu robota, který vytvoříte později v tomto kurzu.

Chcete-li vytvořit tuto třídu:

  1. klikněte pravým tlačítkem myši na panel Projecta pak vytvořte složku. Pojmenujte skriptysložky.

    Vytvořit složku skriptů.

  2. Dvojím kliknutím na složku skripty ji otevřete. Potom v této složce klikněte pravým tlačítkem myši a vyberte možnost vytvořit skript jazyka C#. Pojmenujte skript BotObjects.

  3. Dvojím kliknutím na nový skript BotObjects ho otevřete pomocí 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 Unitynezapomeňte změny v Visual Studio uložit.

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

Další třídou, kterou budete vytvářet, je třída GazeInput . Tato třída zodpovídá za:

  • Vytvoření kurzoru, který bude představovat pohledu přehrávače.
  • Zjišťování objektů, které dosáhla pohledu přehrávače a držení odkazu na zjištěné objekty.

Chcete-li vytvořit tuto třídu:

  1. Přejít do složky skripty , kterou jste vytvořili dříve.

  2. Klikněte pravým tlačítkem myši do složky a vytvořte skript jazyka C#. Zavolejte skript GazeInput.

  3. Dvojím kliknutím na nový skript GazeInput ho otevřete pomocí Visual Studio.

  4. Do názvu třídy vložte následující řádek vpravo:

    /// <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é dovnitř 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ěla by být přidána metoda Code for Start () . Tato akce bude volána při inicializaci třídy:

        /// <summary>
        /// Start method used upon initialization.
        /// </summary>
        internal virtual void Start()
        {
            FocusedObject = null;
            Cursor = CreateCursor();
        }
    
  7. Implementujte metodu, která bude vytvářet instance a nastavení pohledu kurzoru:

        /// <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 zaměření.

        /// <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 Unitynezapomeňte změny v Visual Studio uložit.

Kapitola 10 – vytvoření třídy bot

Skript, který se chystáte nyní vytvořit, se nazývá bot. Toto je základní třída vaší aplikace, kterou ukládá:

  • Přihlašovací údaje pro robota webové aplikace
  • Metoda, která shromažďuje hlasové příkazy uživatele
  • Metoda nutná k zahájení konverzace s robotem webové aplikace
  • Metoda, která se potřebuje k posílání zpráv na robot vaší webové aplikace

Chcete-li odesílat zprávy do služby bot, korutina SendMessageToBot () vytvoří aktivitu, což je objekt rozpoznaný rozhraním bot Framework jako data odesílaná uživatelem.

Chcete-li vytvořit tuto třídu:

  1. Dvojím kliknutím na složku skripty ji otevřete.

  2. Klikněte pravým tlačítkem myši do složky skripty a pak klikněte na možnost vytvořit skript v jazyce C#. Pojmenujte robotaskriptu.

  3. Dvojím kliknutím na nový skript otevřete ho pomocí Visual Studio.

  4. Aktualizujte obory názvů tak, aby byly stejné jako následující, v horní části třídy bot :

    using Newtonsoft.Json;
    using System.Collections;
    using System.Text;
    using UnityEngine;
    using UnityEngine.Networking;
    using UnityEngine.Windows.Speech;
    
  5. Uvnitř třídy robota 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

    Ujistěte se, že jste vložili tajný klíč bot do proměnné botSecret . Na začátku tohoto kurzu jste si poznamenali tajný klíč bot , a to v kapitole 2, krok 10.

  6. Kód pro spuštění () a Start () je nyní nutné přidat.

        /// <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é jsou volány knihovnami řeči při zahájení a ukončení hlasového zachycení. DictationRecognizer automaticky zastaví záznam uživatelského hlasu v případě, že 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 shromažďuje výsledek hlasového vstupu uživatele a volá korutinu, která je odpovědná za odeslání zprávy do služby bot webové aplikace.

        /// <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. K zahájení konverzace s robotem se volá následující korutina. Všimněte si, že po dokončení volání konverzace bude volat SendMessageToCoroutine () předáním řady parametrů, která nastaví aktivitu, která bude odeslána do služby bot jako prázdná zpráva. Tím se zobrazí výzva k zahájení dialogu pro službu bot.

        /// <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. Následující korutina se volá k sestavení aktivity, která se odešle do služby bot.

        /// <summary>
        /// Send the user message to the Bot Service in form of activity
        /// and call for a response
        /// </summary>
        private IEnumerator SendMessageToBot(string message, string fromId, string fromName, string activityType)
        {
            Debug.Log($"SendMessageCoroutine: {conversation.ConversationId}, message: {message} from Id: {fromId} from name: {fromName}");
    
            // Create a new activity here
            Activity activity = new Activity();
            activity.from = new From();
            activity.conversation = new Conversation();
            activity.from.id = fromId;
            activity.from.name = fromName;
            activity.text = message;
            activity.type = activityType;
            activity.channelId = "DirectLineChannelId";
            activity.conversation.id = conversation.ConversationId;     
    
            // Serialize the activity
            string json = JsonConvert.SerializeObject(activity);
    
            string sendActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);
    
            // Send the activity to the Bot
            using (UnityWebRequest www = new UnityWebRequest(sendActivityEndpoint, "POST"))
            {
                www.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));
    
                www.downloadHandler = new DownloadHandlerBuffer();
                www.SetRequestHeader("Authorization", "Bearer " + botSecret);
                www.SetRequestHeader("Content-Type", "application/json");
    
                yield return www.SendWebRequest();
    
                // extrapolate the response Id used to keep track of the conversation
                string jsonResponse = www.downloadHandler.text;
                string cleanedJsonResponse = jsonResponse.Replace("\r\n", string.Empty);
                string responseConvId = cleanedJsonResponse.Substring(10, 30);
    
                // Request a response from the Bot Service
                StartCoroutine(GetResponseFromBot(activity));
            }
        }
    
  11. Následující korutina se volá, aby po odeslání aktivity do služby bot požádala o odpověď.

        /// <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 vyžadována k zobrazení zprávy v 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 editoru Unity se může zobrazit chyba s informacemi o chybějící třídě SceneOrganiser . Tato zpráva se ignoruje, protože tuto třídu vytvoříte později v tomto kurzu.

  13. před návratem do Unitynezapomeňte změny v Visual Studio uložit.

Kapitola 11 – vytvoření třídy interakcí

Třída, kterou se chystáte nyní vytvořit, se nazývá interakce. tato třída slouží k detekci HoloLens klepněte na vstup od uživatele.

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

Tato třída dědí z třídy GazeInput , takže je možné odkazovat na metodu Start () a proměnné z této třídy, označené použitím základny.

Chcete-li vytvořit tuto třídu:

  1. Dvojím kliknutím na složku skripty ji otevřete.

  2. Klikněte pravým tlačítkem myši do složky skripty a pak klikněte na možnost vytvořit skript v jazyce C#. Pojmenujte interakceskriptu.

  3. Dvojím kliknutím na nový skript otevřete ho pomocí Visual Studio.

  4. Aktualizujte obory názvů a dědění třídy tak, aby byly stejné jako následující, v horní části třídy interakcí :

    using UnityEngine.XR.WSA.Input;
    
    public class Interactions : GazeInput
    {
    
  5. Uvnitř třídy interakcí 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 provede gesto klepnutí před fotoaparátem HoloLens.

        /// <summary>
        /// Detects the User Tap Input
        /// </summary>
        private void GestureRecognizer_Tapped(TappedEventArgs obj)
        {
            // Ensure the bot is being gazed upon.
            if(base.FocusedObject != null)
            {
                // If the user is tapping on Bot and the Bot is ready to listen
                if (base.FocusedObject.name == "Bot" && Bot.Instance.botState == Bot.BotState.ReadyToListen)
                {
                    // If a conversation has not started yet, request one
                    if(Bot.Instance.conversationStarted)
                    {
                        Bot.Instance.SetBotResponseText("Listening...");
                        Bot.Instance.StartCapturingAudio();
                    }
                    else
                    {
                        Bot.Instance.SetBotResponseText("Requesting Conversation...");
                        StartCoroutine(Bot.Instance.StartConversation());
                    }                                  
                }
            }
        }
    
  8. před návratem do Unitynezapomeňte změny v Visual Studio uložit.

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

Poslední třída požadovaná v tomto testovacím prostředí se nazývá SceneOrganiser. Tato třída nastaví scénu pomocí kódu programu, přidáním komponent a skriptů do hlavní kamery a vytvořením příslušných objektů na scéně.

Chcete-li vytvořit tuto třídu:

  1. Dvojím kliknutím na složku skripty ji otevřete.

  2. Klikněte pravým tlačítkem myši do složky skripty a pak klikněte na možnost vytvořit skript v jazyce C#. Pojmenujte skript SceneOrganiser.

  3. Dvojím kliknutím na nový skript otevřete ho pomocí Visual Studio.

  4. Uvnitř 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 Start () 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 odpovědná za vytvoření objektu bot na scéně a nastavení parametrů a součástí:

        /// <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 odpovědná za vytvoření objektu uživatelského rozhraní ve scéně, reprezentující odpovědi z 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 Unitynezapomeňte změny v Visual Studio uložit.

  9. V editoru Unity přetáhněte skript SceneOrganiser ze složky Scripts do hlavního fotoaparátu. Komponenta organizátora scény by se teď měla zobrazit na hlavním objektu kamery, jak je znázorněno na obrázku níže.

    Vytvoření Azure Bot Service

Kapitola 13 – před sestavením

Chcete-li provést důkladný test aplikace, budete ji muset bokem na své HoloLens. 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 hlavnímu objektu kamery .
  • Ve třídě robota se ujistěte, že jste vložili tajný klíč bot do proměnné botSecret .

Kapitola 14 – sestavení a bokem do HoloLens

Vše potřebné pro oddíl Unity tohoto projektu se teď dokončilo, takže je čas ho sestavit z Unity.

  1. přejděte k sestavení Nastavení, sestavování souborů Nastavení....

  2. v okně Build Nastavení klikněte na sestavit.

    Sestavení aplikace z Unity

  3. Pokud ještě není, provedli jsme projekty jazyka C#ve osové Unity.

  4. Klikněte na sestavit. Unity spustí okno Průzkumníka souborů , ve kterém je potřeba vytvořit a pak vybrat složku, do které se má aplikace sestavit. Vytvořte tuto složku nyní a pojmenujte ji v aplikaci. Pak vyberte složku aplikace a klikněte na Vybrat složku.

  5. Unity začne sestavovat projekt ve složce aplikace .

  6. Po sestavení Unity (může nějakou dobu trvat) se otevře okno Průzkumníka souborů v umístění sestavení (zkontroluje panel úloh, protože se nemusí vždy zobrazovat nad Windows, ale upozorní vás na přidání nového okna).

Kapitola 15 – nasazení do HoloLens

Nasazení na HoloLens:

  1. budete potřebovat IP adresu vašeho HoloLens (pro vzdálené nasazení) a zajistěte, aby byl váš HoloLens v režimu pro vývojáře. Použijte následující postup:

    1. při používání HoloLens otevřete Nastavení.
    2. Přejít na Možnosti sítě Internet > Wi-Fi > Upřesnit možnosti
    3. Poznamenejte si adresu IPv4 .
    4. dále přejděte zpět na Nastavenía pak aktualizujte zabezpečení pro vývojáře .
    5. Nastavte režim pro vývojáře na.
  2. Přejděte k novému buildu Unity (složka aplikace ) a otevřete soubor řešení pomocí Visual Studio.

  3. V konfiguraci řešení vyberte ladit.

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

    Nasazení řešení z Visual Studio.

  5. Přejděte do nabídky sestavení a kliknutím na nasadit řešeníbokem aplikaci do svého HoloLens.

  6. vaše aplikace by se teď měla zobrazit v seznamu nainstalovaných aplikací na vašem HoloLens, které je připravené k jejímu spuštění.

    Poznámka

    Pro nasazení na moderní sluchátka s mikrofonem nastavte platformu řešení na místní počítača nastavte konfiguraci pro laděnís platformou x86 jako platformou. Pak na místní počítač nasaďte pomocí nabídky sestavita vyberte nasadit řešení.

Kapitola 16 – použití aplikace na HoloLens

  • Po spuštění aplikace se na začátku zobrazí robot jako modrá koule.

  • Použijte gesto klepnutí , když jste gazing na koule k zahájení konverzace.

  • Počkejte, až se konverzace spustí (uživatelské rozhraní zobrazí zprávu, když se stane). Jakmile obdržíte úvodní zprávu od robota, klepněte na robota znovu, aby se zapnula červená a začne naslouchat vašemu hlasu.

  • Po ukončení hovoru vaše aplikace odešle vaši zprávu na robota a zobrazí se výzva, že se zobrazí odpověď, která se zobrazí v uživatelském rozhraní.

  • Opakujte tento postup pro odeslání dalších zpráv na robota (pokaždé, když chcete zprávu odslat).

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

Některé otázky pro vyžádání robota:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Vaše dokončená aplikace webové aplikace bot (v4)

blahopřejeme, vytvořili jste aplikaci pro hybridní realitu, která využívá robota webové aplikace Azure Microsoft Bot Framework v4.

Finální produkt

Bonusová cvičení

Cvičení 1

Struktura konverzace v tomto testovacím prostředí je velmi základní. Využijte Microsoft LUISe k poskytnutí možností porozumění vašemu přirozenému jazyku robotům.

Cvičení 2

Tento příklad nezahrnuje ukončení konverzace a nové restartování. Pokud chcete, aby se funkce robota dokončila, zkuste implementovat uzavření do konverzace.