Udostępnij za pośrednictwem

Urządzenia HoloLens (1. generacji) i Azure 312: integracja bota

  • Artykuł

Uwaga

Samouczki akademii rzeczywistości mieszanej zostały zaprojektowane z myślą o urządzeniach HoloLens (1. generacji) i zestawach słuchawkowych immersyjnych rzeczywistości mieszanej. W związku z tym uważamy, że ważne jest pozostawienie tych samouczków na miejscu dla deweloperów, którzy nadal szukają wskazówek dotyczących opracowywania tych urządzeń. Te samouczki nie zostaną zaktualizowane przy użyciu najnowszych zestawów narzędzi ani interakcji używanych dla urządzenia HoloLens 2. Będą one utrzymywane w celu kontynuowania pracy na obsługiwanych urządzeniach. W przyszłości zostanie opublikowana nowa seria samouczków, które pokażą, jak opracowywać urządzenia HoloLens 2. To powiadomienie zostanie zaktualizowane za pomocą linku do tych samouczków po ich opublikowaniu.

W tym kursie dowiesz się, jak utworzyć i wdrożyć bota przy użyciu programu Microsoft Bot Framework w wersji 4 i komunikować się z nim za pośrednictwem aplikacji Windows Mixed Reality.

Zrzut ekranu przedstawiający komunikację za pośrednictwem aplikacji Windows Mixed Reality.

Microsoft Bot Framework V4 to zestaw interfejsów API zaprojektowanych w celu zapewnienia deweloperom narzędzi do tworzenia rozszerzalnej i skalowalnej aplikacji bota. Aby uzyskać więcej informacji, odwiedź stronę platformy Microsoft Bot Framework lub repozytorium Git w wersji 4.

Po ukończeniu tego kursu utworzysz aplikację windows Mixed Reality, która będzie mogła wykonać następujące czynności:

  1. Użyj gestu naciśnięcia, aby rozpocząć nasłuchiwanie bota dla głosu użytkowników.
  2. Gdy użytkownik coś powiedział, bot spróbuje podać odpowiedź.
  3. Wyświetl odpowiedź botów jako tekst umieszczony w pobliżu bota w scenie aparatu Unity.

W aplikacji należy do Ciebie, jak zintegrować wyniki z projektem. Ten kurs został zaprojektowany, aby nauczyć cię, jak zintegrować usługę platformy Azure z projektem aparatu Unity. Twoim zadaniem jest wykorzystanie wiedzy uzyskanych z tego kursu w celu ulepszenia aplikacji rzeczywistości mieszanej.

Obsługa urządzeń

Kurs HoloLens Immersyjne zestawy nagłowne
MR i Azure 312: integracja bota ✔️ ✔️

Uwaga

Chociaż ten kurs koncentruje się głównie na urządzeniu HoloLens, możesz również zastosować to, czego nauczysz się w tym kursie, do zestawów słuchawkowych immersywnych (VR) systemu Windows Mixed Reality. Ponieważ immersyjne zestawy nagłowne (VR) nie mają dostępnych kamer, potrzebny jest zewnętrzny aparat podłączony do komputera. Wraz z kursem zobaczysz notatki dotyczące wszelkich zmian, które mogą być potrzebne do obsługi immersywnych zestawów słuchawkowych (VR).

Wymagania wstępne

Uwaga

Ten samouczek jest przeznaczony dla deweloperów, którzy mają podstawowe doświadczenie w językach Unity i C#. Należy również pamiętać, że wymagania wstępne i pisemne instrukcje zawarte w tym dokumencie reprezentują to, co zostało przetestowane i zweryfikowane w momencie pisania dokumentu (lipiec 2018 r.). Możesz bezpłatnie korzystać z najnowszego oprogramowania, jak wymieniono w artykule dotyczącym instalacji narzędzi , choć nie należy zakładać, że informacje zawarte w tym kursie doskonale pasują do tego, co znajdziesz w nowszym oprogramowaniu niż to, co zostało wymienione poniżej.

Na potrzeby tego kursu zalecamy następujące oprogramowanie i sprzęt:

Przed rozpoczęciem

  1. Aby uniknąć problemów podczas tworzenia tego projektu, zdecydowanie zaleca się utworzenie projektu wymienionego w tym samouczku w folderze głównym lub niemal głównym (długie ścieżki folderów mogą powodować problemy w czasie kompilacji).
  2. Skonfiguruj i przetestuj urządzenie HoloLens. Jeśli potrzebujesz pomocy technicznej dotyczącej konfigurowania urządzenia HoloLens, zapoznaj się z artykułem dotyczącym konfiguracji urządzenia HoloLens.
  3. Dobrym pomysłem jest przeprowadzenie kalibracji i dostrajania czujników podczas tworzenia nowej aplikacji HoloLens (czasami może to pomóc w wykonywaniu tych zadań dla każdego użytkownika).

Aby uzyskać pomoc dotyczącą kalibracji, skorzystaj z tego linku do artykułu Kalibracja urządzenia HoloLens.

Aby uzyskać pomoc dotyczącą dostrajania czujników, skorzystaj z tego linku do artykułu Dostrajanie czujników HoloLens.

Rozdział 1 — tworzenie aplikacji bota

