HoloLens (1. generációs) és Azure 312: Robotintegráció

Cikk
01/17/2024

Megjegyzés

A Mixed Reality Academy oktatóanyagait a HoloLens (1. generációs) és Mixed Reality modern headsetekkel tervezték. Ezért fontosnak tartjuk, hogy ezeket az oktatóanyagokat megtartsuk azoknak a fejlesztőknek, akik továbbra is útmutatást keresnek az eszközök fejlesztéséhez. Ezek az oktatóanyagok nem frissülnek az HoloLens 2 legújabb eszközkészleteivel vagy interakcióival. A támogatott eszközökön való munka folytatásához megmaradnak. A jövőben egy új oktatóanyag-sorozat jelenik meg, amely bemutatja, hogyan fejleszthet HoloLens 2. Ezt az értesítést a közzétételükkor az oktatóanyagokra mutató hivatkozással frissítjük.

Ebben a kurzusban megtudhatja, hogyan hozhat létre és helyezhet üzembe egy robotot a Microsoft Bot Framework V4 használatával, és hogyan kommunikálhat vele egy Windows Mixed Reality alkalmazáson keresztül.

Képernyőkép egy Windows Mixed Reality alkalmazáson keresztüli kommunikációról.

A Microsoft Bot Framework V4 api-k olyan készlete, amely a fejlesztők számára biztosítja a bővíthető és méretezhető robotalkalmazások létrehozásához szükséges eszközöket. További információt a Microsoft Bot Framework oldalon vagy a V4 Git-adattárban talál.

A tanfolyam elvégzése után létre fog hozni egy Windows Mixed Reality alkalmazást, amely a következőket fogja tudni elvégezni:

Koppintson a kézmozdulatra, és indítsa el a robotot a felhasználók hangjának figyeléséhez.
Amikor a felhasználó mondott valamit, a robot megpróbál választ adni.
A robot válaszának megjelenítése szövegként, a robot közelében, a Unity Jelenetben.

Az alkalmazásban ön múlik, hogyan fogja integrálni az eredményeket a tervével. Ez a kurzus arra szolgál, hogy megtanítsa, hogyan integrálhat egy Azure-szolgáltatást a Unity-projekttel. Az Ön feladata, hogy felhasználja a tanfolyamból megszerzett tudást a vegyes valóság alkalmazásának továbbfejlesztéséhez.

Eszköztámogatás

Tanfolyam	HoloLens	Modern headsetek
MR és Azure 312: Robotintegráció	✔️	✔️

Megjegyzés

Bár ez a kurzus elsősorban a HoloLensre összpontosít, a tanfolyam során tanultakat alkalmazhatja Windows Mixed Reality magával ragadó (VR) fejhallgatókra is. Mivel a modern (VR) headsetek nem rendelkeznek akadálymentes kamerával, szüksége lesz egy külső kamerára, amely csatlakoztatva van a számítógéphez. Ahogy követi a tanfolyamot, jegyzeteket fog látni azokról a változásokról, amelyeket esetleg alkalmaznia kell a modern (VR) headsetek támogatásához.

Előfeltételek

Megjegyzés

Ez az oktatóanyag olyan fejlesztőknek készült, akik alapszintű tapasztalattal rendelkeznek a Unityben és a C#-ben. Felhívjuk a figyelmét arra is, hogy a jelen dokumentumban foglalt előfeltételek és írásos utasítások azt felelnek meg, amit az íráskor (2018. július) teszteltek és ellenőriztek. Szabadon használhatja a legújabb szoftvert, ahogy az az eszközök telepítéséről szóló cikkben szerepel, bár nem szabad feltételezni, hogy a tanfolyam információi tökéletesen megfelelnek az újabb szoftverekben található információknak, mint az alább felsoroltak.

A tanfolyamhoz a következő hardvereket és szoftvereket ajánljuk:

A modern (VR) headset fejlesztéséhez használható Windows Mixed Reality kompatibilis fejlesztőszámítógép
Windows 10 Fall Creators Update (vagy újabb) a fejlesztői mód engedélyezésével
A legújabb Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Egy Windows Mixed Reality modern (VR) headset vagy Microsoft HoloLens, amelyen engedélyezve van a fejlesztői mód
Internet-hozzáférés az Azure-hoz és az Azure Bot lekéréséhez. További információért kövesse ezt a hivatkozást.

Előkészületek

