HoloLens (1. Generation) und Azure 312: Bot-Integration

Artikel
03/21/2023
32 Minuten Lesedauer

Hinweis

Die Tutorials der Mixed Reality Academy wurden im Hinblick auf HoloLens (1. Gen.) und immersive Mixed Reality-Headsets entworfen. Daher halten wir es für wichtig, diese Tutorials für Entwickler verfügbar zu halten, die noch nach Anleitung beim Entwickeln für diese Geräte suchen. Diese Tutorials werden nicht mit den neuesten Toolsets oder Interaktionen aktualisiert, die für HoloLens 2 verwendet werden. Sie werden gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es wird eine neue Reihe von Lernprogrammen geben, die zukünftig veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickelt werden. Diese Benachrichtigung wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.

In diesem Kurs erfahren Sie, wie Sie einen Bot mithilfe der Microsoft Bot Framework V4 erstellen und bereitstellen und über eine Windows Mixed Reality Anwendung mit diesem kommunizieren.

Screenshot that shows communication through a Windows Mixed Reality application.

Die Microsoft Bot Framework V4 ist eine Reihe von APIs, die Entwicklern die Tools zum Erstellen einer erweiterbaren und skalierbaren Botanwendung bieten. Weitere Informationen finden Sie auf der Microsoft Bot Framework Seite oder im V4 Git-Repository.

Nach Abschluss dieses Kurses haben Sie eine Windows Mixed Reality Anwendung erstellt, die folgende Aktionen ausführen kann:

Verwenden Sie eine Tippgeste , um den Bot zu starten, der für die Benutzerstimme zuhört.
Wenn der Benutzer etwas gesagt hat, versucht der Bot, eine Antwort bereitzustellen.
Zeigen Sie die Bots als Text an, der in der Nähe des Bots positioniert ist, in der Unity-Szene.

In Ihrer Anwendung liegt es ihnen bei der Integration der Ergebnisse in Ihr Design. Dieser Kurs soll Ihnen vermitteln, wie Sie einen Azure Service in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen zu nutzen, das Sie aus diesem Kurs gewinnen, um Ihre Mixed Reality-Anwendung zu verbessern.

Geräteunterstützung

Kurs	HoloLens	Immersive Headsets
MR und Azure 312: Bot-Integration	✔️	✔️

Hinweis

Während sich dieser Kurs hauptsächlich auf HoloLens konzentriert, können Sie auch das, was Sie in diesem Kurs lernen, auf Windows Mixed Reality immersive (VR)-Headsets anwenden. Da immersive Headsets (VR) keine barrierefreien Kameras haben, benötigen Sie eine externe Kamera, die mit Ihrem PC verbunden ist. Während Sie mit dem Kurs folgen, werden Notizen zu allen Änderungen angezeigt, die Sie möglicherweise zum Unterstützen immersiver (VR)-Headsets verwenden müssen.

Voraussetzungen

Hinweis

Dieses Lernprogramm wurde für Entwickler entwickelt, die grundlegende Erfahrungen mit Unity und C# haben. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument darstellen, was zum Zeitpunkt des Schreibens getestet und überprüft wurde (Juli 2018). Sie sind kostenlos, die neueste Software zu verwenden, wie im Artikel zur Installation der Tools aufgeführt, aber es sollte nicht angenommen werden, dass die Informationen in diesem Kurs perfekt mit dem übereinstimmen, was Sie in neuerer Software finden werden als die unten aufgeführten.

Wir empfehlen die folgende Hardware und Software für diesen Kurs:

Ein Entwicklungs-PC, kompatibel mit Windows Mixed Reality für die Entwicklung immersiver (VR)-Headsets
Windows 10 Fall Creators Update (oder höher) mit aktivierter Entwicklermodus
Das neueste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ein Windows Mixed Reality immersives Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
Internetzugriff für Azure und für azure Bot-Abruf. Weitere Informationen finden Sie unter diesem Link.

Vorbereitung

Um probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, dass Sie das in diesem Lernprogramm erwähnte Projekt in einem Stamm- oder Nahstammordner erstellen (lange Ordnerpfade können probleme beim Buildzeit verursachen).
Richten Sie Ihre HoloLens ein, und testen Sie sie. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, stellen Sie sicher, dass Sie den HoloLens Setupartikel besuchen.
Es empfiehlt sich, beim Entwickeln einer neuen HoloLens-App Kalibrierung und Sensoroptimierung durchzuführen (manchmal kann es helfen, diese Aufgaben für jeden Benutzer auszuführen).

Hilfe zur Kalibrierung finden Sie unter diesem Link zum Artikel zur HoloLens Kalibrierung.

Hilfe zur Sensoroptimierung finden Sie im Artikel zur HoloLens Sensoroptimierung.

