HoloLens (1. Generation) und Azure 312: Botintegration

Artikel
02/18/2025

Hinweis

Die Tutorials der Mixed Reality Academy wurden unter Berücksichtigung von HoloLens (1. Generation) und Mixed Reality Immersive Headsets entwickelt. Daher ist es uns wichtig, diese Tutorials für Entwickler zu belassen, die noch nach Anleitungen bei der Entwicklung 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 beibehalten, um weiterhin auf den unterstützten Geräten zu arbeiten. Es wird eine neue Reihe von Tutorials geben, die in Zukunft veröffentlicht werden, um zu veranschaulichen, wie für HoloLens 2 entwickelt werden kann. Dieser Hinweis wird mit einem Link zu diesen Tutorials aktualisiert, sobald sie veröffentlicht werden.

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

Screenshot: Kommunikation über eine Windows Mixed Reality Anwendung

Der Microsoft Bot Framework V4 besteht aus einer Reihe von APIs, die Entwicklern die Tools zum Erstellen einer erweiterbaren und skalierbaren Botanwendung zur Verfügung stellen sollen. Weitere Informationen finden Sie auf der Seite Microsoft Bot Framework oder im V4-Git-Repository.

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

Verwenden Sie eine Tippen-Geste , um den Bot zu starten, der auf die Stimme des Benutzers lauscht.
Wenn der Benutzer etwas gesagt hat, versucht der Bot, eine Antwort bereitzustellen.
Zeigen Sie die Botantworten als Text in der Nähe des Bots in der Unity-Szene an.

In Ihrer Anwendung liegt es an Ihnen, wie Sie die Ergebnisse in Ihr Design integrieren. In diesem Kurs erfahren Sie, wie Sie einen Azure-Dienst in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen, das Sie aus diesem Kurs gewinnen, zu nutzen, um Ihre Mixed Reality-Anwendung zu verbessern.

Geräteunterstützung

Kurs	HoloLens	Immersive Headsets
MR und Azure 312: Botintegration	✔️	✔️

Hinweis

Während sich dieser Kurs hauptsächlich auf HoloLens konzentriert, können Sie das, was Sie in diesem Kurs lernen, auch auf Windows Mixed Reality immersiven (VR)-Headsets anwenden. Da immersive Headsets (VR) keine zugänglichen Kameras haben, benötigen Sie eine externe Kamera, die an Ihren PC angeschlossen ist. Während Sie den Kurs befolgen, werden Ihnen Notizen zu allen Änderungen angezeigt, die Sie möglicherweise zur Unterstützung immersiver (VR)-Headsets verwenden müssen.

Voraussetzungen

Hinweis

Dieses Tutorial richtet sich an Entwickler, die über grundlegende Erfahrungen mit Unity und C# verfügen. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument entsprechen, was zum Zeitpunkt des Schreibens (Juli 2018) getestet und überprüft wurde. Sie können die neueste Software verwenden, die im Artikel Installieren der Tools aufgeführt ist, obwohl nicht davon ausgegangen werden sollte, dass die Informationen in diesem Kurs perfekt dem entsprechen, was Sie in neuerer Software finden, 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 aktiviertem 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 den Azure Bot-Abruf. Weitere Informationen finden Sie unter diesem Link.

Vorbereitende Schritte

Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Tutorial erwähnte Projekt in einem Stammordner oder in der Nähe des Stammordners zu erstellen (lange Ordnerpfade können zur Buildzeit Zu Problemen führen).
Richten Sie Ihre HoloLens ein und testen Sie sie. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, lesen Sie den Artikel HoloLens-Setup.
Es empfiehlt sich, Kalibrierung und Sensoroptimierung durchzuführen, wenn Sie mit der Entwicklung einer neuen HoloLens-App beginnen (manchmal kann es hilfreich sein, diese Aufgaben für jeden Benutzer auszuführen).

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

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

Kapitel 1: Erstellen der Botanwendung

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