A projekt létrehozásával kapcsolatos problémák elkerülése érdekében javasoljuk, hogy hozza létre az oktatóanyagban említett projektet egy gyökér- vagy gyökérmappában (a hosszú mappaútvonalak buildeléskor problémákat okozhatnak).
A HoloLens beállítása és tesztelése. Ha támogatásra van szüksége a HoloLens beállításához, feltétlenül látogasson el a HoloLens beállítási cikkére.
Érdemes kalibrálást és érzékelőhangolást végezni egy új HoloLens-alkalmazás fejlesztésének megkezdésekor (néha segíthet az egyes felhasználók számára elvégezni ezeket a feladatokat).

Ha segítségre van szüksége a kalibráláshoz, kövesse ezt a hivatkozást a HoloLens-kalibrációs cikkhez.

Az érzékelőhangolással kapcsolatos segítségért kövesse ezt a hivatkozást a HoloLens érzékelőhangolásról szóló cikkére.

1. fejezet – A robotalkalmazás létrehozása

Az első lépés a robot helyi ASP.Net Core-webalkalmazásként való létrehozása. Miután befejezte és tesztelte, közzé fogja tenni az Azure Portalon.

Nyissa meg a Visual Studiót. Hozzon létre egy új projektet, válassza ki az ASP NET Core webalkalmazást projekttípusként (a .NET Core alszakaszban megtalálja), és hívja meg MyBot néven. Kattintson az OK gombra.
A megjelenő ablakban válassza az Üres lehetőséget. Győződjön meg arról is, hogy a cél az ASP NET Core 2.0 , a Hitelesítés pedig Nincs hitelesítés értékre van állítva. Kattintson az OK gombra.
Ekkor megnyílik a megoldás. Kattintson a jobb gombbal a Megoldás mybot elemre a Megoldáskezelő, majd kattintson a Megoldáshoz készült NuGet-csomagok kezelése elemre.
A Tallózás lapon keressen rá a Microsoft.Bot.Builder.Integration.AspNet.Core kifejezésre (győződjön meg arról, hogy a Kiadás előtti belefoglalás jelölőnégyzet be van jelölve). Jelölje ki a csomag 4.0.1-es előzetes verzióját, és jelölje be a projektmezők jelölőnégyzetét. Ezután kattintson a Telepítés elemre. Telepítette a Bot Framework v4-hez szükséges kódtárakat. Zárja be a NuGet lapot.
Kattintson a jobb gombbal a projektre, a MyBotra a Megoldáskezelő, majd kattintson azAdd Class (Osztályhozzáadása|) elemre.
Nevezze el a MyBot osztályt, és kattintson a Hozzáadás gombra.
Ismételje meg az előző pontot, és hozzon létre egy másik , ConversationContext nevű osztályt.
Kattintson a jobb gombbal a wwwroot elemre a Megoldáskezelő, és kattintson az Új elem hozzáadása|parancsra. Válassza a HTML-lap lehetőséget (a web alszakaszban találja). Nevezze el a fájlt default.html. Kattintson a Hozzáadás parancsra.
A Megoldáskezelő osztályainak/objektumainak listájának az alábbi képhez hasonlóan kell kinéznie.
Kattintson duplán a ConversationContext osztályra. Ez az osztály felel a robot által a beszélgetés környezetének fenntartásához használt változók megtartásáért. Ezek a beszélgetési környezeti értékek az osztály egy példányában vannak fenntartva, mivel a MyBot osztály bármely példánya minden alkalommal frissül, amikor egy tevékenység érkezik. Adja hozzá a következő kódot az osztályhoz:
```
namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}
```

Kattintson duplán a MyBot osztályra. Ez az osztály az ügyféltől érkező bejövő tevékenységek által meghívott kezelőket fogja üzemeltetni. Ebben az osztályban hozzáadja a robot és az ügyfél közötti beszélgetés létrehozásához használt kódot. Ahogy korábban említettük, ennek az osztálynak egy példánya inicializálódik minden alkalommal, amikor egy tevékenység érkezik. Adja hozzá a következő kódot ehhez az osztályhoz:

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?");
            }

        }
    }
}

Kattintson duplán az Indítási osztályra. Ez az osztály inicializálja a robotot. Adja hozzá a következő kódot az osztályhoz:

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();
        }
    }
}

Nyissa meg a Program osztályfájlt, és ellenőrizze, hogy a benne lévő kód megegyezik-e az alábbival:

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();
    }
}

Ne felejtse el menteni a módosításokat, ehhez nyissa meg az Összes fájl>mentése elemet a Visual Studio tetején található eszköztáron.

2. fejezet – Az Azure Bot Service létrehozása

Most, hogy elkészítette a robot kódját, közzé kell tennie azt a Web App Bot Service egy példányán az Azure Portalon. Ez a fejezet bemutatja, hogyan hozhatja létre és konfigurálhatja a Bot Service az Azure-ban, majd közzéteheti a kódot.