Kapitel 1 – Erstellen der Bot-Anwendung

Der erste Schritt besteht darin, Ihren Bot als lokale ASP.Net Core-Webanwendung zu erstellen. Nachdem Sie es abgeschlossen und getestet haben, veröffentlichen Sie sie im Azure-Portal.

Öffnen Sie Visual Studio. Erstellen Sie ein neues Projekt, wählen Sie ASP NET Core-Webanwendung als Projekttyp aus (Sie finden es unter dem Unterabschnitt .NET Core), und rufen Sie es "MyBot" auf. Klicken Sie auf OK.
Wählen Sie im Fenster, das angezeigt wird , "Leer" aus. Stellen Sie außerdem sicher, dass das Ziel auf ASP NET Core 2.0 festgelegt ist und die Authentifizierung auf "Keine Authentifizierung" festgelegt ist. Klicken Sie auf OK.
Die Lösung wird jetzt geöffnet. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf "Lösungs-Mybot", und klicken Sie auf "NuGet Pakete für Lösung verwalten".
Suchen Sie auf der Registerkarte "Durchsuchen " nach Microsoft.Bot.Builder.Integration.AspNet.Core (Stellen Sie sicher, dass Sie "Vorabversion einschließen " aktiviert haben). Wählen Sie die Paketversion 4.0.1-Vorschau aus, und markieren Sie die Projektfelder. Klicken Sie dann auf "Installieren". Sie haben jetzt die bibliotheken installiert, die für das Bot Framework v4 erforderlich sind. Schließen Sie die NuGet Seite.
Klicken Sie mit der rechten Maustaste auf Ihre Project, MyBot, in der Projektmappen-Explorer, und klicken Sie auf"Klassehinzufügen|".
Nennen Sie die Klasse "MyBot ", und klicken Sie auf "Hinzufügen".
Wiederholen Sie den vorherigen Punkt, um eine andere Klasse namens ConversationContext zu erstellen.
Klicken Sie mit der rechten Maustaste auf wwwroot in der Projektmappen-Explorer, und klicken Sie auf"Neues Elementhinzufügen|". Wählen Sie "HTML-Seite" aus (sie finden Sie unter dem Unterabschnittsweb). Benennen Sie die Datei default.html. Klicken Sie auf Hinzufügen.
Die Liste der Klassen / Objekte im Projektmappen-Explorer sollte wie das bild unten aussehen.
Doppelklicken Sie auf die ConversationContext-Klasse . Diese Klasse ist dafür verantwortlich, die variablen, die vom Bot verwendet werden, um den Kontext der Unterhaltung beizubehalten. Diese Unterhaltungskontextwerte werden in einer Instanz dieser Klasse beibehalten, da jede Instanz der MyBot-Klasse jedes Mal aktualisiert wird, wenn eine Aktivität empfangen wird. Fügen Sie der Klasse den folgenden Code hinzu:
```
namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}
```

Doppelklicken Sie auf die MyBot-Klasse . Diese Klasse hostet die Handler, die von allen eingehenden Aktivitäten vom Kunden aufgerufen werden. In dieser Klasse fügen Sie den Code hinzu, der zum Erstellen der Unterhaltung zwischen dem Bot und dem Kunden verwendet wird. Wie bereits erwähnt, wird jede Instanz dieser Klasse initialisiert, wenn eine Aktivität empfangen wird. Fügen Sie dieser Klasse den folgenden Code hinzu:

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

        }
    }
}

Doppelklicken Sie auf die Startklasse . Diese Klasse initialisiert den Bot. Fügen Sie der Klasse den folgenden Code hinzu:

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

Öffnen Sie die Programmklassendatei , und überprüfen Sie den darin aufgeführten Code wie folgt:

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

Denken Sie daran, Ihre Änderungen zu speichern, um dies zu tun, wechseln Sie auf der Symbolleiste oben in Visual Studio zu "Alle speichern>".

Kapitel 2 – Erstellen der Azure-Bot Service

Nachdem Sie nun den Code für Ihren Bot erstellt haben, müssen Sie ihn in einer Instanz des Web App Bot-Diensts im Azure-Portal veröffentlichen. In diesem Kapitel wird gezeigt, wie Sie die Bot Service in Azure erstellen und konfigurieren und dann Ihren Code darauf veröffentlichen.