Pierwszym krokiem jest utworzenie bota jako lokalnej aplikacji internetowej ASP.Net Core. Po zakończeniu i przetestowaniu go opublikujesz w witrynie Azure Portal.

  1. Otwórz program Visual Studio. Utwórz nowy projekt, wybierz pozycję Aplikacja internetowa platformy ASP NET Core jako typ projektu (znajdziesz go w podsekcji .NET Core) i wywołaj go MyBot. Kliknij przycisk OK.

  2. W oknie, które zostanie wyświetlone, wybierz pozycję Puste. Upewnij się również, że element docelowy jest ustawiony na platformę ASP NET Core 2.0 , a ustawienie Uwierzytelnianie ma wartość Brak uwierzytelniania. Kliknij przycisk OK.

    Zrzut ekranu przedstawiający okno Nowa aplikacja internetowa P P S N E T Core.

  3. Rozwiązanie zostanie teraz otwarte. Kliknij prawym przyciskiem myszy pozycję Rozwiązanie Mybot w Eksplorator rozwiązań i kliknij pozycję Zarządzaj pakietami NuGet dla rozwiązania.

    Zrzut ekranu przedstawiający otwarte rozwiązanie z wyróżnioną pozycją

  4. Na karcie Przeglądaj wyszukaj ciąg Microsoft.Bot.Builder.Integration.AspNet.Core (upewnij się, że zaznaczono opcję Uwzględnij wstępne wydanie). Wybierz pakiet w wersji 4.0.1-preview i zaznacz pola projektu. Następnie kliknij pozycję Zainstaluj. Teraz zainstalowano biblioteki wymagane dla platformy Bot Framework w wersji 4. Zamknij stronę NuGet.

    Zrzut ekranu przedstawiający menedżera rozwiązań Nu-Get.

  5. Kliknij prawym przyciskiem myszy projekt MyBot w Eksplorator rozwiązań i kliknij pozycję Dodaj | klasę.

    Zrzut ekranu przedstawiający proces dodawania nowej klasy do usługi MyBot.

  6. Nadaj klasie nazwę MyBot i kliknij pozycję Dodaj.

    Zrzut ekranu przedstawiający tworzenie nowej klasy

  7. Powtórz poprzedni punkt, aby utworzyć inną klasę o nazwie ConversationContext.

  8. Kliknij prawym przyciskiem myszy pozycję wwwroot w Eksplorator rozwiązań i kliknij pozycję Dodaj | nowy element. Wybierz pozycję Strona HTML (znajdziesz ją w podsekcji Web). Nadaj plikowi nazwę default.html. Kliknij przycisk Dodaj.

    Zrzut ekranu przedstawiający tworzenie nowej strony H T M L z poziomu okna Eksplorator rozwiązań.

  9. Lista klas/obiektów w Eksplorator rozwiązań powinna wyglądać jak na poniższym obrazie.

    Zrzut ekranu przedstawiający okno Eksplorator rozwiązań z listą klas.

  10. Kliknij dwukrotnie klasę ConversationContext . Ta klasa jest odpowiedzialna za przechowywanie zmiennych używanych przez bota w celu zachowania kontekstu konwersacji. Te wartości kontekstu konwersacji są zachowywane w wystąpieniu tej klasy, ponieważ każde wystąpienie klasy MyBot będzie odświeżane za każdym razem, gdy zostanie odebrane działanie. Dodaj następujący kod do klasy:

    namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}

  11. Kliknij dwukrotnie klasę MyBot . Ta klasa będzie obsługiwać programy obsługi wywoływane przez wszelkie przychodzące działania od klienta. W tej klasie dodasz kod używany do tworzenia konwersacji między botem a klientem. Jak wspomniano wcześniej, wystąpienie tej klasy jest inicjowane za każdym razem, gdy zostanie odebrane działanie. Dodaj następujący kod do tej klasy:

    using Microsoft.Bot;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using System.Threading.Tasks;

namespace MyBot
{
    public class MyBot : IBot
    {       
        public async Task OnTurn(ITurnContext context)
        {
            ConversationContext.userMsg = context.Activity.Text;

            if (context.Activity.Type is ActivityTypes.Message)
            {
                if (string.IsNullOrEmpty(ConversationContext.userName))
                {
                    ConversationContext.userName = ConversationContext.userMsg;
                    await context.SendActivity($"Hello {ConversationContext.userName}. Looks like today it is going to rain. \nLuckily I have umbrellas and waterproof jackets to sell!");
                }
                else
                {
                    if (ConversationContext.userMsg.Contains("how much"))
                    {
                        if (ConversationContext.userMsg.Contains("umbrella")) await context.SendActivity($"Umbrellas are $13.");
                        else if (ConversationContext.userMsg.Contains("jacket")) await context.SendActivity($"Waterproof jackets are $30.");
                        else await context.SendActivity($"Umbrellas are $13. \nWaterproof jackets are $30.");
                    }
                    else if (ConversationContext.userMsg.Contains("color") || ConversationContext.userMsg.Contains("colour"))
                    {
                        await context.SendActivity($"Umbrellas are black. \nWaterproof jackets are yellow.");
                    }
                    else
                    {
                        await context.SendActivity($"Sorry {ConversationContext.userName}. I did not understand the question");
                    }
                }
            }
            else
            {

                ConversationContext.userMsg = string.Empty;
                ConversationContext.userName = string.Empty;
                await context.SendActivity($"Welcome! \nI am the Weather Shop Bot \nWhat is your name?");
            }

        }
    }
}

  12. Kliknij dwukrotnie klasę Startup . Ta klasa zainicjuje bota. Dodaj następujący kod do klasy:

    using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Bot.Builder.BotFramework;
using Microsoft.Bot.Builder.Integration.AspNet.Core;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace MyBot
{
public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                .AddEnvironmentVariables();
            Configuration = builder.Build();
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton(_ => Configuration);
            services.AddBot<MyBot>(options =>
            {
                options.CredentialProvider = new ConfigurationCredentialProvider(Configuration);
            });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseDefaultFiles();
            app.UseStaticFiles();
            app.UseBotFramework();
        }
    }
}

  13. Otwórz plik klasy Program i sprawdź, czy kod w nim jest taki sam jak poniżej:

    using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;

namespace MyBot
{
    public class Program
    {
        public static void Main(string[] args)
        {
            BuildWebHost(args).Run();
        }

        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .Build();
    }
}

  14. Pamiętaj, aby zapisać zmiany, aby to zrobić, przejdź do pozycji Plik>Zapisz wszystko z paska narzędzi w górnej części programu Visual Studio.

Rozdział 2 . Tworzenie usługi Azure Bot Service