Először jelentkezzen be az Azure Portalra (https://portal.azure.com).
1. Ha még nem rendelkezik Azure-fiókkal, létre kell hoznia egyet. Ha ezt az oktatóanyagot osztályteremben vagy laborhelyzetben követi, kérjen segítséget az oktatótól vagy az egyik proktortól az új fiók beállításához.
Miután bejelentkezett, kattintson az Erőforrás létrehozása elemre a bal felső sarokban, és keresse meg a Webalkalmazás-robotot, majd kattintson az Enter gombra.
Az új oldal a Web App Bot Service leírását adja meg. A lap bal alsó sarkában kattintson a Létrehozás gombra, és hozzon létre társításokat ezzel a szolgáltatással.
Miután a Létrehozás gombra kattintott:
1. Szúrja be a kívánt nevet ehhez a szolgáltatáspéldányhoz.
2. Válasszon ki egy előfizetést.
3. Válasszon egy erőforráscsoportot , vagy hozzon létre egy újat. Az erőforráscsoportok lehetővé teszi az Azure-eszközök gyűjteményéhez tartozó számlázás monitorozását, vezérlését, kiépítését és kezelését. Javasoljuk, hogy az egyetlen projekthez (például a tanfolyamokhoz) társított összes Azure-szolgáltatást egy közös erőforráscsoportban tartsa.
  
  Ha többet szeretne megtudni az Azure-erőforráscsoportokról, kövesse ezt a hivatkozást
4. Határozza meg az erőforráscsoport helyét (ha új erőforráscsoportot hoz létre). A hely ideális esetben abban a régióban lenne, ahol az alkalmazás futna. Egyes Azure-eszközök csak bizonyos régiókban érhetők el.
5. Válassza ki az Önnek megfelelő tarifacsomagot , ha ez az első alkalom, hogy webalkalmazás-robotszolgáltatást hoz létre, akkor egy ingyenes (F0 nevű) szintnek elérhetővé kell lennie az Ön számára
6. Az alkalmazásnév csak a robot nevével megegyező lehet.
7. Hagyja meg a Robot sablontAlapszintű (C#)-ként.
8. Az App Service-csomagnak/helynek automatikusan ki kellett töltenie a fiókját.
9. Állítsa be a robot üzemeltetéséhez használni kívánt Azure Storage-t . Ha még nincs ilyenje, itt hozhatja létre.
10. Azt is meg kell erősítenie, hogy megértette a szolgáltatásra vonatkozó feltételeket.
11. Kattintson a Létrehozás gombra.
Miután a Létrehozás gombra kattintott, meg kell várnia a szolgáltatás létrehozását, ez eltarthat egy percig.
A szolgáltatáspéldány létrehozása után megjelenik egy értesítés a portálon.
Kattintson az értesítésre az új szolgáltatáspéldány megismeréséhez.
Az értesítésben kattintson az Erőforrás megnyitása gombra az új szolgáltatáspéldány megismeréséhez. A rendszer az új Azure Service-példányra nyitja meg.
Ezen a ponton be kell állítania egy Direct Line nevű funkciót, hogy az ügyfélalkalmazás kommunikálhasson ezzel a Bot Service. Kattintson a Csatornák elemre, majd a Kiemelt csatorna hozzáadása szakaszban kattintson a Direct Line csatorna konfigurálása elemre.
Ezen a lapon megtalálja azokat a titkos kulcsokat , amelyek lehetővé teszik az ügyfélalkalmazás számára a robottal való hitelesítést. Kattintson a Megjelenítés gombra, és készítsen másolatot az egyik megjelenített kulcsról, mivel erre később szüksége lesz a projektben.

3. fejezet – A robot közzététele az Azure Web App Bot Service

Most, hogy a szolgáltatás készen áll, közzé kell tennie a korábban létrehozott robotkódot az újonnan létrehozott Web App Bot Service.

Megjegyzés

A robotot minden alkalommal közzé kell tennie az Azure Service-ben, amikor módosítja a Robotmegoldást/ -kódot.

Vissza a korábban létrehozott Visual Studio-megoldáshoz.
Kattintson a jobb gombbal a MyBot-projektre a Megoldáskezelő, majd kattintson a Közzététel parancsra.
A Közzétételi cél kiválasztása lapon kattintson a App Service, majd válassza a Meglévő lehetőséget, végül kattintson a Profil létrehozása elemre (előfordulhat, hogy a Közzététel gomb melletti legördülő nyílra kell kattintania, ha ez nem látható).
Ha még nincs bejelentkezve a Microsoft-fiókjába, itt kell megtennie.
A Közzététel lapon azt az előfizetést kell beállítania, amelyet a Web App Bot Service létrehozásához használt. Ezután állítsa be a Nézeterőforráscsoportként beállítást, és a legördülő mappastruktúrában válassza ki a korábban létrehozott erőforráscsoportot . Kattintson az OK gombra.
Most kattintson a Közzététel gombra, és várja meg a robot közzétételét (eltarthat néhány percig).

4. fejezet – A Unity-projekt beállítása

Az alábbiak egy tipikusan a vegyes valósággal való fejlesztésre szolgálnak, és mint ilyen, jó sablon más projektekhez.

Nyissa meg a Unityt , és kattintson az Új gombra.
Most meg kell adnia egy Unity-projektnevet. HoloLens-robot beszúrása. Győződjön meg arról, hogy a projektsablon 3D értékre van állítva. Állítsa a Hely értékét az Ön számára megfelelő helyre (ne feledje, a gyökérkönyvtárakhoz való közelebb jobb). Ezután kattintson a Projekt létrehozása elemre.
Ha a Unity nyitva van, érdemes ellenőrizni, hogy az alapértelmezett szkriptszerkesztőVisual Studióra van-e állítva. Lépjen a Beállítások szerkesztése > elemre, majd az új ablakból lépjen a Külső eszközök elemre. Módosítsa a Külső szkriptszerkesztőtVisual Studio 2017-re. Zárja be a Beállítások ablakot.
Ezután lépjen a Fájl > buildelési beállításai területre, és válassza a Univerzális Windows-platform lehetőséget, majd kattintson a Platformváltás gombra a kijelölés alkalmazásához.
A fájl > buildelési beállításai között győződjön meg arról, hogy:
1. A céleszközholoLens értékre van állítva
  
  A modern headsetek esetében állítsa a Céleszköz beállítást Bármely eszközre.
2. A build típusaD3D értékre van állítva
3. Az SDK a Legújabb telepített értékre van állítva
4. A Visual Studio verziója a Legújabb telepítve értékre van állítva
5. A buildelés és a futtatáshelyi gépre van állítva
6. Mentse a jelenetet, és adja hozzá a buildhez.
  1. Ehhez válassza a Nyitott jelenetek hozzáadása lehetőséget. Ekkor megjelenik egy mentési ablak.
  2. Hozzon létre egy új mappát ehhez, és minden jövőbeni jelenethez, majd az Új mappa gombra kattintva hozzon létre egy új mappát, és adja neki a Jelenetek nevet.
  3. Nyissa meg az újonnan létrehozott Jelenetek mappát, majd a Fájlnév: szöveg mezőbe írja be a BotScene kifejezést, majd kattintson a Mentés gombra.
7. A buildbeállításokban lévő többi beállításnak egyelőre alapértelmezettnek kell lennie.
A Build Settings (Összeállítási beállítások ) ablakban kattintson a Lejátszó beállításai gombra, ezzel megnyitja a kapcsolódó panelt abban a térben, ahol az Inspector található.
Ebben a panelen ellenőrizni kell néhány beállítást:
1. Az Egyéb beállítások lapon:
  1. A szkriptelési futtatókörnyezet verziójánakkísérletinek kell lennie (NET 4.6-os egyenértékű); a módosításhoz újra kell indítania a Szerkesztőt.
  2. A szkriptelési háttérrendszernek.NET-nek kell lennie
  3. Az API-kompatibilitási szintnek.NET 4.6-osnak kell lennie
2. A Közzétételi beállítások lap Képességek területén ellenőrizze a következőket:
  - InternetClient
  - Mikrofon
3. A panelen lejjebb, az XR-beállítások területen (amely a Közzétételi beállítások alatt található) jelölje be a Virtual Reality Támogatott jelölőnégyzetet, és győződjön meg arról, hogy a Windows Mixed Reality SDK hozzá van adva.
A buildbeállításokban a Unity C#-projektek már nem szürkén jelennek meg; jelölje be a mellette lévő jelölőnégyzetet.
Zárja be a Build Settings (Összeállítási beállítások) ablakot.
Mentse a jelenetet és a projektet (FILE > SAVE SCENE /FILE > SAVE PROJECT).

5. fejezet – Kamera beállítása

Fontos

Ha ki szeretné hagyni a tanfolyam Unity Set up összetevőjét, és közvetlenül a kódban folytatja, töltse le ezt az Azure-MR-312-Package.unitypackage csomagot, importálja a projektbe egyéni csomagként, majd folytassa a 7. fejezettel.

A Hierarchia panelen válassza a Fő kamera lehetőséget.
Miután kiválasztotta, a Fő kamera összes összetevőjét láthatja az Inspector panelen.
1. A Kamera objektumnakfő kamerának kell lennie (jegyezze fel a helyesírást)
2. A fő kameracímkétMainCamera értékre kell állítani (jegyezze fel a helyesírást)
3. Győződjön meg arról, hogy az Átalakítás pozíciója0, 0, 0 értékre van állítva
4. Állítsa a Jelölők törlése beállítást Egyszínűre.
5. Állítsa a Kamera összetevő háttérszínétFekete, Alfa 0 (Hexadecimális kód: #00000000) értékre.

6. fejezet – A Newtonsoft könyvtár importálása

A fogadott és a Bot Service küldött objektumok deszerializálásához és szerializálásához le kell töltenie a Newtonsoft könyvtárat. Itt talál egy kompatibilis verziót, amely már a megfelelő Unity-mappastruktúrával van rendszerezve.

A Newtonsoft kódtár projektbe való importálásához használja a tanfolyamhoz mellékelt Unity-csomagot.

Adja hozzá a .unitypackage fájlt a Unityhez az Eszközök>importálása csomag>egyéni csomag menübeállításával.
A megjelenő Unity-csomag importálása párbeszédpanelen győződjön meg arról, hogy minden elem ki van jelölve a beépülő modulok alatt (és a beépülő modulokat is beleértve).
Kattintson az Importálás gombra az elemek projekthez való hozzáadásához.
A projektnézetben lépjen a Newtonsoft mappába a Beépülő modulok területen, és válassza ki a Newtonsoft beépülő modult.
Ha a Newtonsoft beépülő modul van kiválasztva, győződjön meg arról, hogy a Bármely platformjelölőnégyzet nincs bejelölve, majd győződjön meg arról, hogy a WSAPlayer is nincs bejelölve, majd kattintson az Alkalmaz gombra. Ez csak annak ellenőrzésére, hogy a fájlok megfelelően vannak-e konfigurálva.

Megjegyzés

Ezeknek a beépülő moduloknak a megjelölése úgy konfigurálja őket, hogy csak a Unity-szerkesztőben használhatók legyenek. A WSA mappában különböző halmazok találhatók, amelyeket a projekt Unityből való exportálása után fog használni.
Ezután meg kell nyitnia a WSA mappát a Newtonsoft mappában. Az imént konfigurált fájl másolatát fogja látni. Jelölje ki a fájlt, majd az ellenőrben győződjön meg arról, hogy
- Bármely platformnincs bejelölve
- csaka WSAPlayervan bejelölve
- A dont folyamatbe van jelölve

7. fejezet – A BotTag létrehozása

Hozzon létre egy botTag nevű új Tag objektumot. Válassza ki a fő kamerát a jelenetben. Kattintson a Címke legördülő menüre az Inspector panelen. Kattintson a Címke hozzáadása elemre.
Kattintson a szimbólumra + . Nevezze el az új címkétBotTag, Save néven.

Figyelmeztetés

Ne alkalmazza a BotTaget a fő kamerára. Ha véletlenül ezt tette, ügyeljen arra, hogy a Fő kamera címkét állítsa vissza MainCamera-ra.

8. fejezet – A BotObjects osztály létrehozása

Az első létrehozandó szkript a BotObjects osztály, amely egy üres osztály, amely úgy van létrehozva, hogy más osztályobjektumok sorozata tárolható ugyanazon a szkripten belül, és a jelenet más szkriptjei is hozzáférhessenek.

Ennek az osztálynak a létrehozása kizárólag architekturális választás, ezek az objektumok inkább a robotszkriptben üzemeltethetők, amelyet a tanfolyam későbbi részében fog létrehozni.

Az osztály létrehozása:

Kattintson a jobb gombbal a Projekt panelen, majd válassza a Mappa létrehozása parancsot>. Nevezze el a mappát Szkriptek néven.
Kattintson duplán a Szkriptek mappára a megnyitásához. Ezután a mappában kattintson a jobb gombbal, és válassza a C#-szkript létrehozása >lehetőséget. Nevezze el a botObjects szkriptet.
Kattintson duplán az új BotObjects-szkriptre a Visual Studióval való megnyitásához.

Törölje a szkript tartalmát, és cserélje le a következő kódra:

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

Ne felejtse el menteni a módosításokat a Visual Studióban , mielőtt visszatér a Unitybe.

9. fejezet – A GazeInput osztály létrehozása

A következő létrehozandó osztály a GazeInput osztály. Ez az osztály a következőket végzi el:

Olyan kurzor létrehozása, amely a játékos tekintetét jeleníti meg.
A lejátszó tekintete által eltalált objektumok észlelése, és az észlelt objektumokra mutató hivatkozás.

Az osztály létrehozása:

Nyissa meg a korábban létrehozott Szkriptek mappát.
Kattintson a jobb gombbal a C#-szkript létrehozása >mappába. Hívja meg a GazeInput szkriptet.
Kattintson duplán az új GazeInput szkriptre a Visual Studióval való megnyitásához.

Szúrja be a következő sort közvetlenül az osztály neve fölé:

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

Ezután adja hozzá a következő változókat a GazeInput osztályban a Start() metódus fölé:

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

A Start() metódus kódját hozzá kell adni. Ez a osztály inicializálásakor lesz meghívva:

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

Implementáljon egy metódust, amely példányosít és beállítja a tekintet kurzorát:

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

Implementálja azokat a metódusokat, amelyek beállítják a Raycastot a fő kameráról, és nyomon követi az aktuális szűrt objektumot.

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

Ne felejtse el menteni a módosításokat a Visual Studióban , mielőtt visszatér a Unitybe.

10. fejezet – A robotosztály létrehozása

A most létrehozandó szkript neve Bot. Ez az alkalmazás alapvető osztálya, amely a következőket tárolja:

A webalkalmazás-robot hitelesítő adatai
A felhasználói hangparancsokat gyűjtő metódus
A webalkalmazás-robottal folytatott beszélgetések indításához szükséges módszer
A webalkalmazás-robotnak küldött üzenetek küldéséhez szükséges módszer

Ha üzeneteket szeretne küldeni a Bot Service, a SendMessageToBot() coroutine létrehoz egy tevékenységet, amely a Bot Framework által a felhasználó által küldött adatokként felismert objektum.

Az osztály létrehozása:

Kattintson duplán a Szkriptek mappára a megnyitásához.
Kattintson a jobb gombbal a Szkriptek mappába, és válassza a C#-szkript létrehozása > parancsot. Nevezze el a szkriptrobotot.
Kattintson duplán az új szkriptre a Visual Studióval való megnyitásához.

Frissítse a névtereket úgy, hogy megegyeznek a következővel a Bot osztály tetején:

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

A Bot osztályon belül adja hozzá a következő változókat:

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

Megjegyzés

Győződjön meg arról, hogy beszúrta a Bot Secret-kulcsot a botSecret változóba. A robot titkos kulcsát a tanfolyam elején, a 2. fejezet 10. lépésében jegyezte fel.

Az Awake() és a Start() kódját most hozzá kell adni.

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

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

Adja hozzá a beszédtárak által a hangrögzítés kezdetekor és végén meghívott két kezelőt. A DictationRecognizer automatikusan leállítja a felhasználói hang rögzítését, amikor a felhasználó nem beszél.

    /// <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();
    }

A következő kezelő összegyűjti a felhasználói hangbemenet eredményét, és meghívja az üzenetet a webalkalmazásnak Bot Service küldő coroutine-t.

    /// <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();
    }

A következő coroutine-t hívjuk meg a robottal folytatott beszélgetés megkezdéséhez. Megfigyelheti, hogy a beszélgetési hívás befejezése után a SendMessageToCoroutine() metódust egy paramétersorozat átadásával hívja meg, amely beállítja, hogy a tevékenység üres üzenetként legyen elküldve a Bot Service. Ez arra kéri a Bot Service, hogy kezdeményezhesse a párbeszédet.

    /// <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"));
    }