Öffnen Sie Visual Studio. Erstellen Sie ein neues Projekt, wählen Sie ASP NET Core-Webanwendung als Projekttyp aus (Sie finden ihn im Unterabschnitt .NET Core), und nennen Sie ihn MyBot. Klicken Sie auf OK.
Wählen Sie im daraufhin angezeigten Fenster die Option Leer aus. Stellen Sie außerdem sicher, dass das Ziel auf ASP NET Core 2.0 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 Projektmappen-Mybot, und klicken Sie auf NuGet-Pakete für Projektmappe 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-preview aus, und aktivieren Sie die Projektfelder. Klicken Sie dann auf Installieren. Sie haben nun die Bibliotheken installiert, die für Bot Framework v4 erforderlich sind. Schließen Sie die NuGet-Seite.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr ProjektMyBot, 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 weitere Klasse mit dem Namen ConversationContext zu erstellen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf wwwroot, und klicken Sie aufNeues Elementhinzufügen|. Wählen Sie HTML-Seite aus (Sie finden sie im Unterabschnitt Web). Benennen Sie die Datei default.html. Klicken Sie auf Hinzufügen.
Die Liste der Klassen/Objekte im Projektmappen-Explorer sollte wie in der folgenden Abbildung aussehen.
Doppelklicken Sie auf die ConversationContext-Klasse . Diese Klasse ist für das Speichern der Variablen verantwortlich, die vom Bot verwendet werden, um den Kontext der Konversation beizubehalten. Diese Konversationskontextwerte werden in einem instance dieser Klasse beibehalten, da alle instance der MyBot-Klasse jedes Mal aktualisiert werden, 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 jeder eingehenden Aktivität des Kunden aufgerufen werden. In dieser Klasse fügen Sie den Code hinzu, der zum Erstellen der Konversation zwischen dem Bot und dem Kunden verwendet wird. Wie bereits erwähnt, wird bei jedem Empfang einer Aktivität ein instance dieser Klasse initialisiert. 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 Program-Klassendatei , und vergewissern Sie sich, dass der Code darin mit dem folgenden identisch ist:

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. Wechseln Sie dazu auf der Symbolleiste oben in Visual Studio zu Datei>Speichern alle.

Kapitel 2: Erstellen des Azure-Bot Service

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