Po utworzeniu kodu bota musisz opublikować go w wystąpieniu usługi Bot Service aplikacji internetowej w witrynie Azure Portal. W tym rozdziale pokazano, jak utworzyć i skonfigurować usługę Bot Service na platformie Azure, a następnie opublikować w niej kod.

  1. Najpierw zaloguj się do witryny Azure Portal (https://portal.azure.com).

    1. Jeśli nie masz jeszcze konta platformy Azure, musisz je utworzyć. Jeśli obserwujesz ten samouczek w sytuacji w klasie lub laboratorium, poproś instruktora lub jednego z opiekunów o pomoc przy konfigurowaniu nowego konta.

  2. Po zalogowaniu kliknij pozycję Utwórz zasób w lewym górnym rogu i wyszukaj bota aplikacji internetowej, a następnie kliknij przycisk Enter.

    Zrzut ekranu przedstawiający pulpit nawigacyjny platformy Microsoft Azure z wyróżnioną pozycją

  3. Nowa strona zawiera opis usługi Bot Service aplikacji internetowej. W lewym dolnym rogu tej strony wybierz przycisk Utwórz , aby utworzyć skojarzenie z tą usługą.

    Zrzut ekranu przedstawiający stronę Bot aplikacji internetowej i przycisk

  4. Po kliknięciu pozycji Utwórz:

    1. Wstaw żądaną nazwę dla tego wystąpienia usługi.

    2. Wybierz subskrypcję.

    3. Wybierz grupę zasobów lub utwórz nową. Grupa zasobów umożliwia monitorowanie, kontrolowanie dostępu, aprowizowania i zarządzania rozliczeniami dla kolekcji zasobów platformy Azure. Zaleca się zachowanie wszystkich usług platformy Azure skojarzonych z jednym projektem (np. takimi jak te kursy) w ramach wspólnej grupy zasobów.

      Jeśli chcesz dowiedzieć się więcej o grupach zasobów platformy Azure, skorzystaj z tego linku

    4. Określ lokalizację dla grupy zasobów (jeśli tworzysz nową grupę zasobów). Lokalizacja najlepiej znajdować się w regionie, w którym aplikacja będzie uruchamiana. Niektóre zasoby platformy Azure są dostępne tylko w niektórych regionach.

    5. Wybierz odpowiednią warstwę cenową, jeśli po raz pierwszy utworzysz usługę Bot Service aplikacji internetowej, powinna być dostępna warstwa bezpłatna (o nazwie F0).

    6. Nazwa aplikacji może być po prostu pozostawiona tak samo jak nazwa bota.

    7. Pozostaw szablon bota jako Podstawowy (C#).

    8. Plan usługi App Service/lokalizacja powinien zostać wypełniony automatycznie dla twojego konta.

    9. Ustaw usługę Azure Storage , której chcesz użyć do hostowania bota. Jeśli jeszcze go nie masz, możesz go utworzyć tutaj.

    10. Musisz również potwierdzić, że rozumiesz warunki i postanowienia zastosowane do tej usługi.

    11. Kliknij przycisk Utwórz.

      Zrzut ekranu przedstawiający wymagane pola potrzebne do utworzenia nowej usługi.

  5. Po kliknięciu pozycji Utwórz trzeba będzie poczekać na utworzenie usługi. Może to potrwać minutę.

  6. Po utworzeniu wystąpienia usługi w portalu zostanie wyświetlone powiadomienie.

    Zrzut ekranu przedstawiający ikonę powiadomienia wyróżnioną po utworzeniu wystąpienia usługi.

  7. Kliknij powiadomienie, aby zapoznać się z nowym wystąpieniem usługi.

    Zrzut ekranu przedstawiający pomyślne wdrożenie i przycisk

  8. Kliknij przycisk Przejdź do zasobu w powiadomieniu, aby zapoznać się z nowym wystąpieniem usługi. Nastąpi przekierowanie do nowego wystąpienia usługi platformy Azure.

    Zrzut ekranu przedstawiający okna Zasoby po kliknięciu przycisku

  9. W tym momencie należy skonfigurować funkcję o nazwie Direct Line , aby umożliwić aplikacji klienckiej komunikowanie się z tą usługą Bot Service. Kliknij pozycję Kanały, a następnie w sekcji Dodawanie polecanego kanału kliknij pozycję Konfiguruj kanał Direct Line.

    Zrzut ekranu przedstawiający kanał Configure Direct Line (Konfigurowanie kanału linii bezpośredniej) wyróżnioną w elemencie MyHoloLensBot.

  10. Na tej stronie znajdziesz klucze tajne , które umożliwią aplikacji klienckiej uwierzytelnianie za pomocą bota. Kliknij przycisk Pokaż i pobierz kopię jednego z wyświetlonych kluczy, ponieważ będzie to potrzebne w dalszej części projektu.

    Zrzut ekranu przedstawiający klucze tajne wyróżnione w temacie MyHoloLensBot Configure Direct Line channel (Konfigurowanie kanału linii bezpośredniej).

Rozdział 3 — Publikowanie bota w usłudze Azure Web App Bot Service

Teraz, gdy usługa jest gotowa, musisz opublikować utworzony wcześniej kod bota w nowo utworzonej usłudze Bot Service.

Uwaga

Za każdym razem, gdy wprowadzisz zmiany w rozwiązaniu bota/kodzie, musisz opublikować bota w usłudze Azure Service.

  1. Wróć do utworzonego wcześniej rozwiązania programu Visual Studio.

  2. Kliknij prawym przyciskiem myszy projekt MyBot w Eksplorator rozwiązań, a następnie kliknij pozycję Publikuj.

    Zrzut ekranu przedstawiający menu rozwijane projektu

  3. Na stronie Wybierz miejsce docelowe publikacji kliknij pozycję App Service, a następnie wybierz pozycję Istniejący, a następnie kliknij pozycję Utwórz profil (może być konieczne kliknięcie strzałki listy rozwijanej obok przycisku Publikuj, jeśli nie jest to widoczne).

    Zrzut ekranu przedstawiający stronę Wybierz docelową publikację z wyróżnioną pozycją

  4. Jeśli jeszcze nie zalogowano się do konta Microsoft, musisz to zrobić tutaj.

  5. Na stronie Publikowanie znajdziesz, że musisz ustawić tę samą subskrypcję, która była używana do tworzenia usługi Bot Service aplikacji internetowej. Następnie ustaw widok jako grupę zasobów, a następnie w strukturze folderów rozwijanych wybierz utworzoną wcześniej grupę zasobów. Kliknij przycisk OK.

    Zrzut ekranu przedstawiający okno usługi App Service z tą samą subskrypcją używaną do utworzenia usługi Bot Service aplikacji internetowej.

  6. Teraz kliknij przycisk Publikuj i poczekaj na opublikowanie bota (może to potrwać kilka minut).

    Zrzut ekranu przedstawiający okno Publikowanie z przyciskiem Publikuj.

Rozdział 4 — Konfigurowanie projektu aparatu Unity

Poniżej przedstawiono typową konfigurację do opracowywania za pomocą rzeczywistości mieszanej, a w związku z tym jest to dobry szablon dla innych projektów.

  1. Otwórz aparat Unity i kliknij pozycję Nowy.

    Zrzut ekranu przedstawiający okno Projekty aparatu Unity z ikoną projektu

  2. Teraz musisz podać nazwę projektu aparatu Unity. Wstaw bota HoloLens. Upewnij się, że szablon projektu jest ustawiony na 3D. Ustaw lokalizację na odpowiednią dla Ciebie (pamiętaj, że bliżej katalogów głównych jest lepiej). Następnie kliknij pozycję Utwórz projekt.

    Zrzut ekranu przedstawiający wyróżnione nowe pole nazwy projektu aparatu Unity.

  3. Po otwarciu aparatu Unity warto sprawdzić, czy domyślny edytor skryptów jest ustawiony na program Visual Studio. Przejdź do pozycji Edytuj > preferencje , a następnie w nowym oknie przejdź do pozycji Narzędzia zewnętrzne. Zmień edytor skryptów zewnętrznych na Visual Studio 2017. Zamknij okno Preferencje.

    Zrzut ekranu przedstawiający okno Preferencje aparatu Unity z wymaganymi ustawieniami.

  4. Następnie przejdź do pozycji Ustawienia kompilacji pliku > i wybierz pozycję platforma uniwersalna systemu Windows, a następnie kliknij przycisk Przełącz platformę, aby zastosować wybór.

    Zrzut ekranu przedstawiający okno Ustawienia kompilacji z wyróżnionym przyciskiem

  5. Nadal w obszarze Ustawienia kompilacji pliku > i upewnij się, że:

    1. Urządzenie docelowe jest ustawione na urządzenie HoloLens

      W przypadku immersyjnych zestawów słuchawkowych ustaw opcję Urządzenie docelowe na dowolne urządzenie.

    2. Typ kompilacji jest ustawiony na D3D

    3. Zestaw SDK jest ustawiony na najnowszą zainstalowaną

    4. Dla wersji programu Visual Studio jest ustawiona wartość Najnowsza zainstalowana

    5. Kompilowanie i uruchamianie jest ustawione na komputer lokalny

    6. Zapisz scenę i dodaj ją do kompilacji.

      1. W tym celu wybierz pozycję Dodaj otwarte sceny. Zostanie wyświetlone okno zapisywania.

        Zrzut ekranu przedstawiający okno Ustawienia kompilacji z wyróżnionym przyciskiem

      2. Utwórz nowy folder dla tego i dowolnej przyszłości sceny, a następnie wybierz przycisk Nowy folder , aby utworzyć nowy folder, nadaj mu nazwę Sceny.

        Zrzut ekranu przedstawiający tworzenie nowego folderu

      3. Otwórz nowo utworzony folder Sceny , a następnie w polu Nazwa pliku: tekst wpisz BotScene, a następnie kliknij pozycję Zapisz.

        Zrzut ekranu przedstawiający folder Sceny i nowo utworzony plik, który jest zapisywany.

    7. Pozostałe ustawienia w obszarze Ustawienia kompilacji powinny być pozostawione jako domyślne na razie.

  6. W oknie Ustawienia kompilacji kliknij przycisk Ustawienia odtwarzacza, spowoduje to otwarcie powiązanego panelu w obszarze, w którym znajduje się inspektor.

    Zrzut ekranu przedstawiający okno Ustawienia kompilacji na karcie Inspektor.

  7. W tym panelu należy zweryfikować kilka ustawień:

    1. Na karcie Inne ustawienia:

      1. Wersja środowiska uruchomieniowego skryptów powinna być eksperymentalna (odpowiednik platformy NET 4.6); zmiana tego ustawienia będzie wymagać ponownego uruchomienia edytora.

      2. Zaplecze skryptów powinno mieć wartość .NET

      3. Poziom zgodności interfejsu API powinien mieć wartość .NET 4.6

        Zrzut ekranu przedstawiający kartę Inne ustawienia z wymaganymi ustawieniami.

    2. Na karcie Ustawienia publikowania w obszarze Możliwości sprawdź:

      • InternetClient

      • Mikrofon

        Zrzut ekranu przedstawiający opcję

    3. W dalszej części panelu w obszarze Ustawienia XR (znajdujące się poniżej ustawienia publikowania) zaznacz pole Virtual Reality Supported (Obsługiwane w rzeczywistości wirtualnej), upewnij się, że dodano zestaw WINDOWS Mixed Reality SDK .

      Zrzut ekranu przedstawiający usługę Virtual Reality Supported (Obsługiwana rzeczywistość wirtualna) i Windows Mixed Reality S D K added (Dodano obsługę rzeczywistości wirtualnej) i Windows Mixed Reality S D K ..

  8. Po powrocie do ustawień kompilacji Projekty języka C# środowiska Unity nie są już wyszarzone; zaznacz pole wyboru obok tego.

  9. Zamknij okno Build Settings (Ustawienia kompilacji).

  10. Zapisz scenę i projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Rozdział 5 — Konfiguracja aparatu

Ważne

Jeśli chcesz pominąć składnik Konfiguracji aparatu Unity tego kursu i kontynuować bezpośrednio w kodzie, możesz pobrać ten pakiet Azure-MR-312-Package.unitypackage, zaimportować go do projektu jako pakiet niestandardowy, a następnie kontynuować z rozdziału 7.

  1. W panelu Hierarchia wybierz kamerę główną.

  2. Po wybraniu tej opcji będzie można zobaczyć wszystkie składniki głównego aparatu w panelu Inspektor.

    1. Obiekt Camera musi mieć nazwę Main Camera (zanotuj pisownię)
    2. Główny tag aparatu musi być ustawiony na MainCamera (zanotuj pisownię)
    3. Upewnij się, że pozycja przekształcania jest ustawiona na 0, 0, 0
    4. Ustaw opcję Wyczyść flagi na Kolor stały.
    5. Ustaw kolor tła składnika Aparatu na , Alfa 0 (kod szesnastkowy: #00000000)

    Zrzut ekranu przedstawiający wszystkie składniki głównego aparatu w panelu Inspektor.

Rozdział 6 — importowanie biblioteki Newtonsoft

Aby ułatwić deserializacji i serializowania odebranych i wysłanych do usługi Bot Service, należy pobrać bibliotekę Newtonsoft . W tym miejscu znajdziesz zgodną wersję z prawidłową strukturą folderów aparatu Unity.

Aby zaimportować bibliotekę Newtonsoft do projektu, użyj pakietu aparatu Unity, który został dołączony do tego kursu.

  1. Dodaj pakiet unitypackage do aparatu Unity przy użyciu opcji menu Importuj pakiet>niestandardowy pakietu Assets>.

    Zrzut ekranu przedstawiający menu rozwijane Zasoby z wybraną pozycją

  2. W wyświetlonym oknie Importuj pakiet aparatu Unity upewnij się, że wybrano wszystkie elementy w obszarze (i w tym) Wtyczki .

    Zrzut ekranu przedstawiający okno podręczne Importuj pakiet aparatu Unity z wybraną pozycję

  3. Kliknij przycisk Importuj, aby dodać elementy do projektu.

  4. Przejdź do folderu Newtonsoft w obszarze Wtyczki w widoku projektu i wybierz wtyczkę Newtonsoft.

    Zrzut ekranu przedstawiający folder Newtonsoft w widoku projektu.

  5. Po wybraniu wtyczki Newtonsoft upewnij się, że pole wyboru Dowolna platforma jest niezaznaczone, a następnie upewnij się, że WSAPlayer jest również niezaznaczone, a następnie kliknij przycisk Zastosuj. Wystarczy potwierdzić, że pliki są poprawnie skonfigurowane.

    Zrzut ekranu przedstawiający poprawne opcje dla wtyczki Newtonsoft.

    Uwaga

    Oznaczanie tych wtyczek konfiguruje je tak, aby były używane tylko w Edytorze aparatu Unity. Istnieje inny zestaw z nich w folderze WSA, który będzie używany po wyeksportowaniu projektu z aparatu Unity.

  6. Następnie należy otworzyć folder WSA w folderze Newtonsoft . Zobaczysz kopię tego samego pliku, który został właśnie skonfigurowany. Wybierz plik, a następnie w inspektorze upewnij się, że

    • Wszystkie platformy są niezaznaczone
    • zaznaczono tylko WSAPlayer
    • Nie zaznaczono procesu

    Zrzut ekranu przedstawiający poprawne opcje dla wtyczki Newtonsoft w folderze WSA.

Rozdział 7 — tworzenie bottagu

  1. Utwórz nowy obiekt Tag o nazwie BotTag. Wybierz kamerę główną w scenie. Kliknij menu rozwijane Tag w panelu Inspector (Inspektor). Kliknij pozycję Dodaj tag.

    Zrzut ekranu przedstawiający menu rozwijane Tag kamery głównej w panelu Inspector (Inspektor) z wyróżnioną pozycją

  2. + Kliknij symbol. Nazwij nowy tag jako BotTag, Zapisz.

    Zrzut ekranu przedstawiający panel Inspector (Inspektor) z nową nazwą botTag oraz symbolem i przyciskiem Save (Zapisz).

Ostrzeżenie

Nie należy stosować botTag do aparatu głównego. Jeśli to zrobiono przypadkowo, pamiętaj o zmianie tagu Main Camera z powrotem na MainCamera.

Rozdział 8 — tworzenie klasy BotObjects

Pierwszym skryptem, który należy utworzyć, jest klasa BotObjects , która jest pustą klasą utworzoną, aby seria innych obiektów klas mogła być przechowywana w tym samym skry skrycie i uzyskiwana przez inne skrypty w scenie.

Tworzenie tej klasy jest wyłącznie wyborem architektonicznym. Te obiekty mogą być hostowane w skry skrycie bota, który zostanie utworzony w dalszej części tego kursu.

Aby utworzyć tę klasę:

  1. Kliknij prawym przyciskiem myszy w panelu Projekt, a następnie pozycję Utwórz > folder. Nadaj folderowi nazwę Scripts( Skrypty).

    Utwórz folder skryptów.

  2. Kliknij dwukrotnie folder Skrypty, aby go otworzyć. Następnie w tym folderze kliknij prawym przyciskiem myszy i wybierz polecenie Utwórz > skrypt języka C#. Nadaj skryptowi nazwę BotObjects.

  3. Kliknij dwukrotnie nowy skrypt BotObjects , aby otworzyć go za pomocą programu Visual Studio.

  4. Usuń zawartość skryptu i zastąp ją następującym kodem:

    using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BotObjects : MonoBehaviour{}

/// <summary>
/// Object received when first opening a conversation
/// </summary>
[Serializable]
public class ConversationObject
{
    public string ConversationId;
    public string token;
    public string expires_in;
    public string streamUrl;
    public string referenceGrammarId;
}

/// <summary>
/// Object including all Activities
/// </summary>
[Serializable]
public class ActivitiesRootObject
{
    public List<Activity> activities { get; set; }
    public string watermark { get; set; }
}
[Serializable]
public class Conversation
{
    public string id { get; set; }
}
[Serializable]
public class From
{
    public string id { get; set; }
    public string name { get; set; }
}
[Serializable]
public class Activity
{
    public string type { get; set; }
    public string channelId { get; set; }
    public Conversation conversation { get; set; }
    public string id { get; set; }
    public From from { get; set; }
    public string text { get; set; }
    public string textFormat { get; set; }
    public DateTime timestamp { get; set; }
    public string serviceUrl { get; set; }
}

  5. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

Rozdział 9 — Tworzenie klasy GazeInput

Następną klasą , którą utworzysz, jest klasa GazeInput . Ta klasa jest odpowiedzialna za:

  • Utworzenie kursora, który będzie reprezentować spojrzenie odtwarzacza.
  • Wykrywanie obiektów trafionych przez spojrzenie odtwarzacza i trzymanie odwołania do wykrytych obiektów.

Aby utworzyć tę klasę:

  1. Przejdź do utworzonego wcześniej folderu Skrypty .

  2. Kliknij prawym przyciskiem myszy wewnątrz folderu Utwórz > skrypt języka C#. Wywołaj skrypt GazeInput.

  3. Kliknij dwukrotnie nowy skrypt GazeInput , aby otworzyć go za pomocą programu Visual Studio.

  4. Wstaw następujący wiersz w prawo u góry nazwy klasy:

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

  5. Następnie dodaj następujące zmienne wewnątrz klasy GazeInput powyżej metody Start():

        [Tooltip("Used to compare whether an object is to be interacted with.")]
    internal string InteractibleTag = "BotTag";

    /// <summary>
    /// Length of the gaze
    /// </summary>
    internal float GazeMaxDistance = 300;

    /// <summary>
    /// Object currently gazed
    /// </summary>
    internal GameObject FocusedObject { get; private set; }

    internal GameObject _oldFocusedObject { get; private set; }

    internal RaycastHit HitInfo { get; private set; }

    /// <summary>
    /// Cursor object visible in the scene
    /// </summary>
    internal GameObject Cursor { get; private set; }

    internal bool Hit { get; private set; }

    internal Vector3 Position { get; private set; }

    internal Vector3 Normal { get; private set; }

    private Vector3 _gazeOrigin;

    private Vector3 _gazeDirection;

  6. Należy dodać kod metody Start(). Zostanie ona wywołana, gdy klasa inicjuje:

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

  7. Zaimplementuj metodę, która utworzy wystąpienie i skonfiguruje kursor spojrzenia:

        /// <summary>
    /// Method to create a cursor object.
    /// </summary>
    internal GameObject CreateCursor()
    {
        GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        newCursor.SetActive(false);
        // Remove the collider, so it does not block Raycast.
        Destroy(newCursor.GetComponent<SphereCollider>());
        newCursor.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
        Material mat = new Material(Shader.Find("Diffuse"));
        newCursor.GetComponent<MeshRenderer>().material = mat;
        mat.color = Color.HSVToRGB(0.0223f, 0.7922f, 1.000f);
        newCursor.SetActive(true);

        return newCursor;
    }

  8. Zaimplementuj metody, które skonfigurują raycast z kamery głównej i będą śledzić bieżący obiekt skoncentrowany.

        /// <summary>
    /// Called every frame
    /// </summary>
    internal virtual void Update()
    {
        _gazeOrigin = Camera.main.transform.position;

        _gazeDirection = Camera.main.transform.forward;

        UpdateRaycast();
    }


    /// <summary>
    /// Reset the old focused object, stop the gaze timer, and send data if it
    /// is greater than one.
    /// </summary>
    private void ResetFocusedObject()
    {
        // Ensure the old focused object is not null.
        if (_oldFocusedObject != null)
        {
            if (_oldFocusedObject.CompareTag(InteractibleTag))
            {
                // Provide the OnGazeExited event.
                _oldFocusedObject.SendMessage("OnGazeExited", 
                    SendMessageOptions.DontRequireReceiver);
            }
        }
    }


    private void UpdateRaycast()
    {
        // Set the old focused gameobject.
        _oldFocusedObject = FocusedObject;
        RaycastHit hitInfo;

        // Initialize Raycasting.
        Hit = Physics.Raycast(_gazeOrigin,
            _gazeDirection,
            out hitInfo,
            GazeMaxDistance);
        HitInfo = hitInfo;

        // Check whether raycast has hit.
        if (Hit == true)
        {
            Position = hitInfo.point;
            Normal = hitInfo.normal;

            // Check whether the hit has a collider.
            if (hitInfo.collider != null)
            {
                // Set the focused object with what the user just looked at.
                FocusedObject = hitInfo.collider.gameObject;
            }
            else
            {
                // Object looked on is not valid, set focused gameobject to null.
                FocusedObject = null;
            }
        }
        else
        {
            // No object looked upon, set focused gameobject to null.
            FocusedObject = null;

            // Provide default position for cursor.
            Position = _gazeOrigin + (_gazeDirection * GazeMaxDistance);

            // Provide a default normal.
            Normal = _gazeDirection;
        }

        // Lerp the cursor to the given position, which helps to stabilize the gaze.
        Cursor.transform.position = Vector3.Lerp(Cursor.transform.position, Position, 0.6f);

        // Check whether the previous focused object is this same. If so, reset the focused object.
        if (FocusedObject != _oldFocusedObject)
        {
            ResetFocusedObject();
            if (FocusedObject != null)
            {
                if (FocusedObject.CompareTag(InteractibleTag))
                {
                    // Provide the OnGazeEntered event.
                    FocusedObject.SendMessage("OnGazeEntered",
                        SendMessageOptions.DontRequireReceiver);
                }
            }
        }
    }

  9. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

Rozdział 10 — tworzenie klasy Bot

Skrypt, który teraz utworzysz, nosi nazwę Bot. Jest to podstawowa klasa aplikacji, która przechowuje:

  • Poświadczenia bota aplikacji internetowej
  • Metoda, która zbiera polecenia głosowe użytkownika
  • Metoda niezbędna do inicjowania konwersacji z botem aplikacji internetowej
  • Metoda niezbędna do wysyłania komunikatów do bota aplikacji internetowej

Aby wysyłać komunikaty do usługi Bot Service, coroutine SendMessageToBot() utworzy działanie, które jest obiektem rozpoznawanym przez platformę Bot Framework jako danymi wysyłanymi przez użytkownika.

Aby utworzyć tę klasę:

  1. Kliknij dwukrotnie folder Skrypty, aby go otworzyć.

  2. Kliknij prawym przyciskiem myszy wewnątrz folderu Scripts (Skrypty ), kliknij polecenie Create C# Script (Utwórz > skrypt języka C#). Nazwij bota skryptu.

  3. Kliknij dwukrotnie nowy skrypt, aby otworzyć go za pomocą programu Visual Studio.

  4. Zaktualizuj przestrzenie nazw tak samo jak w przypadku następujących elementów w górnej części klasy Bot :

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

  5. Wewnątrz klasy Bot dodaj następujące zmienne:

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

    Uwaga

    Upewnij się, że wstawisz klucz tajny bota do zmiennej botSecret. Klucz tajny bota został zanotowany na początku tego kursu, w rozdziale 2, krok 10.

  6. Teraz należy dodać kod dla aplikacji Awake() i Start().

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

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

  7. Dodaj dwa programy obsługi, które są wywoływane przez biblioteki mowy po rozpoczęciu i zakończeniu przechwytywania głosu. Element DictationRecognizer automatycznie przestanie przechwytywać głos użytkownika, gdy użytkownik przestanie mówić.

        /// <summary>
    /// Start microphone capture.
    /// </summary>
    public void StartCapturingAudio()
    {
        botState = BotState.Listening;
        botMaterial.color = Color.red;

        // Start dictation
        dictationRecognizer = new DictationRecognizer();
        dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;
        dictationRecognizer.Start();
    }


    /// <summary>
    /// Stop microphone capture.
    /// </summary>
    public void StopCapturingAudio()
    {
        botState = BotState.Processing;
        dictationRecognizer.Stop();
    }

  8. Poniższa procedura obsługi zbiera wynik danych wejściowych głosowych użytkownika i wywołuje współpracę odpowiedzialną za wysyłanie komunikatu do usługi Bot Service aplikacji internetowej.

        /// <summary>
    /// This handler is called every time the Dictation detects a pause in the speech. 
    /// </summary>
    private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
    {
        // Update UI with dictation captured
        Debug.Log($"User just said: {text}");      

        // Send dictation to Bot
        StartCoroutine(SendMessageToBot(text, botId, botName, "message"));
        StopCapturingAudio();
    }

  9. Aby rozpocząć konwersację z botem, wywoływana jest następująca coroutine. Po zakończeniu rozmowy wywołanie konwersacji wywoła metodę SendMessageToCoroutine() przez przekazanie serii parametrów, które ustawią działanie do wysłania do usługi Bot Service jako pustą wiadomość. Jest to wykonywane w celu monitowania usługi Bot Service o zainicjowanie okna dialogowego.

        /// <summary>
    /// Request a conversation with the Bot Service
    /// </summary>
    internal IEnumerator StartConversation()
    {
        string conversationEndpoint = string.Format("{0}/conversations", botEndpoint);

        WWWForm webForm = new WWWForm();

        using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(conversationEndpoint, webForm))
        {
            unityWebRequest.SetRequestHeader("Authorization", "Bearer " + botSecret);
            unityWebRequest.downloadHandler = new DownloadHandlerBuffer();

            yield return unityWebRequest.SendWebRequest();
            string jsonResponse = unityWebRequest.downloadHandler.text;

            conversation = new ConversationObject();
            conversation = JsonConvert.DeserializeObject<ConversationObject>(jsonResponse);
            Debug.Log($"Start Conversation - Id: {conversation.ConversationId}");
            conversationStarted = true; 
        }

        // The following call is necessary to create and inject an activity of type //"conversationUpdate" to request a first "introduction" from the Bot Service.
        StartCoroutine(SendMessageToBot("", botId, botName, "conversationUpdate"));
    }

  10. Następująca kohroutyna jest wywoływana w celu utworzenia działania, które ma zostać wysłane do usługi Bot Service.

        /// <summary>
    /// Send the user message to the Bot Service in form of activity
    /// and call for a response
    /// </summary>
    private IEnumerator SendMessageToBot(string message, string fromId, string fromName, string activityType)
    {
        Debug.Log($"SendMessageCoroutine: {conversation.ConversationId}, message: {message} from Id: {fromId} from name: {fromName}");

        // Create a new activity here
        Activity activity = new Activity();
        activity.from = new From();
        activity.conversation = new Conversation();
        activity.from.id = fromId;
        activity.from.name = fromName;
        activity.text = message;
        activity.type = activityType;
        activity.channelId = "DirectLineChannelId";
        activity.conversation.id = conversation.ConversationId;     

        // Serialize the activity
        string json = JsonConvert.SerializeObject(activity);

        string sendActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);

        // Send the activity to the Bot
        using (UnityWebRequest www = new UnityWebRequest(sendActivityEndpoint, "POST"))
        {
            www.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));

            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Authorization", "Bearer " + botSecret);
            www.SetRequestHeader("Content-Type", "application/json");

            yield return www.SendWebRequest();

            // extrapolate the response Id used to keep track of the conversation
            string jsonResponse = www.downloadHandler.text;
            string cleanedJsonResponse = jsonResponse.Replace("\r\n", string.Empty);
            string responseConvId = cleanedJsonResponse.Substring(10, 30);

            // Request a response from the Bot Service
            StartCoroutine(GetResponseFromBot(activity));
        }
    }

  11. Następująca kohroutyna jest wywoływana w celu żądania odpowiedzi po wysłaniu działania do usługi Bot Service.

        /// <summary>
    /// Request a response from the Bot by using a previously sent activity
    /// </summary>
    private IEnumerator GetResponseFromBot(Activity activity)
    {
        string getActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);

        using (UnityWebRequest unityWebRequest1 = UnityWebRequest.Get(getActivityEndpoint))
        {
            unityWebRequest1.downloadHandler = new DownloadHandlerBuffer();
            unityWebRequest1.SetRequestHeader("Authorization", "Bearer " + botSecret);

            yield return unityWebRequest1.SendWebRequest();

            string jsonResponse = unityWebRequest1.downloadHandler.text;

            ActivitiesRootObject root = new ActivitiesRootObject();
            root = JsonConvert.DeserializeObject<ActivitiesRootObject>(jsonResponse);

            foreach (var act in root.activities)
            {
                Debug.Log($"Bot Response: {act.text}");
                SetBotResponseText(act.text);
            }

            botState = BotState.ReadyToListen;
            botMaterial.color = Color.blue;
        }
    }

  12. Ostatnia metoda, która ma zostać dodana do tej klasy, jest wymagana do wyświetlenia komunikatu w scenie:

        /// <summary>
    /// Set the UI Response Text of the bot
    /// </summary>
    internal void SetBotResponseText(string responseString)
    {        
        SceneOrganiser.Instance.botResponseText.text =  responseString;
    }

    Uwaga

    W konsoli edytora aparatu Unity może zostać wyświetlony błąd dotyczący braku klasy SceneOrganiser . Zignoruj ten komunikat, ponieważ utworzysz tę klasę w dalszej części samouczka.

  13. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