A rendszer a következő coroutine-t hívja meg a Bot Service küldendő tevékenység létrehozásához.

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

A rendszer a következő coroutine-t hívja meg, hogy választ kérjen egy tevékenység Bot Service való elküldése után.

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

A osztályhoz utolsóként hozzáadni kívánt metódusnak meg kell jelenítenie az üzenetet a jelenetben:
```
    /// <summary>
    /// Set the UI Response Text of the bot
    /// </summary>
    internal void SetBotResponseText(string responseString)
    {        
        SceneOrganiser.Instance.botResponseText.text =  responseString;
    }
```
Megjegyzés

Előfordulhat, hogy a Unity szerkesztőkonzolján hibaüzenet jelenik meg a SceneOrganiser osztály hiányáról. Hagyja figyelmen kívül ezt az üzenetet, mivel ezt az osztályt az oktatóanyag későbbi részében fogja létrehozni.
Ne felejtse el menteni a módosításokat a Visual Studióban , mielőtt visszatér a Unitybe.

11. fejezet – Az Interakciók osztály létrehozása

A most létrehozandó osztály neve Interakciók. Ez az osztály a felhasználó HoloLens-koppintás bemenetének észlelésére szolgál.

Ha a felhasználó a robot objektumának a jelenetben való nézése közben koppint, és a robot készen áll a hangbemenetek figyelésére, a Bot objektum színe pirosra változik, és elkezdi figyelni a hangbemeneteket.