Melden Sie sich zunächst beim Azure-Portal (https://portal.azure.com) an.
1. Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie eines erstellen. Wenn Sie dieses Tutorial in einer Unterrichts- oder Lab-Situation durcharbeiten, bitten Sie Ihren Kursleiter oder einen der Betreuer um Hilfe beim Einrichten Ihres neuen Kontos.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf Ressource erstellen , suchen Sie nach Web-App-Bot, und klicken Sie auf DIE EINGABETASTE.
Die neue Seite enthält eine Beschreibung des Web App Bot Service. 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 den gewünschten Namen für diese Dienst-instance ein.
2. Wählen Sie ein Abonnement aus.
3. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt zugeordnet sind (z. B. diese Kurse), in einer gemeinsamen Ressourcengruppe zu speichern.
  
  Weitere Informationen zu Azure-Ressourcengruppen finden Sie unter diesem Link.
4. Bestimmen Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Standort befindet sich 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 den für Sie geeigneten Tarif aus. Wenn Sie zum ersten Mal einen Web App Bot Service erstellen, sollte ihnen ein kostenloser Tarif (mit dem Namen F0) zur Verfügung stehen.
6. Der App-Name kann einfach mit dem Botnamen identisch bleiben.
7. Behalten Sie für die Botvorlagedie Option Basic (C#) bei.
8. App Service-Plan/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 keines haben, können Sie sie hier erstellen.
10. Sie müssen auch bestätigen, dass Sie die für diesen Dienst geltenden 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.
Eine Benachrichtigung wird im Portal angezeigt, nachdem die Dienst-instance erstellt wurde.
Klicken Sie auf die Benachrichtigung, um Ihre neue Dienst-instance zu erkunden.
Klicken Sie in der Benachrichtigung auf die Schaltfläche Zu Ressource wechseln, um Ihre neue Dienst-instance zu erkunden. Sie werden zu Ihrer neuen Azure-Dienst-instance 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 Ausgewählte Kanal hinzufügen auf Direct Line Kanal konfigurieren.
Auf dieser Seite finden Sie die geheimen Schlüssel , die es Ihrer Client-App ermöglichen, sich beim Bot zu authentifizieren. Klicken Sie auf die Schaltfläche Anzeigen , und erstellen Sie eine Kopie eines der angezeigten Schlüssel, da Sie diese später in Ihrem Projekt benötigen.

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

Nachdem Ihr Dienst nun bereit ist, müssen Sie Ihren zuvor erstellten Botcode in Ihrer 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 Botlösung/dem Botcode vornehmen.

Zurück zu Ihrer Visual Studio-Projektmappe, die Sie zuvor erstellt haben.
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 Veröffentlichungsziel auswählen auf App Service und dann Auf Vorhandene auswählen, und klicken Sie schließlich auf Profil erstellen (Sie müssen möglicherweise 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 Web App Bot Service-Erstellung verwendet haben. Legen Sie dann die Ansicht als Ressourcengruppe fest, und wählen Sie in der Dropdownordnerstruktur die Ressourcengruppe aus, die Sie zuvor erstellt haben. 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

Es folgt ein typisches Setup 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 nun einen Unity-Projektnamen angeben. Einfügen des HoloLens-Bots Stellen Sie sicher, dass die Projektvorlage auf 3D festgelegt ist. Legen Sie den Speicherort auf einen für Sie geeigneten Speicherort fest (denken Sie daran, dass näher an Stammverzeichnissen besser ist). Klicken Sie dann auf Projekt erstellen.
Wenn Unity geöffnet ist, empfiehlt es sich, die Standardskript Editor auf Visual Studio festgelegt ist, zu überprüfen. Wechseln Sie zu Einstellungen bearbeiten>, und navigieren Sie dann im neuen Fenster zu Externe Tools. Ändern Sie external script Editor in Visual Studio 2017. Schließen Sie das Fenster Einstellungen .
Wechseln Sie als Nächstes zu Dateierstellungseinstellungen>, 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 Dateierstellungseinstellungen > befinden , und stellen Sie sicher, dass:
1. Zielgerät ist auf HoloLens festgelegt
  
  Legen Sie für die immersiven Headsets Zielgerät auf Beliebiges Gerät fest.
2. Buildtyp ist auf D3D festgelegt.
3. SDK ist auf Latest installed (Neueste Installation) festgelegt.
4. Visual Studio-Version ist auf Zuletzt installiert festgelegt.
5. Build und Ausführen ist auf Lokaler Computer festgelegt.
6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.
  1. Wählen Sie hierzu Geöffnete 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 den neu erstellten Ordner Scenes , geben Sie im Textfeld Dateiname: botScene ein, und klicken Sie dann auf Speichern.
7. Die restlichen Einstellungen in Buildeinstellungen sollten vorerst als Standard beibehalten werden.
Klicken Sie im Fenster Buildeinstellungen auf die Schaltfläche Playereinstellungen . Dadurch wird der zugehörige Bereich in dem 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. Die Skriptruntime-Version sollte experimentell sein (NET 4.6-Entsprechung); Um dies zu ändern, ist ein Neustart des Editor erforderlich.
  2. Skripterstellungs-Back-End sollte .NET sein
  3. API-Kompatibilitätsgrad sollte .NET 4.6 sein
2. Aktivieren Sie auf der Registerkarte Veröffentlichungseinstellungen unter Funktionen Folgendes:
  - InternetClient
  - Mikrofon
3. Wählen Sie weiter unten im Bereich unter XR-Einstellungen (unter Veröffentlichungseinstellungen) das Kontrollkästchen Virtual Reality Supported (Virtuelle Realität unterstützt) aus, und stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt wurde.
Zurück unter BuildeinstellungenUnity C#- Projekte ist nicht mehr abgeblendet. aktivieren Sie das Kontrollkästchen daneben.
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-Komponente Einrichten dieses Kurses überspringen und direkt mit dem Code fortfahren möchten, können Sie dieses Azure-MR-312-Package.unitypackage herunterladen, es als benutzerdefiniertes Paket in Ihr Projekt importieren und dann in Kapitel 7 fortfahren.

Wählen Sie im Bereich Hierarchie die Hauptkamera aus.
Nach der Auswahl werden alle Komponenten der Hauptkamera im Inspektorbereich angezeigt.
1. Das Camera-Objekt muss den Namen Hauptkamera 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. Legen Sie die Hintergrundfarbe der Kamerakomponente auf Schwarz, Alpha 0 (Hexadezimalcode: #00000000) fest.

Kapitel 6 – Importieren der Newtonsoft-Bibliothek

Damit Sie empfangene und an die Bot Service e Objekte deserialisieren und serialisieren können, 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 mithilfe der Menüoption Assets>Import Package>Custom Package (Benutzerdefiniertes Paket importieren) zu Unity hinzu.
Stellen Sie im eingeblendeten Feld Unity-Paket importieren sicher, dass alles unter (und einschließlich) Plug-Ins ausgewählt ist.
Klicken Sie auf die Schaltfläche Importieren , um die Elemente zu Ihrem Projekt hinzuzufügen.
Wechseln Sie in der Projektansicht unter Plug-Ins zum Ordner Newtonsoft, und wählen Sie das Newtonsoft-Plug-In aus.
Stellen Sie bei ausgewähltem Newtonsoft-Plug-In sicher, dass Beliebige Plattformdeaktiviert ist, und stellen Sie dann sicher, dass WSAPlayer ebenfalls deaktiviert ist, und klicken Sie dann auf Übernehmen. Dies dient lediglich dazu, zu bestätigen, dass die Dateien ordnungsgemäß konfiguriert sind.

Hinweis

Wenn Sie diese Plug-Ins markieren, werden sie so konfiguriert, dass sie nur im Unity-Editor verwendet werden. Im WSA-Ordner gibt es einen anderen Satz davon, der nach dem Export des Projekts aus Unity verwendet wird.
Als Nächstes müssen Sie den WSA-Ordner im Ordner Newtonsoft öffnen. Es wird eine Kopie der soeben konfigurierten Datei angezeigt. Wählen Sie die Datei aus, und stellen Sie dann im Inspektor sicher, dass
- Jede Plattform ist deaktiviert.
- nurWSAPlayerist aktiviert.
- Nicht aktivierter Prozess

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 Tag Hauptkamera wieder in MainCamera ändern.

Kapitel 8: Erstellen der BotObjects-Klasse

Das erste Skript, das Sie erstellen müssen, ist die BotObjects-Klasse . Dabei handelt es sich um eine leere Klasse, 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önnen stattdessen im Botskript gehostet werden, das Sie später in diesem Kurs erstellen werden.

So erstellen Sie diese Klasse:

Klicken Sie mit der rechten Maustaste in den Bereich Projekt, und klicken Sie dann auf Ordner erstellen>. Nennen 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, ist die GazeInput-Klasse . Diese Klasse ist für Folgendes zuständig:

Erstellen eines Cursors, der den Anvisieren des Spielers darstellt.
Erkennen von Objekten, die vom Anvisieren des Spielers getroffen werden, und Halten eines Verweises 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:

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

Implementieren Sie eine Methode, die den Anvisierungscursor 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 von der Hauptkamera aus 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 jetzt erstellen, heißt Bot. Dies ist die Kernklasse Ihrer Anwendung und speichert Folgendes:

Anmeldeinformationen für Ihren Web-App-Bot
Die Methode, die die Sprachbefehle des Benutzers erfasst
Die Methode, die zum Initiieren von Unterhaltungen mit Ihrem Web-App-Bot erforderlich ist
Die zum Senden von Nachrichten an Ihren Web-App-Bot erforderliche Methode

Um Nachrichten an die Bot Service zu senden, erstellt die SendMessageToBot()-Coroutine eine Aktivität, bei der es sich um ein Objekt handelt, 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 das Skript Bot.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.

Aktualisieren Sie die Namespaces oben in der Bot-Klasse so, dass sie mit den folgenden identisch sind:

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 geheimen Botschlüssel in die botSecret-Variable einfügen. Sie haben Ihren geheimen Botschlüssel 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 Spracherfassung beginnt und endet. Der DictationRecognizer beendet die Erfassung der Benutzerstimme automatisch, 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 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 Konversation mit dem Bot zu beginnen. Sie werden feststellen, dass nach Abschluss des Unterhaltungsaufrufs SendMessageToCoroutine() aufgerufen wird, indem eine Reihe von Parametern übergeben wird, die festlegen, dass die Aktivität als leere Nachricht an den Bot Service gesendet werden soll. Dies geschieht, um die Bot Service zu veranlassen, 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 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 eine Antwort anzufordern, nachdem eine Aktivität an den Bot Service 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 unity Editor Console ein Fehler angezeigt, bei dem die SceneOrganiser-Klasse fehlt. Ignorieren Sie diese Meldung, da Sie diese Klasse später im Tutorial erstellen werden.
Achten Sie darauf, ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Kapitel 11: Erstellen der Interactions-Klasse

Die Klasse, die Sie jetzt erstellen, heißt Interaktionen. Diese Klasse wird verwendet, um die HoloLens Tap-Eingabe des Benutzers zu erkennen.

Wenn der Benutzer beim Betrachten des Bot-Objekts in der Szene tippt und der Bot bereit ist, auf Spracheingaben zu lauschen, ändert sich die Farbe des Bot-Objekts in Rot und beginnt mit dem Lauschen auf Spracheingaben.

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

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 am Anfang der Interactions-Klasse wie folgt sind:
```
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 in diesem Lab erforderliche Klasse heißt SceneOrganiser. Mit dieser Klasse wird die Szene programmgesteuert eingerichtet, indem komponenten und Skripts zur Hauptkamera hinzugefügt und die entsprechenden Objekte in der Szene erstellt werden.

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 und das Einrichten der Parameter und Komponenten zuständig ist:

    /// <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 die Erstellung 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 Skript SceneOrganiser aus dem Ordner Skripts in die Hauptkamera. Die Komponente Scene Organizer sollte nun auf dem Hauptkameraobjekt angezeigt werden, wie in der folgenden Abbildung dargestellt.

Kapitel 13 – Vor dem Bau

Für einen gründlichen Test Ihrer Anwendung müssen Sie sie auf Ihre HoloLens querladen. Bevor Sie dies tun, stellen Sie Folgendes sicher:

Alle in Kapitel 4 erwähnten Einstellungen sind richtig festgelegt.
Das Skript SceneOrganiser ist an das Hauptkameraobjekt angefügt.
Stellen Sie in der Bot-Klasse sicher, dass Sie Ihren geheimen Botschlüssel in die variable botSecret eingefügt haben.

Kapitel 14: Erstellen und Querladen in die HoloLens

Alles, was für den Unity-Abschnitt dieses Projekts erforderlich ist, ist nun abgeschlossen, sodass es an der Zeit ist, es über Unity zu erstellen.

Navigieren Sie zu Buildeinstellungen, Dateibuildeinstellungen > ....
Klicken Sie im Fenster Buildeinstellungen auf Erstellen.
Wenn noch nicht geschehen, markieren Sie Unity C#-Projekte.
Klicken Sie auf Erstellen. Unity startet ein Explorer Fenster, in dem Sie einen Ordner erstellen und dann auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt, und nennen Sie ihn App. Klicken Sie dann bei ausgewähltem App-Ordner auf Ordner auswählen.
Unity beginnt mit dem Erstellen Ihres Projekts im Ordner App .
Sobald 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 es möglicherweise nicht immer über Ihren Fenstern angezeigt wird, aber Sie über das Hinzufügen eines neuen Fensters informiert).

Kapitel 15: Bereitstellen in HoloLens

So stellen Sie die Bereitstellung auf HoloLens bereit:

Sie benötigen die IP-Adresse Ihrer HoloLens (für Remote Deploy) und um sicherzustellen, dass sich Ihre HoloLens im Entwicklermodus befindet. Gehen Sie dazu wie folgt vor:
1. Öffnen Sie beim Tragen Ihrer HoloLens die Einstellungen.
2. Wechseln Sie zu Netzwerk & Internet > Wi-Fi > Erweiterte Optionen
3. Notieren Sie sich die IPv4-Adresse .
4. Navigieren Sie als Nächstes zurück zu Einstellungen und dann zu Update & Security > For Developers.
5. Legen Sie den Entwicklermodus ein.
Navigieren Sie zu Ihrem neuen Unity-Build (dem Ordner App ), und öffnen Sie die Projektmappendatei mit Visual Studio.
Wählen Sie unter Projektmappenkonfigurationdie Option Debuggen aus.
Wählen Sie auf 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 Ihrer HoloLens angezeigt werden und kann gestartet werden!

Hinweis

Legen Sie für die Bereitstellung für immersive Headsets die Lösungsplattform auf Lokaler Computer und die Konfiguration auf Debuggen mit x86 als Plattform fest. Stellen Sie dann auf dem lokalen Computer bereit, und wählen Sie im Menü Erstellen die Option Lösung bereitstellen aus.

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 Tippen-Geste , 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). Nachdem Sie die Einführungsnachricht vom Bot erhalten haben, tippen Sie erneut auf den Bot, damit er rot wird und beginnt, Ihre Stimme zu hören.
Sobald Sie die Kommunikation beenden, sendet Ihre Anwendung Ihre Nachricht an den Bot, und Sie erhalten sofort eine Antwort, die auf 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) beibehalten und gleichzeitig bekannte Informationen (z. B. die vorgehaltenen Elemente) bereitstellt.

Einige Fragen zum Stellen des Bots:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Ihre fertige Web-App-Bot-Anwendung (v4)

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

Endprodukt

Bonusübungen

Übung 1

Die Konversationsstruktur in diesem Lab ist sehr einfach. Verwenden Sie Microsoft LUIS, um Ihrem Bot Funktionen zum Verstehen natürlicher Sprache zu bieten.

Übung 2

Dieses Beispiel umfasst nicht das Beenden einer Unterhaltung und das Neustarten einer neuen Unterhaltung. Um das Botfeature vollständig zu machen, versuchen Sie, den Abschluss der Unterhaltung zu implementieren.

Teilen über

HoloLens (1. Generation) und Azure 312: Botintegration

Geräteunterstützung

Voraussetzungen

Vorbereitende Schritte

Kapitel 1: Erstellen der Botanwendung

Kapitel 2: Erstellen des Azure-Bot Service

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

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 Interactions-Klasse

Kapitel 12: Erstellen der SceneOrganiser-Klasse

Kapitel 13 – Vor dem Bau

Kapitel 14: Erstellen und Querladen in die HoloLens

Kapitel 15: Bereitstellen in HoloLens

Kapitel 16: Verwenden der Anwendung auf der HoloLens

Einige Fragen zum Stellen des Bots:

Ihre fertige Web-App-Bot-Anwendung (v4)

Bonusübungen

Übung 1

Übung 2

Feedback

Zusätzliche Ressourcen