Rozdział 11 — Tworzenie klasy Interakcje

Klasa, którą teraz utworzysz, nosi nazwę Interakcje. Ta klasa służy do wykrywania danych wejściowych naciśnięcia urządzenia HoloLens od użytkownika.

Jeśli użytkownik naciągnie obiekt Bot w scenie, a bot będzie gotowy do nasłuchiwania danych głosowych, obiekt Bot zmieni kolor na czerwony i rozpocznie nasłuchiwanie danych głosowych.

Ta klasa dziedziczy z klasy GazeInput i dlatego może odwoływać się do metody Start() i zmiennych z tej klasy, co oznacza użycie bazy.

Aby utworzyć tę klasę:

  1. Kliknij dwukrotnie folder Skrypty, aby go otworzyć.

  2. Kliknij prawym przyciskiem myszy wewnątrz folderu Scripts (Skrypty ), kliknij polecenie Create C# Script (Utwórz > skrypt języka C#). Nadaj skryptowi nazwę Interakcje.

  3. Kliknij dwukrotnie nowy skrypt, aby otworzyć go za pomocą programu Visual Studio.

  4. Zaktualizuj przestrzenie nazw i dziedziczenie klas tak samo jak w przypadku następujących elementów w górnej części klasy Interactions :

    using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{

  5. Wewnątrz klasy Interactions dodaj następującą zmienną:

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

  6. Następnie dodaj metodę Start():

        /// <summary>
    /// Called on initialization, after Awake
    /// </summary>
    internal override void Start()
    {
        base.Start();

        //Register the application to recognize HoloLens user inputs
        _gestureRecognizer = new GestureRecognizer();
        _gestureRecognizer.SetRecognizableGestures(GestureSettings.Tap);
        _gestureRecognizer.Tapped += GestureRecognizer_Tapped;
        _gestureRecognizer.StartCapturingGestures();
    }

  7. Dodaj procedurę obsługi, która zostanie wyzwolona, gdy użytkownik wykonuje gest naciśnięcia przed aparatem HoloLens

        /// <summary>
    /// Detects the User Tap Input
    /// </summary>
    private void GestureRecognizer_Tapped(TappedEventArgs obj)
    {
        // Ensure the bot is being gazed upon.
        if(base.FocusedObject != null)
        {
            // If the user is tapping on Bot and the Bot is ready to listen
            if (base.FocusedObject.name == "Bot" && Bot.Instance.botState == Bot.BotState.ReadyToListen)
            {
                // If a conversation has not started yet, request one
                if(Bot.Instance.conversationStarted)
                {
                    Bot.Instance.SetBotResponseText("Listening...");
                    Bot.Instance.StartCapturingAudio();
                }
                else
                {
                    Bot.Instance.SetBotResponseText("Requesting Conversation...");
                    StartCoroutine(Bot.Instance.StartConversation());
                }                                  
            }
        }
    }

  8. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

Rozdział 12 — Tworzenie klasy SceneOrganiser

Ostatnia klasa wymagana w tym laboratorium nosi nazwę SceneOrganiser. Ta klasa skonfiguruje scenę programowo, dodając składniki i skrypty do aparatu głównego oraz tworząc odpowiednie obiekty w scenie.

Aby utworzyć tę klasę:

  1. Kliknij dwukrotnie folder Skrypty, aby go otworzyć.

  2. Kliknij prawym przyciskiem myszy wewnątrz folderu Scripts (Skrypty ), kliknij polecenie Create C# Script (Utwórz > skrypt języka C#). Nadaj skryptowi nazwę SceneOrganiser.

  3. Kliknij dwukrotnie nowy skrypt, aby otworzyć go za pomocą programu Visual Studio.

  4. Wewnątrz klasy SceneOrganiser dodaj następujące zmienne:

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

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

  5. Następnie dodaj metody Awake() i Start():

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

    /// <summary>
    /// Called immediately after Awake method
    /// </summary>
    void Start ()
    {
        // Add the GazeInput class to this object
        gameObject.AddComponent<GazeInput>();

        // Add the Interactions class to this object
        gameObject.AddComponent<Interactions>();

        // Create the Bot in the scene
        CreateBotInScene();
    }

  6. Dodaj następującą metodę, odpowiedzialną za utworzenie obiektu Bot w scenie i skonfigurowanie parametrów i składników:

        /// <summary>
    /// Create the Sign In button object in the scene
    /// and sets its properties
    /// </summary>
    private void CreateBotInScene()
    {
        GameObject botObjInScene = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        botObjInScene.name = "Bot";

        // Add the Bot class to the Bot GameObject
        botObjInScene.AddComponent<Bot>();

        // Create the Bot UI
        botResponseText = CreateBotResponseText();

        // Set properties of Bot GameObject
        Bot.Instance.botMaterial = new Material(Shader.Find("Diffuse"));
        botObjInScene.GetComponent<Renderer>().material = Bot.Instance.botMaterial;
        Bot.Instance.botMaterial.color = Color.blue;
        botObjInScene.transform.position = new Vector3(0f, 2f, 10f);
        botObjInScene.tag = "BotTag";
    }

  7. Dodaj następującą metodę odpowiedzialną za utworzenie obiektu interfejsu użytkownika w scenie reprezentującą odpowiedzi bota:

        /// <summary>
    /// Spawns cursor for the Main Camera
    /// </summary>
    private TextMesh CreateBotResponseText()
    {
        // Create a sphere as new cursor
        GameObject textObject = new GameObject();
        textObject.transform.parent = Bot.Instance.transform;
        textObject.transform.localPosition = new Vector3(0,1,0);

        // Resize the new cursor
        textObject.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);

        // Creating the text of the Label
        TextMesh textMesh = textObject.AddComponent<TextMesh>();
        textMesh.anchor = TextAnchor.MiddleCenter;
        textMesh.alignment = TextAlignment.Center;
        textMesh.fontSize = 50;
        textMesh.text = "Hi there, tap on me and I will start listening.";

        return textMesh;
    }

  8. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

  9. W edytorze aparatu Unity przeciągnij skrypt SceneOrganiser z folderu Scripts do głównego aparatu. Składnik Organizator sceny powinien teraz pojawić się w obiekcie Main Camera, jak pokazano na poniższej ilustracji.

    Zrzut ekranu przedstawiający skrypt organizatora sceny dodawany do obiektu Main Camera w Edytorze aparatu Unity.