Melden Sie sich zuerst beim Azure-Portal an (https://portal.azure.com).
1. Wenn Sie noch kein Azure-Konto haben, müssen Sie ein Konto erstellen. Wenn Sie diesem Lernprogramm in einer Unterrichts- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Proktoren, hilfe beim Einrichten Ihres neuen Kontos.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf "Ressource erstellen ", und suchen Sie nach Web App-Bot, und klicken Sie auf 'EINGABETASTE'.
Die neue Seite enthält eine Beschreibung des Web App Bot-Diensts . Wählen Sie unten links auf dieser Seite die Schaltfläche " Erstellen" aus, um eine Zuordnung zu diesem Dienst zu erstellen.
Nachdem Sie auf "Erstellen" geklickt haben:
1. Fügen Sie Ihren gewünschten Namen für diese Dienstinstanz ein.
2. Wählen Sie ein Abonnementaus.
3. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit, die Abrechnung für eine Sammlung von Azure-Ressourcen zu überwachen, zu steuern, den Zugriff zu steuern, bereitzustellen und zu verwalten. Es wird empfohlen, alle Azure Services, die einem einzelnen Projekt zugeordnet sind (z. B. diese Kurse), unter einer gemeinsamen Ressourcengruppe zu halten.
  
  Wenn Sie mehr über Azure-Ressourcengruppen lesen möchten, folgen Sie bitte diesem Link
4. Bestimmen Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Standort wäre idealerweise in der Region, in der die Anwendung ausgeführt wird. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar.
5. Wählen Sie die für Sie geeignete Preisstufe aus, wenn dies zum ersten Mal das Erstellen eines Web App Bot-Diensts ist, sollte eine kostenlose Stufe (mit dem Namen F0) für Sie verfügbar sein.
6. Der App-Name kann nur mit dem Bot-Namen identisch sein.
7. Lassen Sie die Bot-Vorlage als "Standard" (C#).
8. App-Dienstplan/Standort sollte für Ihr Konto automatisch ausgefüllt sein.
9. Legen Sie die Azure Storage fest, die Sie zum Hosten Ihres Bots verwenden möchten. Wenn Sie noch keines haben, können Sie es hier erstellen.
10. Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Geschäftsbedingungen verstanden haben.
11. Klicken Sie auf „Erstellen“.
Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wird. Dies kann eine Minute dauern.
Eine Benachrichtigung wird im Portal angezeigt, sobald die Dienstinstanz erstellt wurde.
Klicken Sie auf die Benachrichtigung, um Ihre neue Dienstinstanz zu erkunden.
Klicken Sie in der Benachrichtigung auf die Schaltfläche " Zur Ressource wechseln ", um Ihre neue Dienstinstanz zu erkunden. Sie werden zu Ihrer neuen Azure Service-Instanz weitergeleitet.
An diesem Punkt müssen Sie ein Feature namens Direct Line einrichten, damit Ihre Clientanwendung mit diesem Bot Service kommunizieren kann. Klicken Sie auf Kanäle, und klicken Sie dann im Abschnitt "Einen empfohlenen Kanal hinzufügen" auf "Konfigurieren Direct Line Kanals".
Auf dieser Seite finden Sie die geheimen Schlüssel , mit denen Ihre Client-App sich beim Bot authentifizieren kann. Klicken Sie auf die Schaltfläche "Anzeigen ", und nehmen Sie eine Kopie eines der angezeigten Schlüssel ein, da Sie dies später in Ihrem Projekt benötigen.

Kapitel 3 – Veröffentlichen des Bots in der Azure Web App Bot Service

Nachdem Ihr Dienst bereit ist, müssen Sie Ihren Bot-Code veröffentlichen, den Sie zuvor erstellt haben, in Ihrer neu erstellten Web App-Bot Service.

Hinweis

Sie müssen Ihren Bot jedes Mal veröffentlichen, wenn Sie Änderungen an der Bot-Lösung /Code vornehmen.

Zurück Zu Ihrer zuvor erstellten Visual Studio Lösung.
Klicken Sie mit der rechten Maustaste auf Ihr MyBot-Projekt, im Projektmappen-Explorer, und klicken Sie dann auf "Veröffentlichen".
Klicken Sie auf der Seite "Ziel veröffentlichen" auf App Service, und klicken Sie dann auf "Vorhandenes Profil auswählen", und klicken Sie schließlich auf "Profil erstellen" (Möglicherweise müssen Sie auf den Dropdownpfeil neben der Schaltfläche "Veröffentlichen" klicken, wenn dies nicht sichtbar ist).
Wenn Sie noch nicht bei Ihrem Microsoft-Konto angemeldet sind, müssen Sie es hier tun.
Auf der Seite "Veröffentlichen " müssen Sie dasselbe Abonnement festlegen, das Sie für die Erstellung des Web App Bot-Diensts verwendet haben. Legen Sie dann die Ansicht als Ressourcengruppe fest, und wählen Sie in der Dropdownordnerstruktur die zuvor erstellte Ressourcengruppe aus. Klicken Sie auf OK.
Klicken Sie nun auf die Schaltfläche "Veröffentlichen ", und warten Sie, bis der Bot veröffentlicht wird (es kann einige Minuten dauern).

Kapitel 4 – Einrichten des Unity-Projekts

Nachfolgend sehen Sie eine typische Einrichtung für die Entwicklung mit Mixed Reality und ist daher eine gute Vorlage für andere Projekte.

Öffnen Sie Unity , und klicken Sie auf "Neu".
Sie müssen jetzt einen Unity-Projektnamen angeben. Fügen Sie HoloLens Bot ein. Stellen Sie sicher, dass die Projektvorlage auf 3D festgelegt ist. Legen Sie den Speicherort an einer beliebigen Stelle fest, die für Sie geeignet ist (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".
Wenn Unity geöffnet ist, empfiehlt es sich, den Standardskript-Editor auf Visual Studio festzulegen. Wechseln Sie zu "Einstellungen bearbeiten">, und navigieren Sie dann im neuen Fenster zu "Externe Tools". Ändern Sie den externen Skript-Editor in Visual Studio 2017. Schließen Sie das Fenster "Einstellungen" .
Wechseln Sie als Nächstes zu "Dateibuild>" Einstellungen, und wählen Sie Universelle Windows-Plattform aus, und klicken Sie dann auf die Schaltfläche "Plattform wechseln", um Ihre Auswahl anzuwenden.
Während Sie sich noch im Dateibuild > Einstellungen befinden, und stellen Sie sicher, dass:
1. Zielgerät ist auf HoloLens festgelegt.
  
  Legen Sie für die immersiven Headsets das Zielgerät auf ein beliebiges Gerät fest.
2. Buildtyp ist auf D3D festgelegt
3. SDK ist auf "Neueste Installation" festgelegt.
4. Visual Studio Version ist auf "Neueste Installation" festgelegt.
5. Build und Run ist auf lokalen Computer festgelegt
6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.
  1. Wählen Sie dazu "Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.
  2. Erstellen Sie einen neuen Ordner für diesen Ordner und jede zukünftige Szene, und wählen Sie dann die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, benennen Sie ihn "Szenen".
  3. Öffnen Sie Ihren neu erstellten Szenenordner , und klicken Sie dann im Dateinamen: Textfeld, geben Sie BotScene ein, und klicken Sie dann auf "Speichern".
7. Die verbleibenden Einstellungen in Build Einstellungen sollten jetzt als Standard beibehalten werden.
Klicken Sie im Fenster "Build Einstellungen" auf die Schaltfläche "Player Einstellungen". Dadurch wird der zugehörige Bereich im Bereich geöffnet, in dem sich der Inspektor befindet.
In diesem Bereich müssen einige Einstellungen überprüft werden:
1. Auf der Registerkarte "Andere Einstellungen":
  1. Skriptlaufzeitversion sollte experimentell sein (NET 4.6 Äquivalent); Wenn Sie dies ändern, muss der Editor neu gestartet werden.
  2. Skript-Back-End sollte .NET sein
  3. API-Kompatibilitätsebene sollte .NET 4.6 sein
2. Überprüfen Sie auf der Registerkarte "Veröffentlichen Einstellungen" unter "Funktionen":
  - InternetClient
  - Mikrofon
3. Klicken Sie weiter unten im Bereich in XR Einstellungen (unter "Veröffentlichen Einstellungen") auf "Virtual Reality Unterstützt", stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt wird.
Zurück in Build EinstellungenUnity C#-Projekte ist nicht mehr abgeblentet. Aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster „Build Settings“ (Buildeinstellungen).
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Kapitel 5 – Kamera Setup

Wichtig

Wenn Sie die Unity Setup-Komponente dieses Kurses überspringen und direkt in Code fortfahren möchten, können Sie dieses Azure-MR-312-Package.unitypackage herunterladen, es in Ihr Projekt als benutzerdefiniertes Paket importieren und dann von Kapitel 7 fortfahren.

Wählen Sie im Hierarchiebereich die Haupt-Kamera aus.
Nachdem Sie ausgewählt haben, können Sie alle Komponenten der Haupt-Kamera im Inspektorbereich anzeigen.
1. Das Kamera-Objekt muss "Main Kamera" genannt werden (beachten Sie die Schreibweise)
2. Das Haupt-Kamera-Tag muss auf "MainCamera" festgelegt werden (beachten Sie die Schreibweise)
3. Stellen Sie sicher, dass die Transformationsposition auf 0, 0, 0 festgelegt ist.
4. Legen Sie "Clear Flags " auf "Volltonfarbe" fest.
5. Festlegen der Hintergrundfarbe der Kamera-Komponente auf Schwarz, Alpha 0 (Hex Code: #0000000000)

Kapitel 6 – Importieren der Newtonsoft-Bibliothek

Um Ihnen bei der Deerialisierung und Serialisierung von Objekten zu helfen, die empfangen und an die Bot Service gesendet werden, müssen Sie die Newtonsoft-Bibliothek herunterladen. Hier finden Sie eine kompatible Version, die bereits mit der richtigen Unity-Ordnerstruktur organisiert ist.

Um die Newtonsoft-Bibliothek in Ihr Projekt zu importieren, verwenden Sie das Unity-Paket, das in diesem Kurs enthalten ist.

Fügen Sie unitypackage zu Unity hinzu, indem Sie die Menüoption"Benutzerdefiniertes Paketimportieren" des Ressourcenimportpakets>> verwenden.
Stellen Sie im Feld "Unity-Paket importieren " sicher, dass alles unter (und einschließlich) Plug-Ins ausgewählt ist.
Klicken Sie auf die Schaltfläche "Importieren ", um dem Projekt die Elemente hinzuzufügen.
Wechseln Sie in der Projektansicht zum Newtonsoft-Ordner unter Plugins , und wählen Sie das Newtonsoft-Plug-In aus.
Stellen Sie sicher, dass das Newtonsoft-Plug-In ausgewählt ist, stellen Sie sicher, dass "Beliebige Plattform" deaktiviert ist, und stellen Sie sicher, dass WSAPlayer ebenfalls deaktiviert ist, und klicken Sie dann auf "Übernehmen". Dies ist nur die Bestätigung, dass die Dateien ordnungsgemäß konfiguriert sind.

Hinweis

Wenn Sie diese Plug-Ins markieren, werden sie nur im Unity-Editor verwendet. Es gibt einen anderen Satz davon im WSA-Ordner, der verwendet wird, nachdem das Projekt aus Unity exportiert wird.
Als Nächstes müssen Sie den WSA-Ordner innerhalb des Newtonsoft-Ordners öffnen. Sie sehen eine Kopie derselben Datei, die Sie gerade konfiguriert haben. Wählen Sie die Datei aus, und stellen Sie dann im Inspektor sicher, dass
- Jede Plattform ist deaktiviert.
- NurWSAPlayer ist aktiviert.
- Der Vorgang wird überprüft.

Kapitel 7 – Erstellen des BotTags

Erstellen Sie ein neues Tag-Objekt namens BotTag. Wählen Sie die Haupt-Kamera in der Szene aus. Klicken Sie im Dropdownmenü "Tag" im Inspektorbereich auf das Dropdownmenü "Tag". Klicken Sie auf "Tag hinzufügen".
Klicken Sie auf das + Symbol. Benennen Sie das neue Tag als BotTag, Speichern.

Warnung

Wenden Sie das BotTagnicht auf das Main-Kamera an. Wenn Sie dies versehentlich getan haben, müssen Sie das Main-Kamera-Tag wieder in MainCamera ändern.

Kapitel 8 – Erstellen der BotObjects-Klasse

Das erste Skript, das Sie erstellen müssen, ist die BotObjects-Klasse , die eine leere Klasse ist, die erstellt wird, damit eine Reihe anderer Klassenobjekte innerhalb desselben Skripts gespeichert werden und auf andere Skripts in der Szene zugegriffen werden kann.

Die Erstellung dieser Klasse ist nur eine architekturliche Wahl, diese Objekte könnten stattdessen im Bot-Skript gehostet werden, das Sie später in diesem Kurs erstellen.

So erstellen Sie diese Klasse:

Klicken Sie mit der rechten Maustaste im Project-Bereich, und erstellen Sie dann "Ordner erstellen>". Benennen Sie den Ordner Skripts.
Doppelklicken Sie auf den Ordner "Skripts ", um sie zu öffnen. Klicken Sie dann innerhalb dieses Ordners mit der rechten Maustaste, und wählen Sie "C#-Skript erstellen>" aus. Benennen Sie das Skript BotObjects.
Doppelklicken Sie auf das neue BotObjects-Skript, um es mit Visual Studio zu öffnen.

Löschen Sie den Inhalt des Skripts, und ersetzen Sie sie durch den folgenden Code:

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

Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Kapitel 9 – Erstellen der GazeInput-Klasse

Die nächste Klasse, die Sie erstellen möchten, ist die GazeInput-Klasse . Diese Klasse ist verantwortlich für:

Erstellen eines Cursors, der den Blick des Spielers darstellt.
Erkennen von Objekten, die vom Blick des Spielers getroffen werden, und halten Sie einen Verweis auf erkannte Objekte.

So erstellen Sie diese Klasse:

Wechseln Sie zum Ordner "Skripts" , den Sie zuvor erstellt haben.
Klicken Sie mit der rechten Maustaste in den Ordner, "C#-Skript erstellen>". Rufen Sie das Skript GazeInput auf.
Doppelklicken Sie auf das neue GazeInput-Skript, um sie mit Visual Studio zu öffnen.

Fügen Sie die folgende Zeile oben im Klassennamen ein:

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

Fügen Sie dann die folgenden Variablen in der GazeInput-Klasse oberhalb der Start() -Methode hinzu:

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

Code für Start()- Methode sollte hinzugefügt werden. Dies wird aufgerufen, wenn die Klasse initialisiert:

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

Implementieren Sie eine Methode, die den Blickzeiger instanziieren und einrichten wird:

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

Implementieren Sie die Methoden, die den Raycast aus dem Main Kamera einrichten und das aktuelle fokussierte Objekt nachverfolgen.

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

Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Kapitel 10 – Erstellen der Bot-Klasse

Das Skript, das Sie erstellen möchten, wird jetzt als Bot bezeichnet. Dies ist die Kernklasse Ihrer Anwendung, sie speichert:

Ihre Web App Bot-Anmeldeinformationen
Die Methode, die die Sprachbefehle des Benutzers sammelt
Die Methode, die erforderlich ist, um Unterhaltungen mit Ihrem Web App Bot zu initiieren
Die Methode, die zum Senden von Nachrichten an Ihren Web App Bot erforderlich ist

Um Nachrichten an die Bot Service zu senden, erstellt das SendMessageToBot() coroutine eine Aktivität, die von dem Bot Framework als vom Benutzer gesendete Daten erkannt wird.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner "Skripts ", um sie zu öffnen.
Klicken Sie mit der rechten Maustaste in den Skriptordner, klicken Sie auf "C#-Skript erstellen>". Benennen Sie den Skript-Bot.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.

Aktualisieren Sie die Namespaces so wie folgt, am oberen Rand der Bot-Klasse :

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

In der Bot-Klasse fügen Sie die folgenden Variablen hinzu:

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

Hinweis

Stellen Sie sicher, dass Sie Ihren Bot-Geheimschlüssel in die BotSecret-Variable einfügen. Sie haben Ihren Bot-Geheimschlüssel am Anfang dieses Kurses in Kapitel 2, Schritt 10, notiert.

Code für Awake() und Start() müssen jetzt hinzugefügt werden.

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

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

Fügen Sie die beiden Handler hinzu, die von den Sprachbibliotheken aufgerufen werden, wenn die Sprachaufnahme beginnt und endet. Der DictationRecognizer beendet automatisch die Erfassung der Benutzerstimme, wenn der Benutzer nicht mehr spricht.

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

Der folgende Handler sammelt das Ergebnis der Spracheingabe des Benutzers und ruft die Coroutine auf, die für das Senden der Nachricht an die Web App-Bot Service verantwortlich ist.

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

Die folgende Coroutine wird aufgerufen, um eine Unterhaltung mit dem Bot zu beginnen. Sie werden feststellen, dass nach Abschluss des Unterhaltungsaufrufs die SendMessageToCoroutine() aufgerufen wird, indem sie eine Reihe von Parametern übergeben, die die Aktivität festlegen, die an die Bot Service als leere Nachricht gesendet werden soll. Dies geschieht, um die Bot Service aufzufordern, den Dialog zu initiieren.

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

Die folgende Coroutine wird aufgerufen, um die Aktivität zu erstellen, die an die Bot Service gesendet werden soll.

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

Die folgende Coroutine wird aufgerufen, um nach dem Senden einer Aktivität an die Bot Service eine Antwort anzufordern.

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

Die letzte Methode, die dieser Klasse hinzugefügt werden soll, ist erforderlich, um die Nachricht in der Szene anzuzeigen:
```
    /// <summary>
    /// Set the UI Response Text of the bot
    /// </summary>
    internal void SetBotResponseText(string responseString)
    {        
        SceneOrganiser.Instance.botResponseText.text =  responseString;
    }
```
Hinweis

Möglicherweise wird ein Fehler in der Unity-Editor-Konsole angezeigt, um die SceneOrganiser-Klasse zu fehlen. Ignorieren Sie diese Nachricht, da Sie diese Klasse später im Lernprogramm erstellen.
Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Kapitel 11 – Erstellen der Interaktionsklasse

Die Klasse, die Sie jetzt erstellen möchten, wird als "Interaktionen" bezeichnet. Diese Klasse wird verwendet, um die HoloLens Tippen Auf Eingabe vom Benutzer zu erkennen.

Wenn der Benutzer während des Blicks auf das Bot-Objekt in der Szene tippt, und der Bot ist bereit, spracheingaben zu hören, ändert das Bot-Objekt farbe in rot und beginnt mit der Wiedergabe von Spracheingaben.

Diese Klasse erbt von der GazeInput-Klasse und kann daher auf die Start() -Methode und Variablen dieser Klasse verweisen, die durch die Verwendung von Basis gekennzeichnet ist.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner "Skripts ", um sie zu öffnen.
Klicken Sie mit der rechten Maustaste in den Skriptordner, klicken Sie auf "C#-Skript erstellen>". Benennen Sie die Skriptinteraktionen.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.
Aktualisieren Sie die Namespaces und die Klassenvererbung so wie folgt, am oberen Rand der Interaktionen-Klasse :
```
using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{
```

In der Interaktionsklasse fügen Sie die folgende Variable hinzu:

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

Fügen Sie dann die Start()- Methode hinzu:

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

Fügen Sie den Handler hinzu, der ausgelöst wird, wenn der Benutzer die Tippengeste vor der HoloLens Kamera ausführt.

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

Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Kapitel 12 – Erstellen der SceneOrganiser-Klasse

Die letzte Klasse, die in diesem Lab erforderlich ist, wird als SceneOrganiser bezeichnet. Diese Klasse wird die Szene programmgesteuert einrichten, indem Sie Komponenten und Skripts zum Main Kamera hinzufügen und die entsprechenden Objekte in der Szene erstellen.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner "Skripts ", um sie zu öffnen.
Klicken Sie mit der rechten Maustaste in den Skriptordner, klicken Sie auf "C#-Skript erstellen>". Benennen Sie das Skript "SceneOrganiser".
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.

Fügen Sie innerhalb der SceneOrganiser-Klasse die folgenden Variablen hinzu:

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

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

Fügen Sie dann die Methoden "Awake() " und " Start()" hinzu:

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

Fügen Sie die folgende Methode hinzu, die für das Erstellen des Bot-Objekts in der Szene verantwortlich ist, und richten Sie die Parameter und Komponenten ein:

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

Fügen Sie die folgende Methode hinzu, die für das Erstellen des UI-Objekts in der Szene verantwortlich ist und die Antworten des Bots darstellt:

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

Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.
Ziehen Sie im Unity-Editor das SceneOrganiser-Skript aus dem Ordner "Skripts" in die Haupt-Kamera. Die Komponente "Szenenorganisator" sollte nun auf dem Hauptobjekt Kamera angezeigt werden, wie in der abbildung unten dargestellt.

Kapitel 13 – Vor dem Gebäude

Um einen gründlichen Test Ihrer Anwendung durchzuführen, müssen Sie sie auf Ihre HoloLens querladen. Bevor Sie vorgehen, stellen Sie sicher, dass:

Alle im Kapitel 4 genannten Einstellungen sind korrekt festgelegt.
Das Skript "SceneOrganiser" wird an das Main Kamera-Objekt angefügt.
Stellen Sie in der Bot-Klasse sicher, dass Sie Ihren Bot Secret Key in die BotSecret-Variable eingefügt haben.

Kapitel 14 – Erstellen und Querladen in die HoloLens

Alles, was für den Unity-Abschnitt dieses Projekts erforderlich ist, wurde jetzt abgeschlossen, daher ist es an der Zeit, es aus Unity zu erstellen.

Navigieren Sie zu Build Einstellungen, Dateibuild > Einstellungen....
Klicken Sie im Fenster "Build Einstellungen" auf "Erstellen".
Wenn noch nicht, ticken Sie Unity C#-Projekte.
Klicken Sie auf Erstellen. Unity startet ein Explorer Fenster, in dem Sie erstellen und dann einen Ordner zum Erstellen der App auswählen müssen. Erstellen Sie diesen Ordner jetzt, und nennen Sie sie App. Klicken Sie dann mit ausgewähltem App-Ordner auf "Ordner auswählen".
Unity beginnt mit dem Erstellen Ihres Projekts im App-Ordner .
Sobald Unity das Gebäude abgeschlossen hat (es kann einige Zeit dauern), öffnet es ein Explorer Fenster an der Position Ihres Builds (überprüfen Sie Ihre Taskleiste, da sie möglicherweise nicht immer über Ihren Fenstern angezeigt wird, sondern Sie über das Hinzufügen eines neuen Fensters informieren).

Kapitel 15 – Bereitstellen für HoloLens

So stellen Sie HoloLens bereit:

Sie benötigen die IP-Adresse Ihrer HoloLens (für Remotebereitstellung), und um sicherzustellen, dass sich Ihr HoloLens im Entwicklermodus befindet. Gehen Sie dazu folgendermaßen vor:
1. Öffnen Sie beim Tragen Ihrer HoloLens die Einstellungen.
2. Wechseln zu Netzwerk-Internet &> -Wi-Fi > Erweiterten Optionen
3. Beachten Sie die IPv4-Adresse .
4. Navigieren Sie als Nächstes zu Einstellungen und dann zum Aktualisieren & der Sicherheit > für Entwickler
5. Legen Sie den Entwicklermodus ein.
Navigieren Sie zu Ihrem neuen Unity-Build (dem App-Ordner), und öffnen Sie die Lösungsdatei mit Visual Studio.
Wählen Sie in der Lösungskonfiguration"Debuggen" aus.
Wählen Sie in der Lösungsplattformx86, Remotecomputer aus.
Wechseln Sie zum Menü "Erstellen", und klicken Sie auf "Lösung bereitstellen", um die Anwendung in Ihre HoloLens querzuladen.
Ihre App sollte jetzt in der Liste der installierten Apps auf Ihrem HoloLens angezeigt werden, die zum Starten bereit sind!

Hinweis

Um das immersive Headset bereitzustellen, legen Sie die Lösungsplattform auf den lokalen Computer fest, und legen Sie die Konfiguration auf "Debuggen" fest, wobei x86 als Plattform verwendet wird. Stellen Sie dann auf dem lokalen Computer mithilfe des Menüs "Erstellen" die Option "Lösung bereitstellen" bereit.

Kapitel 16 – Verwenden der Anwendung auf der HoloLens

Nachdem Sie die Anwendung gestartet haben, sehen Sie den Bot als blaue Kugel vor Ihnen.
Verwenden Sie die Tippgeste , während Sie auf die Kugel blicken, um eine Unterhaltung zu initiieren.
Warten Sie, bis die Unterhaltung gestartet wird (Die Benutzeroberfläche zeigt eine Meldung an, wenn dies geschieht). Sobald Sie die Einführungsnachricht vom Bot erhalten haben, tippen Sie erneut auf den Bot, sodass es rot wird und beginnt, Ihre Stimme zu hören.
Sobald Sie nicht mehr sprechen, sendet Ihre Anwendung Ihre Nachricht an den Bot, und Sie erhalten sofort eine Antwort, die in der Benutzeroberfläche angezeigt wird.
Wiederholen Sie den Vorgang, um weitere Nachrichten an Ihren Bot zu senden (Sie müssen jedes Mal tippen, wenn Sie eine Nachricht senden möchten).

In dieser Unterhaltung wird veranschaulicht, wie der Bot Informationen (Ihren Namen) aufbewahren kann und gleichzeitig bekannte Informationen bereitstellt (z. B. die elemente, die auf lageriert sind).

Einige Fragen zum Stellen des Bots:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Ihre fertige Web App Bot (v4)-Anwendung

Herzlichen Glückwunsch, Sie haben eine Mixed Reality-App erstellt, die den Azure Web App Bot Microsoft Bot Framework v4 nutzt.

Final Product

Zusatzübungen

Übung 1

Die Unterhaltungsstruktur in dieser Übung ist sehr einfach. Verwenden Sie Microsoft LUIS, um Ihren Bot natürliche Sprachverständnisfunktionen zu ermöglichen.

Übung 2

In diesem Beispiel wird das Beenden einer Unterhaltung und das Neustarten einer neuen Unterhaltung nicht eingeschlossen. Um das Bot-Feature abzuschließen, versuchen Sie, den Abschluss der Unterhaltung zu implementieren.

HoloLens (1. Generation) und Azure 312: Bot-Integration

Geräteunterstützung

Voraussetzungen

Vorbereitung

Kapitel 1 – Erstellen der Bot-Anwendung

Kapitel 2 – Erstellen der Azure-Bot Service

Kapitel 3 – Veröffentlichen des Bots in der Azure Web App Bot Service

Kapitel 4 – Einrichten des Unity-Projekts

Kapitel 5 – Kamera Setup

Kapitel 6 – Importieren der Newtonsoft-Bibliothek

Kapitel 7 – Erstellen des BotTags

Kapitel 8 – Erstellen der BotObjects-Klasse

Kapitel 9 – Erstellen der GazeInput-Klasse

Kapitel 10 – Erstellen der Bot-Klasse

Kapitel 11 – Erstellen der Interaktionsklasse

Kapitel 12 – Erstellen der SceneOrganiser-Klasse

Kapitel 13 – Vor dem Gebäude

Kapitel 14 – Erstellen und Querladen in die HoloLens

Kapitel 15 – Bereitstellen für HoloLens

Kapitel 16 – Verwenden der Anwendung auf der HoloLens

Einige Fragen zum Stellen des Bots:

Ihre fertige Web App Bot (v4)-Anwendung

Zusatzübungen

Übung 1

Übung 2

Zusätzliche Ressourcen

Zusätzliche Ressourcen