Ez az osztály a GazeInput osztálytól öröklődik, így hivatkozhat a Start() metódusra és az osztály változóira, amelyeket az alap használata jelöl.

Az osztály létrehozása:

Kattintson duplán a Szkriptek mappára a megnyitásához.
Kattintson a jobb gombbal a Szkriptek mappába, és válassza a C#-szkript létrehozása > parancsot. Nevezze el a szkript interactions (Interakciók) nevet.
Kattintson duplán az új szkriptre a Visual Studióval való megnyitásához.
Frissítse a névtereket és az osztályöröklést úgy, hogy azok megegyeznek a következővel az Interactions osztály tetején:
```
using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{
```

Az Interactions osztályon belül adja hozzá a következő változót:

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

Ezután adja hozzá a Start() metódust:

    /// <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();
    }

Adja hozzá azt a kezelőt, amely akkor aktiválódik, amikor a felhasználó a HoloLens kamera előtt végrehajtja a koppintás kézmozdulatát

    /// <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());
                }                                  
            }
        }
    }

Ne felejtse el menteni a módosításokat a Visual Studióban , mielőtt visszatér a Unitybe.

12. fejezet – A SceneOrganiser osztály létrehozása

A laborban az utolsó szükséges osztály neve SceneOrganiser. Ez az osztály programozott módon fogja beállítani a jelenetet úgy, hogy összetevőket és szkripteket ad hozzá a fő kamerához, és létrehozza a megfelelő objektumokat a jelenetben.