Rozdział 13 – Przed budynkiem

Aby przeprowadzić dokładny test aplikacji, należy załadować ją bezpośrednio na urządzenie HoloLens. Przed wykonaniem upewnij się, że:

  • Wszystkie ustawienia wymienione w rozdziale 4 są ustawione poprawnie.
  • Skrypt SceneOrganiser jest dołączony do obiektu Main Camera .
  • W klasie Bot upewnij się, że klucz tajny bota został wstawiony do zmiennej botSecret.

Rozdział 14 — Kompilowanie i ładowanie bezpośrednie do urządzenia HoloLens

Wszystko, co jest potrzebne w sekcji aparatu Unity tego projektu, zostało ukończone, więc nadszedł czas, aby skompilować go z poziomu aparatu Unity.

  1. Przejdź do obszaru Ustawienia kompilacji, Ustawienia kompilacji pliku > ....

  2. W oknie Ustawienia kompilacji kliknij pozycję Kompiluj.

    Kompilowanie aplikacji z poziomu aparatu Unity

  3. Jeśli jeszcze tego nie zrobiono, zaznacz pole Unity C# Projects (Projekty języka C# aparatu Unity).

  4. Kliknij pozycję Kompiluj. Aparat Unity uruchomi okno Eksplorator plików, w którym należy utworzyć, a następnie wybierz folder do skompilowania aplikacji. Utwórz teraz ten folder i nadaj mu nazwę Aplikacja. Następnie po wybraniu folderu Aplikacja kliknij pozycję Wybierz folder.

  5. Aparat Unity rozpocznie kompilowanie projektu w folderze App .

  6. Po zakończeniu kompilowania środowiska Unity (może to zająć trochę czasu), zostanie otwarte okno Eksplorator plików w lokalizacji kompilacji (sprawdź pasek zadań, ponieważ może nie zawsze pojawiać się nad oknami, ale powiadomi o dodaniu nowego okna).

