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

Artikel
07/04/2024

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 in Zukunft veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickelt werden. Dieser Hinweis wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.

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

Screenshot der Kommunikation über eine Windows Mixed Reality-Anwendung.

Das Microsoft Bot Framework V4 ist eine Reihe von APIs, die Entwicklern die Tools zum Erstellen einer erweiterbaren und skalierbaren Bot-Anwendung bieten sollen. 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 die Stimme der Benutzer anhö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 an Ihnen, wie Sie die Ergebnisse in Ihr Design integrieren. 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.

Unterstützung für Geräte

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 Headsets (VR) anwenden. Da immersive Headsets (VR) keine barrierefreien Kameras haben, benötigen Sie eine externe Kamera, die mit Ihrem PC verbunden ist. Während Sie den Kurs befolgen, werden Notizen zu allen Änderungen angezeigt, die Sie möglicherweise verwenden müssen, um immersive Headsets (VR) zu unterstützen.

Voraussetzungen

Hinweis

Dieses Lernprogramm wurde für Entwickler entwickelt, die grundlegende Erfahrung mit Unity und C# haben. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument darstellen, was zum Zeitpunkt der Schriftlichkeit (Juli 2018) getestet und überprüft wurde. Sie können die neueste Software verwenden, wie im Artikel "Tools installieren" aufgeführt, aber es sollte nicht davon ausgegangen 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 von immersiven (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 immersives Windows Mixed Reality-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.

Vor der Installation

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

Hilfe zur Kalibrierung finden Sie unter diesem Link zum HoloLens-Kalibrierungsartikel.

Hilfe zur Sensoroptimierung finden Sie in diesem Link zum Artikel "HoloLens Sensor Tuning".

Kapitel 1 – Erstellen der Bot-Anwendung

Der erste Schritt besteht darin, Ihren Bot als lokale ASP.Net Core-Webanwendung zu erstellen. Nachdem Sie sie 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 angezeigten Fenster " 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 nun geöffnet. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf "Solution 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 "Vorabversion einschließen" aktiviert ist). 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 Ihr Projekt, MyBot, im Projektmappen-Explorer, und klicken Sie auf "Klasse hinzufügen" | .
Nennen Sie die Klasse "MyBot ", und klicken Sie auf "Hinzufügen".
Wiederholen Sie den vorherigen Punkt, um eine andere Klasse mit dem Namen ConversationContext zu erstellen.
Klicken Sie mit der rechten Maustaste auf wwwroot im Projektmappen-Explorer, und klicken Sie auf "Neues Element hinzufü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 für die Aufbewahrung der vom Bot verwendeten Variablen verantwortlich, um den Kontext der Unterhaltung aufrechtzuerhalten. Diese Unterhaltungskontextwerte werden in einer Instanz dieser Klasse verwaltet, da jede Instanz der MyBot-Klasse jedes Mal aktualisiert wird, wenn eine Aktivität empfangen wird. Fügen Sie der -Klasse 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 des 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 eine Instanz dieser Klasse jedes Mal 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 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 von der Symbolleiste oben in Visual Studio zu "Alle>speichern".

Kapitel 2 – Erstellen des Azure Bot-Diensts

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 erfahren Sie, wie Sie den Bot-Dienst in Azure erstellen und konfigurieren und dann Ihren Code veröffentlichen.