Az osztály létrehozása:

Kattintson duplán a Szkriptek mappára a megnyitásához.
Kattintson a jobb gombbal a Szkriptek mappába, és válassza a C#-szkript létrehozása > parancsot. Nevezze el a SceneOrganiser szkriptet.
Kattintson duplán az új szkriptre a Visual Studióval való megnyitásához.

A SceneOrganiser osztályban adja hozzá a következő változókat:

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

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

Ezután adja hozzá az Awake() és a Start() metódust:

    /// <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();
    }

Adja hozzá a következő metódust, amely a Robot objektum létrehozásáért felelős a jelenetben, valamint a paraméterek és összetevők beállításáért:

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

Adja hozzá a következő metódust, amely a felhasználói felület objektumának létrehozásáért felel a jelenetben, amely a robot válaszait képviseli:

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

Ne felejtse el menteni a módosításokat a Visual Studióban , mielőtt visszatér a Unitybe.
A Unity Szerkesztőben húzza a SceneOrganiser szkriptet a Scripts mappából a fő kamerára. A Jelenetszervező összetevőnek most meg kell jelennie a Fő kamera objektumon, ahogy az az alábbi képen is látható.

13. fejezet – Építés előtt

Az alkalmazás alapos teszteléséhez közvetlenül be kell helyeznie a HoloLensre. Mielőtt ezt tenné, győződjön meg arról, hogy:

A 4. fejezetben említett összes beállítás helyesen van beállítva.
A SceneOrganiser szkript a Fő kamera objektumhoz van csatolva.
A Bot osztályban győződjön meg arról, hogy beszúrta a Bot Secret Key kulcsot a botSecret változóba.

14. fejezet – Buildelés és közvetlen telepítés a HoloLenshez

A projekt Unity szakaszához szükséges összes elem elkészült, ezért ideje a Unityből felépíteni.

Lépjen a BuildBeállítások, Fájl > buildelési beállításai... területre.
A Build Settings (Összeállítási beállítások ) ablakban kattintson a Build (Build) elemre.
Ha még nem tette meg, jelölje be a Unity C# Projects elemet.
Kattintson a Build (Build) elemre. A Unity elindít egy Fájlkezelő ablakot, amelyben létre kell hoznia, majd ki kell választania egy mappát az alkalmazás létrehozásához. Hozza létre ezt a mappát most, és nevezze el appnak. Ezután jelölje ki az Alkalmazás mappát, és kattintson a Mappa kiválasztása gombra.
A Unity megkezdi a projekt összeállítását az Alkalmazás mappába.
Miután a Unity befejezte az építést (eltarthat egy ideig), megnyit egy Fájlkezelő ablakot a build helyén (ellenőrizze a tálcát, mivel előfordulhat, hogy nem mindig jelenik meg az ablakok felett, de értesítést küld az új ablak hozzáadásáról).

15. fejezet – Üzembe helyezés a HoloLensben