Rozdział 15 — Wdrażanie na urządzeniu HoloLens

Aby wdrożyć na urządzeniu HoloLens:

  1. Będziesz potrzebować adresu IP urządzenia HoloLens (na potrzeby zdalnego wdrażania) i upewnij się, że urządzenie HoloLens jest w trybie dewelopera. Czynność:

    1. Podczas noszenia urządzenia HoloLens otwórz ustawienia.
    2. Przejdź do pozycji Sieć i Internetowe > opcje zaawansowane sieci Wi-Fi >
    3. Zanotuj adres IPv4 .
    4. Następnie przejdź z powrotem do pozycji Ustawienia, a następnie przejdź do pozycji Aktualizuj i zabezpieczenia > dla deweloperów
    5. Ustaw tryb dewelopera wł.

  2. Przejdź do nowej kompilacji aparatu Unity ( folderu App ) i otwórz plik rozwiązania za pomocą programu Visual Studio.

  3. W obszarze Konfiguracja rozwiązania wybierz pozycję Debuguj.

  4. W polu Platforma rozwiązania wybierz pozycję x86, Maszyna zdalna.

    Wdróż rozwiązanie z poziomu programu Visual Studio.

  5. Przejdź do menu Kompilacja i kliknij pozycję Wdróż rozwiązanie, aby załadować aplikację bezpośrednio do urządzenia HoloLens.

  6. Aplikacja powinna być teraz wyświetlana na liście zainstalowanych aplikacji na urządzeniu HoloLens, gotowych do uruchomienia.

    Uwaga

    Aby wdrożyć w immersywnym zestawie słuchawkowym, ustaw wartość Platforma rozwiązania na Komputer lokalny i ustaw wartość Konfiguracja na Debugowanie z wartością x86 jako platforma. Następnie wdróż na komputerze lokalnym, korzystając z menu Kompilacja, wybierając pozycję Wdróż rozwiązanie.