Melden Sie sich zuerst beim Azure-Portal (https://portal.azure.com) an.
1. Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie ein Konto erstellen. Wenn Sie diesem Lernprogramm in einer Unterrichts- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Betreuer, Hilfe beim Einrichten Ihres neuen Kontos zu erhalten.
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-Dienste, die einem einzelnen Projekt (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, folgen Sie 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 würde. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar.
5. Wählen Sie die für Sie geeignete Preisstufe aus, wenn Sie zum ersten Mal einen Web App Bot-Dienst erstellen, sollte ihnen eine kostenlose Stufe (mit dem Namen F0) zur Verfügung stehen.
6. Der App-Name kann einfach mit dem Botnamen identisch sein.
7. Belassen Sie die Bot-Vorlage als Basis (C#).
8. App-Serviceplan/Standort sollte für Ihr Konto automatisch ausgefüllt worden sein.
9. Legen Sie den Azure Storage fest, den Sie zum Hosten Ihres Bots verwenden möchten. Wenn Sie noch keins haben, können Sie es hier erstellen.
10. Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Allgemeinen Geschäftsbedingungen verstanden haben.
11. Klicken Sie auf Erstellen.
Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Sobald die Dienstinstanz erstellt wurde, wird im Portal eine Benachrichtigung angezeigt.
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-Dienst kommunizieren kann. Klicken Sie auf "Kanäle", und klicken Sie dann im Abschnitt "Empfohlenen Kanal hinzufügen" auf " Direct Line-Kanal konfigurieren".
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 einer der angezeigten Schlüssel ein, da Sie dies später in Ihrem Projekt benötigen.

Kapitel 3 – Veröffentlichen des Bots im Azure Web App Bot-Dienst

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

Hinweis

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

Kehren Sie zu Ihrer zuvor erstellten Visual Studio-Projektmappe zurück.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr MyBot-Projekt, und klicken Sie dann auf "Veröffentlichen".
Klicken Sie auf der Seite "Ziel veröffentlichen" auf "App Service auswählen", und klicken Sie dann auf "Vorhandenes 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 dies 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 wurde (es kann einige Minuten dauern).

Kapitel 4 – Einrichten des Unity-Projekts

Im Folgenden 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".
Jetzt müssen Sie 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 für Sie geeigneten Stelle fest (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".
Wenn Unity geöffnet ist, lohnt es sich, den Standardmäßigen Skript-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 "Dateibuildeinstellungen>", 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 in den Dateibuildeinstellungen > befinden , und stellen Sie sicher, dass:
1. Zielgerät ist auf HoloLens festgelegt
  
  Legen Sie für die immersiven Headsets "Zielgerät " auf "Jedes 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 Ausführung ist auf den lokalen Computer festgelegt.
6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.
  1. Wählen Sie dazu "Offene Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.
  2. Erstellen Sie einen neuen Ordner für diese Und jede zukünftige Szene, und wählen Sie dann die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, nennen Sie ihn "Szenen".
  3. Öffnen Sie ihren neu erstellten Ordner "Szenen", und klicken Sie dann im Feld "Datei" auf "BotScene", und klicken Sie dann auf "Speichern".
7. Die übrigen Einstellungen in den Buildeinstellungen sollten jetzt als Standard beibehalten werden.
Klicken Sie im Fenster "Buildeinstellungen " auf die Schaltfläche "Spielereinstellungen ". 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" folgendes:
  1. Skripting-Runtime-Version sollte experimental sein (NET 4.6-Entsprechung). Wenn Sie dies ändern, muss der Editor neu gestartet werden.
  2. Scripting Back-End sollte .NET sein
  3. API-Kompatibilitätsstufe sollte .NET 4.6 sein
2. Aktivieren Sie auf der Registerkarte "Veröffentlichungseinstellungen " unter "Funktionen" Folgendes:
  - InternetClient
  - Mikrofon
3. Klicken Sie weiter unten im Bereich unter "XR-Einstellungen" (unter "Veröffentlichungseinstellungen" finden Sie auf "Virtual Reality Unterstützt"), und vergewissern Sie sich, dass das Windows Mixed Reality SDK hinzugefügt wird.
Zurück in Buildeinstellungen Unity C# -Projekte ist nicht mehr abgeblentet. Aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster Buildeinstellungen.
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Kapitel 5 – Kameraeinrichtung

Wichtig

Wenn Sie die Unity Set up-Komponente dieses Kurses überspringen und direkt mit Code fortfahren möchten, laden Sie dieses Azure-MR-312-Package.unitypackage herunter, importieren Sie sie als benutzerdefiniertes Paket in Ihr Projekt, und fahren Sie dann mit Kapitel 7 fort.

Wählen Sie im Hierarchiebereich die Hauptkamera aus.
Nach der Auswahl können Sie alle Komponenten der Hauptkamera im Inspektorbereich anzeigen.
1. Das Camera-Objekt muss den Namen "Main Camera" haben (beachten Sie die Schreibweise)
2. Das Hauptkameratag 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 "Flags löschen" auf Volltonfarbe fest.
5. Festlegen der Hintergrundfarbe der Kamerakomponente auf Schwarz, Alpha 0 (Hex-Code: #00000000)

Kapitel 6 – Importieren der Newtonsoft-Bibliothek

Damit Sie Objekte deserialisieren und serialisieren können, die empfangen und an den Bot-Dienst 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 das UNITY-Paket mithilfe der Menüoption "Benutzerdefiniertes>Paket> importieren" zu Unity hinzu.
Stellen Sie im Popupfeld "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 Ordner Newtonsoft unter Plugins , und wählen Sie das Newtonsoft-Plug-In aus.
Stellen Sie bei ausgewähltem Newtonsoft-Plug-In sicher, dass "Any Platform" deaktiviert ist, und stellen Sie dann sicher, dass WSAPlayer ebenfalls deaktiviert ist, und klicken Sie dann auf "Übernehmen". Dies ist nur zu bestätigen, 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 wurde.
Als Nächstes müssen Sie den WSA-Ordner innerhalb des Newtonsoft-Ordners öffnen. Es wird eine Kopie derselben Datei angezeigt, die Sie gerade konfiguriert haben. Wählen Sie die Datei aus, und stellen Sie dann im Inspektor sicher, dass
- Jede Plattform ist deaktiviert.
- Nur WSAPlayer ist aktiviert.
- Der Vorgang wird überprüft.

Kapitel 7 – Erstellen des BotTags

Erstellen Sie ein neues Tag-Objekt namens BotTag. Wählen Sie die Hauptkamera in der Szene aus. Klicken Sie 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 BotTag nicht auf die Hauptkamera an. Wenn Sie dies versehentlich getan haben, stellen Sie sicher, dass Sie das Hauptkamera-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 und von anderen Skripts in der Szene aufgerufen werden kann.

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

So erstellen Sie diese Klasse:

Klicken Sie mit der rechten Maustaste im Projektbereich und dann auf "Ordner erstellen > ". Benennen Sie den Ordner Skripts.
Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen. Klicken Sie dann in diesem Ordner mit der rechten Maustaste, und wählen Sie "C#-Skript erstellen" >aus. Nennen 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 ihn 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 werden, ist die GazeInput-Klasse . Diese Klasse ist für Folgendes verantwortlich:

Erstellen eines Cursors, der den Blick des Spielers darstellt.
Erkennen von Objekten, die vom Blick des Spielers getroffen werden, und halten 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 es mit Visual Studio zu öffnen.

Fügen Sie die folgende Zeile rechts über dem 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 Die Start() -Methode sollte hinzugefügt werden. Dies wird aufgerufen, wenn die Klasse initialisiert wird:

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

Implementieren Sie eine Methode, die den Blickcursor instanziieren und einrichten soll:

    /// <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, mit denen der Raycast von der Hauptkamera eingerichtet wird, und verfolgen Sie das aktuelle fokussierte Objekt.

    /// <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 jetzt erstellen werden, heißt Bot. Dies ist die Kernklasse Ihrer Anwendung, die folgendes speichert:

Ihre Web App Bot-Anmeldeinformationen
Die Methode, die die Sprachbefehle des Benutzers sammelt
Die Zum Initiieren von Unterhaltungen mit Ihrem Web App Bot erforderliche Methode
Die zum Senden von Nachrichten an Ihren Web App Bot erforderliche Methode

Um Nachrichten an den Bot-Dienst zu senden, erstellt das SendMessageToBot() -Coroutine eine Aktivität, die ein Objekt ist, das vom Bot Framework als Vom Benutzer gesendete Daten erkannt wird.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie den Skriptbot.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.

Aktualisieren Sie die Namespaces so, dass sie mit dem folgenden identisch sind, am Anfang der Bot-Klasse :

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

Fügen Sie in der Bot-Klasse 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 Secret Key in die BotSecret-Variable einfügen. Sie haben Ihren Bot Secret Key zu Beginn dieses Kurses in Kapitel 2, Schritt 10 notiert.

Code für Awake() und Start() muss 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. Das 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 erfasst das Ergebnis der Benutzerstimmeeingabe und ruft die coroutine auf, die für das Senden der Nachricht an den Web App Bot-Dienst 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 eine Reihe von Parametern übergeben wird, die festlegen, dass die Aktivität als leere Nachricht an den Bot-Dienst gesendet wird. Dies geschieht, um den Bot-Dienst 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 den Bot-Dienst 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));
        }
    }

Der folgende Coroutine wird aufgerufen, um eine Antwort anzufordern, nachdem eine Aktivität an den Bot-Dienst gesendet wurde.

    /// <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 Meldung 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 in der Unity Editor-Konsole ein Fehler angezeigt, da die SceneOrganiser-Klasse fehlt. 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 Klasse "Interaktionen"

Die Klasse, die Sie jetzt erstellen möchten, heißt "Interaktionen". Diese Klasse wird verwendet, um die HoloLens Tap Input vom Benutzer zu erkennen.

Wenn der Benutzer während des Betrachtens des Bot-Objekts in der Szene tippt und der Bot bereit ist, spracheingaben zu hören, ändert sich das Bot-Objekt in Rot und beginnt mit dem Hören von Spracheingaben.

Diese Klasse erbt von der GazeInput-Klasse und kann daher auf die Start() -Methode und Variablen aus dieser Klasse verweisen, die von der Verwendung der Basis angegeben wird.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie das Skript "Interaktionen".
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.
Aktualisieren Sie die Namespaces und die Klassenvererbung so, dass sie mit dem folgenden identisch sind, ganz oben in der Interactions-Klasse :
```
using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{
```

Fügen Sie in der Interactions-Klasse 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 Tippbewegung 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, heißt SceneOrganiser. Diese Klasse wird die Szene programmgesteuert einrichten, indem Sie der Hauptkamera Komponenten und Skripts hinzufügen und die entsprechenden Objekte in der Szene erstellen.

So erstellen Sie diese Klasse:

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

Fügen Sie in 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" auf die Hauptkamera. Die Scene Organizer-Komponente sollte nun auf dem Hauptkameraobjekt angezeigt werden, wie in der abbildung unten dargestellt.

Kapitel 13 – Vor dem Bau

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

Alle im Kapitel 4 genannten Einstellungen sind korrekt festgelegt.
Das Skript SceneOrganiser ist an das Main Camera-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 zu 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 Buildeinstellungen, Dateibuildeinstellungen > ....
Klicken Sie im Fenster "Buildeinstellungen " auf "Erstellen".
Wenn noch nicht geschehen, ticken Sie unter "Unity C#-Projekte".
Klicken Sie auf Erstellen. Unity startet ein Explorer-Fenster, in dem Sie einen Ordner erstellen und dann einen Ordner auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt, und nennen Sie ihn " App". Klicken Sie dann mit ausgewähltem App-Ordner auf "Ordner auswählen".
Unity beginnt mit dem Erstellen Ihres Projekts im App-Ordner .
Nachdem Unity das Erstellen 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 dem Hinzufügen eines neuen Fensters informiert).

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 Ihre HoloLens im Entwicklermodus befindet. Gehen Sie hierzu folgendermaßen vor:
1. Öffnen Sie beim Tragen Ihrer HoloLens die Einstellungen.
2. Wechseln sie zu den erweiterten Optionen für Netzwerk- und Internet-WLAN > >
3. Notieren Sie sich die IPv4-Adresse .
4. Navigieren Sie als Nächstes zurück zu "Einstellungen" und dann zu "Update & Sicherheit > für Entwickler".
5. Legen Sie den Entwicklermodus aktiviert fest.
Navigieren Sie zu Ihrem neuen Unity-Build (dem App-Ordner ), und öffnen Sie die Projektmappendatei mit Visual Studio.
Wählen Sie in der Lösungskonfiguration "Debuggen" aus.
Wählen Sie in der Lösungsplattform x86, 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 Ihrer HoloLens angezeigt werden, damit sie gestartet werden können!

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 mithilfe des Menüs "Erstellen" die Option "Lösung bereitstellen" auf dem lokalen Computer 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 (Auf der Benutzeroberfläche wird eine Meldung angezeigt, wenn dies geschieht). Sobald Sie die Einführungsnachricht vom Bot erhalten haben, tippen Sie erneut auf den Bot, sodass er 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 umgehend 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, während auch bekannte Informationen (z. B. die auf lagerten Elemente) bereitgestellt werden.

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.

Endprodukt

Zusatzübungen

Übung 1

Die Unterhaltungsstruktur in dieser Übung ist sehr einfach. Verwenden Sie Microsoft LUIS, um Ihren Bot funktionen für natürliche Sprache zu vermitteln.

Ü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, das Schließen für die Unterhaltung zu implementieren.

Teilen über

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

Unterstützung für Geräte

Voraussetzungen

Vor der Installation

Kapitel 1 – Erstellen der Bot-Anwendung

Kapitel 2 – Erstellen des Azure Bot-Diensts

Kapitel 3 – Veröffentlichen des Bots im Azure Web App Bot-Dienst

Kapitel 4 – Einrichten des Unity-Projekts

Kapitel 5 – Kameraeinrichtung

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 Klasse "Interaktionen"

Kapitel 12 – Erstellen der SceneOrganiser-Klasse

Kapitel 13 – Vor dem Bau

Kapitel 14 – Erstellen und Querladen zu 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