Üzembe helyezés a HoloLensen:

Szüksége lesz a HoloLens IP-címére (távoli üzembe helyezéshez), és győződjön meg arról, hogy a HoloLens fejlesztői módban van. Ehhez tegye a következőket:
1. A HoloLens viselése közben nyissa meg a Beállításokat.
2. Lépjen a Hálózati & Internet > Wi-Fi > Speciális beállítások elemre
3. Jegyezze fel az IPv4-címet .
4. Ezután lépjen vissza a Beállítások területre, majd a Frissítés & Fejlesztőknek biztonsági > frissítéséhez
5. Állítsa be a fejlesztői módot.
Nyissa meg az új Unity-buildet (az alkalmazásmappát ), és nyissa meg a megoldásfájlt a Visual Studióval.
A Megoldás konfigurációja területen válassza a Hibakeresés lehetőséget.
A Megoldásplatformon válassza az x86, Távoli gép lehetőséget.
Nyissa meg a Build (Build) menüt , és kattintson a Deploy Solution (Megoldás üzembe helyezése) elemre az alkalmazás HoloLensbe való közvetlen telepítéséhez.
Az alkalmazásnak most meg kell jelennie a HoloLens telepített alkalmazásainak listájában, készen áll az indításra!

Megjegyzés

A modern headsetre való üzembe helyezéshez állítsa a MegoldásplatformotHelyi gépre, és állítsa a KonfigurációtHibakeresés értékre, az x86-otpedig platformként. Ezután telepítse a helyi gépen a Build menüben a Megoldás üzembe helyezése lehetőséget.

16. fejezet – Az alkalmazás használata a HoloLensen

Az alkalmazás elindítása után a robot kék gömbként jelenik meg előtted.
Beszélgetés indításához használja a Koppintás kézmozdulatot , miközben a gömbre néz.
Várjon, amíg a beszélgetés elindul (a felhasználói felület üzenet jelenik meg, amikor megtörténik). Miután megkapta a robottól a bevezető üzenetet, koppintson ismét a robotra, hogy pirosra váltsa, és elkezdje hallgatni a hangját.
Ha abbahagyja a beszélgetést, az alkalmazás elküldi az üzenetet a robotnak, és azonnal megkapja a választ, amely megjelenik a felhasználói felületen.
Ismételje meg a folyamatot, hogy több üzenetet küldjön a robotnak (minden alkalommal, amikor üzenetet szeretne küldeni, koppintson rá).

Ez a beszélgetés bemutatja, hogyan őrizheti meg a robot az információkat (az Ön nevét), miközben ismert információkat (például a raktáron lévő elemeket) is megad.

Néhány kérdés, amelyeket fel kell tenni a robotnak:

what do you sell? 

how much are umbrellas?

how much are raincoats?

A kész webalkalmazás-robot (v4) alkalmazása

Gratulálunk, olyan vegyes valósági alkalmazást készített, amely az Azure Web App Botot használja, Microsoft Bot Framework v4-et.

Végtermék

Soron kívüli gyakorlatok

1. gyakorlat

A labor beszélgetési struktúrája nagyon egyszerű. A Microsoft LUIS használatával természetes nyelvfelismerési képességeket biztosíthat a robotnak.

2. gyakorlat

Ez a példa nem foglalja magában a beszélgetés leállítását és egy új újraindítását. A Robot funkció befejezéséhez próbálja meg implementálni a beszélgetés lezárását.

HoloLens (1. generációs) és Azure 312: Robotintegráció

Eszköztámogatás

Előfeltételek

Előkészületek

1. fejezet – A robotalkalmazás létrehozása

2. fejezet – Az Azure Bot Service létrehozása

3. fejezet – A robot közzététele az Azure Web App Bot Service

4. fejezet – A Unity-projekt beállítása

5. fejezet – Kamera beállítása

6. fejezet – A Newtonsoft könyvtár importálása

7. fejezet – A BotTag létrehozása

8. fejezet – A BotObjects osztály létrehozása

9. fejezet – A GazeInput osztály létrehozása

10. fejezet – A robotosztály létrehozása

11. fejezet – Az Interakciók osztály létrehozása

12. fejezet – A SceneOrganiser osztály létrehozása

13. fejezet – Építés előtt

14. fejezet – Buildelés és közvetlen telepítés a HoloLenshez

15. fejezet – Üzembe helyezés a HoloLensben

16. fejezet – Az alkalmazás használata a HoloLensen

Néhány kérdés, amelyeket fel kell tenni a robotnak:

A kész webalkalmazás-robot (v4) alkalmazása

Soron kívüli gyakorlatok

1. gyakorlat

2. gyakorlat

További források