Rozdział 16 — Używanie aplikacji na urządzeniu HoloLens

  • Po uruchomieniu aplikacji zobaczysz bota jako niebieską sferę.

  • Użyj gestu naciśnięcia, gdy patrzysz na sferę, aby zainicjować konwersację.

  • Poczekaj na rozpoczęcie konwersacji (interfejs użytkownika wyświetli komunikat w takim przypadku). Po otrzymaniu komunikatu wprowadzającego z bota naciśnij ponownie bota, aby zmienić kolor na czerwony i rozpocząć nasłuchiwanie głosu.

  • Po zakończeniu rozmowy aplikacja wyśle wiadomość do bota i natychmiast otrzymasz odpowiedź, która będzie wyświetlana w interfejsie użytkownika.

  • Powtórz ten proces, aby wysłać więcej komunikatów do bota (musisz nacisnąć za każdym razem, gdy chcesz użyć komunikatu).

Ta konwersacja pokazuje, jak bot może przechowywać informacje (twoje imię i nazwisko), a także dostarczać znane informacje (takie jak elementy, które są zaopatrzone).

Kilka pytań, które należy zadać botowi:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Zakończona aplikacja bota aplikacji internetowej (wersja 4)

Gratulacje, utworzono aplikację rzeczywistości mieszanej, która korzysta z bota aplikacji internetowej platformy Azure, platformy Microsoft Bot Framework w wersji 4.

Końcowy produkt

Ćwiczenia dodatkowe

Ćwiczenie 1

Struktura konwersacji w tym laboratorium jest bardzo podstawowa. Użyj usługi Microsoft LUIS, aby zapewnić możliwości interpretacji języka naturalnego bota.

Ćwiczenie 2

W tym przykładzie nie znaleziono zakończenia konwersacji i ponownego uruchomienia nowej konwersacji. Aby ukończyć funkcję bota, spróbuj zaimplementować zamknięcie konwersacji.