HoloLens (1ª geração) e Azure 312: integração de bot

Observação

Os tutoriais do Mixed Reality Academy foram projetados com o HoloLens (1ª geração) e os headsets imersivos de realidade misturada em mente. Dessa forma, achamos que é importante continuar disponibilizando esses tutoriais para os desenvolvedores que ainda buscam obter diretrizes para o desenvolvimento visando esses dispositivos. Esses tutoriais não serão atualizados com os conjuntos de ferramentas mais recentes nem com as interações usadas para o HoloLens 2. Eles serão mantidos para continuar funcionando nos dispositivos compatíveis. Haverá uma nova série de tutoriais que serão postados no futuro que demonstrarão como desenvolver para HoloLens 2. Este aviso será atualizado com um link para esses tutoriais quando eles forem postados.

Neste curso, você aprenderá a criar e implantar um bot usando o Microsoft Bot Framework V4 e se comunicar com ele por meio de um aplicativo Windows Mixed Reality.

Screenshot that shows communication through a Windows Mixed Reality application.

O Microsoft Bot Framework V4 é um conjunto de APIs projetado para fornecer aos desenvolvedores as ferramentas para criar um aplicativo de bot extensível e escalonável. Para obter mais informações, visite a página Microsoft Bot Framework ou o Repositório Git V4.

Depois de concluir este curso, você terá criado um aplicativo Windows Mixed Reality, que poderá fazer o seguinte:

  1. Use um Gesto de Toque para iniciar o bot escutando a voz dos usuários.
  2. Quando o usuário disse algo, o bot tentará fornecer uma resposta.
  3. Exiba a resposta dos bots como texto, posicionado perto do bot, na Cena do Unity.

Em seu aplicativo, cabe a você integrar os resultados ao seu design. Este curso foi projetado para ensinar como integrar um Serviço do Azure ao seu projeto do Unity. É seu trabalho usar o conhecimento obtido com este curso para aprimorar seu aplicativo de realidade misturada.

Suporte a dispositivos

Curso HoloLens Headsets imersivos
MR e Azure 312: integração de bots ✔️ ✔️

Observação

Embora este curso se concentre principalmente em HoloLens, você também pode aplicar o que aprender neste curso a Windows Mixed Reality headsets imersivos (VR). Como os headsets imersivos (VR) não têm câmeras acessíveis, você precisará de uma câmera externa conectada ao computador. Ao acompanhar o curso, você verá anotações sobre as alterações que talvez precise empregar para dar suporte a headsets imersivos (VR).

Pré-requisitos

Observação

Este tutorial foi projetado para desenvolvedores que têm experiência básica com Unity e C#. Lembre-se também de que os pré-requisitos e as instruções escritas neste documento representam o que foi testado e verificado no momento da gravação (julho de 2018). Você é livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas , embora não se supõe que as informações neste curso correspondam perfeitamente ao que você encontrará no software mais recente do que o listado abaixo.

Recomendamos o seguinte hardware e software para este curso:

Antes de começar

  1. Para evitar problemas ao criar esse projeto, é altamente sugerido que você crie o projeto mencionado neste tutorial em uma pasta raiz ou quase raiz (caminhos de pastas longas podem causar problemas no tempo de build).
  2. Configure e teste sua HoloLens. Se você precisar de suporte para configurar seu HoloLens, visite o artigo de instalação do HoloLens.
  3. É uma boa ideia executar o Ajuste de Calibração e Sensor ao começar a desenvolver um novo aplicativo HoloLens (às vezes, pode ajudar a executar essas tarefas para cada usuário).

Para obter ajuda sobre Calibração, siga este link para o artigo HoloLens Calibration.

Para obter ajuda sobre o Ajuste do Sensor, siga este link para o artigo HoloLens Ajuste do Sensor.

Capítulo 1 – Criar o aplicativo bot

A primeira etapa é criar seu bot como um aplicativo Web ASP.Net Core local. Depois de terminar e testá-lo, você o publicará no Portal do Azure.

  1. Abra o Visual Studio. Crie um novo projeto, selecione o aplicativo Web ASP NET Core como o tipo de projeto (você o encontrará no .NET Core de subseção) e chame-o de MyBot. Clique em OK.

  2. Na Janela que será exibida, selecione Vazio. Verifique também se o destino está definido como ASP NET Core 2.0 e se a Autenticação está definida como Nenhuma Autenticação. Clique em OK.

    Screenshot that shows the New A S P dot N E T Core Web Application window.

  3. A solução será aberta agora. Clique com o botão direito do mouse no Mybot da Solução no Gerenciador de Soluções e clique em Gerenciar pacotes de NuGet para solução.

    Screenshot that shows the opened solution with 'MyBot' and 'Manage NuGet Packages for Solution' highlighted.

  4. Na guia Procurar , pesquise por Microsoft.Bot.Builder.Integration.AspNet.Core (verifique se você tem a pré-versão inclusa marcada). Selecione o pacote versão 4.0.1-preview e marque as caixas de projeto. Em seguida, clique em Instalar. Agora você instalou as bibliotecas necessárias para o Bot Framework v4. Feche a página NuGet.

    Screenshot that shows the Nu-Get Solution manager.

  5. Clique com o botão direito do mouse em seu Project, MyBot, no Gerenciador de Soluções e clique em Adicionar|Classe.

    Screenshot that shows the process to add a new class to MyBot.

  6. Nomeie a classe MyBot e clique em Adicionar.

    Screenshot that shows the new class creation 'MyBot'.

  7. Repita o ponto anterior para criar outra classe chamada ConversationContext.

  8. Clique com o botão direito do mouse em wwwroot no Gerenciador de Soluções e clique em Adicionar|Novo Item. Selecione a página HTML (você a encontrará na Web de subseção). Nomeie o arquivo default.html. Clique em Adicionar.

    Screenshot that shows the creation of a new H T M L page from within the Solution Explorer window.

  9. A lista de classes/objetos no Gerenciador de Soluções deve ser semelhante à imagem abaixo.

    Screenshot of the Solution Explorer window with list of classes.

  10. Clique duas vezes na classe ConversationContext . Essa classe é responsável por manter as variáveis usadas pelo bot para manter o contexto da conversa. Esses valores de contexto de conversa são mantidos em uma instância dessa classe, pois qualquer instância da classe MyBot será atualizada sempre que uma atividade for recebida. Adicione o seguinte código à classe:

    namespace MyBot
    {
        public static class ConversationContext
        {
            internal static string userName;
    
            internal static string userMsg;
        }
    }
    
  11. Clique duas vezes na classe MyBot . Essa classe hospedará os manipuladores chamados por qualquer atividade de entrada do cliente. Nesta classe, você adicionará o código usado para criar a conversa entre o bot e o cliente. Conforme mencionado anteriormente, uma instância dessa classe é inicializada sempre que uma atividade é recebida. Adicione o seguinte código a esta classe:

    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. Clique duas vezes na classe Inicialização . Essa classe inicializará o bot. Adicione o seguinte código à classe:

    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. Abra o arquivo de classe Program e verifique se o código nele é o mesmo que o seguinte:

    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. Lembre-se de salvar suas alterações, para fazer isso, vá para Salvar>Todos, na barra de ferramentas na parte superior do Visual Studio.

Capítulo 2 – Criar o Serviço de Bot do Azure

Agora que você criou o código para o bot, é necessário publicá-lo em uma instância do Serviço de Bot de Aplicativo Web , no Portal do Azure. Este Capítulo mostrará como criar e configurar o Serviço de Bot no Azure e publicar seu código nele.

  1. Primeiro, faça logon no Portal do Azure (https://portal.azure.com).

    1. Se você ainda não tiver uma conta do Azure, precisará criar uma. Se você estiver seguindo este tutorial em uma situação de sala de aula ou laboratório, peça ajuda ao instrutor ou a um dos supervisores para configurar sua nova conta.
  2. Depois de fazer logon, clique em Criar um recurso no canto superior esquerdo, pesquise o bot do Aplicativo Web e clique em Enter.

    Screenshot of the Microsoft Azure dashboard with 'Create a resource' highlighted in the upper left.

  3. A nova página fornecerá uma descrição do Serviço de Bot de Aplicativo Web . Na parte inferior esquerda desta página, selecione o botão Criar para criar uma associação com este Serviço.

    Screenshot of the Web App Bot page and the 'Create' button in the bottom left.

  4. Depois de clicar em Criar:

    1. Insira o nome desejado para esta instância de Serviço.

    2. Selecione uma Assinatura.

    3. Escolha um Grupo de Recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os Serviços do Azure associados a um único projeto (por exemplo, como esses cursos) em um grupo de recursos comum).

      Se você quiser ler mais sobre os Grupos de Recursos do Azure, siga este link

    4. Determine a localização do grupo de recursos (se você estiver criando um novo Grupo de Recursos). O local seria idealmente na região em que o aplicativo seria executado. Alguns ativos do Azure só estão disponíveis em determinadas regiões.

    5. Selecione o Tipo de Preço apropriado para você, se esta for a primeira vez que criar um Serviço de Bot de Aplicativo Web , uma camada gratuita (chamada F0) deverá estar disponível para você

    6. O nome do aplicativo pode ser deixado da mesma forma que o nome do Bot.

    7. Deixe o modelo de Bot como Básico (C#).

    8. O plano do serviço de aplicativo/Local deveria ter sido preenchido automaticamente para sua conta.

    9. Defina o Armazenamento do Azure que você deseja usar para hospedar seu Bot. Se você ainda não tiver um, poderá criá-lo aqui.

    10. Você também precisará confirmar se entendeu os Termos e Condições aplicados a este Serviço.

    11. Clique em Criar.

      Screenshot that shows the required fields needed to create the new Service.

  5. Depois de clicar em Criar, você precisará aguardar a criação do Serviço, isso pode levar um minuto.

  6. Uma notificação será exibida no Portal depois que a instância de Serviço for criada.

    Screenshot that shows the notification icon highlighted after the Service instance is created.

  7. Clique na notificação para explorar sua nova instância de Serviço.

    Screenshot that shows deployment succeeded and the 'Go to resources' button.

  8. Clique no botão Ir para recurso na notificação para explorar sua nova instância de Serviço. Você será levado para sua nova instância do Serviço do Azure.

    Screenshot of the Resources windows after clicking the 'Go to resources' button in the previous window.

  9. Neste ponto, você precisa configurar um recurso chamado Direct Line para permitir que seu aplicativo cliente se comunique com esse Serviço de Bot. Clique em Canais e, na seção Adicionar um canal em destaque, clique em Configurar Direct Line canal.

    Screenshot that shows the Configure Direct Line channel highlighted in MyHoloLensBot.

  10. Nesta página, você encontrará as chaves secretas que permitirão que seu aplicativo cliente se autentique com o bot. Clique no botão Mostrar e tire uma cópia de uma das Chaves exibidas, pois você precisará disso mais tarde em seu projeto.

    Screenshot of the secret keys highlighted in MyHoloLensBot Configure Direct Line channel.

Capítulo 3 – Publicar o Bot no aplicativo Web do Azure Serviço de Bot

Agora que seu Serviço está pronto, você precisa publicar seu código de Bot, que você criou anteriormente, em seu aplicativo Web recém-criado Serviço de Bot.

Observação

Você precisará publicar seu Bot no Serviço do Azure sempre que fizer alterações na solução/código do Bot.

  1. Voltar para sua Solução de Visual Studio que você criou anteriormente.

  2. Clique com o botão direito do mouse no projeto MyBot, no Gerenciador de Soluções e clique em Publicar.

    Screenshot that shows the 'MyBot' project drop down menu after a right-click.

  3. Na página Escolher um destino de publicação, clique em Serviço de Aplicativo, selecione Existente, clique por último em Criar Perfil (talvez seja necessário clicar na seta suspensa ao lado do botão Publicar, se isso não estiver visível).

    Screenshot that shows the Pick a publish target page with 'App Service', 'Select Existing', and 'Create Profile' highlighted.

  4. Se você ainda não estiver conectado à sua conta da Microsoft, precisará fazer isso aqui.

  5. Na página Publicar , você verá que precisa definir a mesma assinatura usada para a criação do Serviço de Bot de Aplicativo Web . Em seguida, defina o Modo de Exibição como Grupo de Recursos e, na estrutura de pasta suspensa, selecione o Grupo de Recursos criado anteriormente. Clique em OK.

    Screenshot that shows the App Service window with the same Subscription used for the Web App Bot Service creation selected.

  6. Agora clique no botão Publicar e aguarde a publicação do Bot (pode levar alguns minutos).

    Screenshot that shows the Publish window with Publish button.

Capítulo 4 – Configurar o projeto do Unity

A seguir está uma configuração típica para desenvolver com realidade misturada e, como tal, é um bom modelo para outros projetos.

  1. Abra o Unity e clique em Novo.

    Screenshot that shows the Unity Projects window with the 'New' project icon highlighted in the upper right.

  2. Agora você precisará fornecer um nome de projeto do Unity. Insira HoloLens Bot. Verifique se o modelo de projeto está definido como 3D. Defina o Local como um lugar apropriado para você (lembre-se de que mais perto dos diretórios raiz é melhor). Em seguida, clique em Criar projeto.

    Screenshot that shows the new Unity Project name field highlighted.

  3. Com o Unity aberto, vale a pena verificar se o Editor de Script padrão está definido como Visual Studio. Vá para Editar > Preferências e, em seguida, na nova janela, navegue até Ferramentas Externas. Altere o Editor de Script Externo para Visual Studio 2017. Feche a janela Preferências .

    Screenshot that shows the Unity Preferences window with the required settings.

  4. Em seguida, vá para a Configurações de Compilação de Arquivos > e selecione Plataforma Universal do Windows e clique no botão Alternar Plataforma para aplicar sua seleção.

    Screenshot that shows the Build Settings window with the 'Switch Platform' button highlighted.

  5. Ainda no > Configurações de build de arquivo e verifique se:

    1. O dispositivo de destino está definido como HoloLens

      Para os headsets imersivos, defina o dispositivo de destino como qualquer dispositivo.

    2. O tipo de build está definido como D3D

    3. O SDK está definido como o mais recente instalado

    4. Visual Studio Versão está definida como Mais Recente instalada

    5. Compilar e Executar é definido como Computador Local

    6. Salve a cena e adicione-a ao build.

      1. Faça isso selecionando Adicionar Cenas Abertas. Uma janela de salvamento será exibida.

        Screenshot that shows the Build Settings window with the 'Add Open Scenes' button highlighted.

      2. Crie uma nova pasta para essa cena e, em qualquer futuro, selecione o botão Nova pasta , para criar uma nova pasta, nomeie-a cenas.

        Screenshot that shows the creation of a new 'Scenes' folder.

      3. Abra a pasta Cenas recém-criada e, em seguida, no nome do arquivo: campo de texto, digite BotScene e clique em Salvar.

        Screenshot of the Scenes folder and the newly created file being saved.

    7. As configurações restantes, no build Configurações, devem ser deixadas como padrão por enquanto.

  6. Na janela Criar Configurações, clique no botão Player Configurações, isso abrirá o painel relacionado no espaço onde o Inspetor está localizado.

    Screenshot that shows the Build Settings window in the Inspector tab.

  7. Neste painel, algumas configurações precisam ser verificadas:

    1. Na guia Outros Configurações:

      1. A versão de runtime de script deve ser experimental (equivalente ao NET 4.6); alterar isso exigirá uma reinicialização do Editor.

      2. O back-end de script deve ser .NET

      3. O nível de compatibilidade da API deve ser .NET 4.6

        Screenshot that shows the Other Settings tab with the required settings.

    2. Na guia Publicar Configurações, em Recursos, verifique:

      • InternetClient

      • Microfone

        Screenshot that shows 'InternetClient' and 'Microphone' enabled in the Publishing Settings tab.

    3. Mais adiante no painel, no Configurações XR (encontrado abaixo de Publicar Configurações), marque a Realidade Virtual com Suporte, verifique se o SDK do Windows Mixed Reality foi adicionado.

      Screenshot that shows Virtual Reality Supported enabled and Windows Mixed Reality S D K added.

  8. De volta ao Build ConfiguraçõesUnity C# Projects não está mais esmaeçado; marque a caixa de seleção ao lado disso.

  9. Feche a janela Configurações de Build.

  10. Salve a cena e o projeto (FILE > SAVE SCENE/FILE > SAVE PROJECT).

Capítulo 5 – configuração de Câmera

Importante

Se você quiser ignorar o componente de Configuração do Unity deste curso e continuar diretamente no código, fique à vontade para baixar este pacote Azure-MR-312-Package.unitypackage, importá-lo para o projeto como um Pacote Personalizado e, em seguida, continuar a partir do Capítulo 7.

  1. No painel Hierarquia, selecione a Câmera Principal.

  2. Depois de selecionado, você poderá ver todos os componentes da Câmera Principal no painel Inspetor.

    1. O objeto Câmera deve ser chamado de Main Câmera (observe a ortografia)
    2. A Marca de Câmera Principal deve ser definida como MainCamera (observe a ortografia)
    3. Verifique se a Posição de Transformação está definida como 0, 0, 0
    4. Defina Sinalizadores Desmarcados como Cor Sólida.
    5. Defina a cor da tela de fundo do componente Câmera como Preto, Alfa 0 (Código Hex: #00000000)

    Screenshot that shows all the components of the Main Camera in the Inspector panel.

Capítulo 6 – Importar a biblioteca Newtonsoft

Para ajudá-lo a desserializar e serializar objetos recebidos e enviados para o Serviço de Bot você precisa baixar a biblioteca Newtonsoft. Você encontrará uma versão compatível já organizada com a estrutura de pastas correta do Unity aqui.

Para importar a biblioteca Newtonsoft para seu projeto, use o Pacote do Unity que veio com este curso.

  1. Adicione o .unitypackage ao Unity usando a opção de menu PacotePersonalizadode Importação> de Ativos>.

    Screenshot that shows the Assets drop down menu with 'Import Package' then 'Custom Package' selected.

  2. Na caixa Importar Pacote do Unity que aparece, verifique se tudo em (e incluindo) Plug-ins está selecionado.

    Screenshot of the Import Unity Package popup box with'Plugins' selected.

  3. Clique no botão Importar para adicionar os itens ao projeto.

  4. Vá para a pasta Newtonsoft em Plug-ins na exibição do projeto e selecione o plug-in Newtonsoft.

    Screenshot that shows the Newtonsoft folder in the project view.

  5. Com o plug-in Newtonsoft selecionado, verifique se Qualquer Plataforma está desmarcada e verifique se o WSAPlayer também está desmarcado e clique em Aplicar. Isso é apenas para confirmar se os arquivos estão configurados corretamente.

    Screenshot that shows the correct selections for the Newtonsoft plugin.

    Observação

    Marcar esses plug-ins os configura para serem usados apenas no Editor do Unity. Há um conjunto diferente deles na pasta WSA que será usado depois que o projeto for exportado do Unity.

  6. Em seguida, você precisa abrir a pasta WSA , dentro da pasta Newtonsoft . Você verá uma cópia do mesmo arquivo que acabou de configurar. Selecione o arquivo e, em seguida, no inspetor, verifique se

    • Qualquer plataforma está desmarcada
    • somenteO WSAPlayer está marcado
    • O processo Dont está marcado

    Screenshot that shows the correct selections for the Newtonsoft plugin in the WSA folder.

Capítulo 7 – Criar o BotTag

  1. Crie um novo objeto Tag chamado BotTag. Selecione a Câmera Principal na cena. Clique no menu suspenso Marca no painel Inspetor. Clique em Adicionar Marca.

    Screenshot of the Main Camera Tag drop down menu in the Inspector panel with 'Add Tag' highlighted.

  2. Clique no + símbolo. Nomeie a nova marca como BotTag, Salvar.

    Screenshot of the Inspector panel with the new BotTag name, plus symbol, and Save button.

Aviso

Não aplique o BotTag à Câmera Principal. Se você tiver feito isso acidentalmente, altere a marca main Câmera de volta para MainCamera.

Capítulo 8 – Criar a classe BotObjects

O primeiro script que você precisa criar é a classe BotObjects , que é uma classe vazia criada para que uma série de outros objetos de classe possam ser armazenados no mesmo script e acessados por outros scripts na cena.

A criação dessa classe é puramente uma escolha arquitetônica, em vez disso, esses objetos podem ser hospedados no script bot que você criará posteriormente neste curso.

Para criar essa classe:

  1. Clique com o botão direito do mouse no painel Project e, em seguida, crie > pasta. Nomeie a pasta Scripts.

    Create scripts folder.

  2. Clique duas vezes na pasta Scripts para abri-la. Em seguida, dentro dessa pasta, clique com o botão direito do mouse e selecione Criar > Script C#. Nomeie o script BotObjects.

  3. Clique duas vezes no novo script BotObjects para abri-lo com Visual Studio.

  4. Exclua o conteúdo do script e substitua-o pelo seguinte código:

    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. Salve suas alterações no Visual Studio antes de retornar ao Unity.

Capítulo 9 – Criar a classe GazeInput

A próxima classe que você vai criar é a classe GazeInput . Essa classe é responsável por:

  • Criar um cursor que representará o olhar do jogador.
  • Detectando objetos atingidos pelo olhar do player e mantendo uma referência a objetos detectados.

Para criar essa classe:

  1. Vá para a pasta Scripts que você criou anteriormente.

  2. Clique com o botão direito do mouse dentro da pasta, Criar > Script C#. Chame o script GazeInput.

  3. Clique duas vezes no novo script GazeInput para abri-lo com Visual Studio.

  4. Insira a seguinte linha diretamente na parte superior do nome da classe:

    /// <summary>
    /// Class responsible for the User's gaze interactions
    /// </summary>
    [System.Serializable]
    public class GazeInput : MonoBehaviour
    
  5. Em seguida, adicione as seguintes variáveis dentro da classe GazeInput, acima do método 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. O código para o método Start() deve ser adicionado. Isso será chamado quando a classe inicializar:

        /// <summary>
        /// Start method used upon initialization.
        /// </summary>
        internal virtual void Start()
        {
            FocusedObject = null;
            Cursor = CreateCursor();
        }
    
  7. Implemente um método que criará uma instância e configurará o cursor de foco:

        /// <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. Implemente os métodos que configurarão o Raycast da Câmera Principal e acompanharão o objeto focado atual.

        /// <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. Salve suas alterações no Visual Studio antes de retornar ao Unity.

Capítulo 10 – Criar a classe Bot

O script que você vai criar agora se chama Bot. Essa é a classe principal do seu aplicativo, que armazena:

  • Suas credenciais do Bot do Aplicativo Web
  • O método que coleta os comandos de voz do usuário
  • O método necessário para iniciar conversas com seu Bot de Aplicativo Web
  • O método necessário para enviar mensagens para seu Bot de Aplicativo Web

Para enviar mensagens para o Serviço de Bot, a coroutina SendMessageToBot() criará uma atividade, que é um objeto reconhecido pelo Bot Framework como dados enviados pelo usuário.

Para criar essa classe:

  1. Clique duas vezes na pasta Scripts para abri-la.

  2. Clique com o botão direito do mouse dentro da pasta Scripts , clique em Criar > Script em C#. Nomeie o bot de script.

  3. Clique duas vezes no novo script para abri-lo com Visual Studio.

  4. Atualize os namespaces para serem iguais aos seguintes, na parte superior da classe Bot :

    using Newtonsoft.Json;
    using System.Collections;
    using System.Text;
    using UnityEngine;
    using UnityEngine.Networking;
    using UnityEngine.Windows.Speech;
    
  5. Dentro da classe Bot , adicione as seguintes variáveis:

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

    Observação

    Insira sua Chave Secreta do Bot na variável botSecret . Você terá anotado sua Chave Secreta do Bot no início deste curso, no Capítulo 2, etapa 10.

  6. O código para Awake() e Start() agora precisa ser adicionado.

        /// <summary>
        /// Called on Initialization
        /// </summary>
        void Awake()
        {
            Instance = this;
        }
    
        /// <summary>
        /// Called immediately after Awake method
        /// </summary>
        void Start()
        {
            botState = BotState.ReadyToListen;
        }
    
  7. Adicione os dois manipuladores que são chamados pelas bibliotecas de fala quando a captura de voz começar e terminar. O DictationRecognizer interromperá automaticamente a captura da voz do usuário quando o usuário parar de falar.

        /// <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. O manipulador a seguir coleta o resultado da entrada de voz do usuário e chama a coroutina responsável por enviar a mensagem para o aplicativo Web Serviço de Bot.

        /// <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. A coroutina a seguir é chamada para iniciar uma conversa com o Bot. Você observará que, depois que a chamada de conversa for concluída, ela chamará SendMessageToCoroutine() passando uma série de parâmetros que definirão a atividade a ser enviada para o Serviço de Bot como uma mensagem vazia. Isso é feito para solicitar que o Serviço de Bot inicie o diálogo.

        /// <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. A coroutina a seguir é chamada para compilar a atividade a ser enviada ao Serviço de Bot.

        /// <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. A coroutina a seguir é chamada para solicitar uma resposta depois de enviar uma atividade para o Serviço de Bot.

        /// <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. O último método a ser adicionado a essa classe é necessário para exibir a mensagem na cena:

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

    Observação

    Você pode ver um erro no Console do Editor do Unity sobre a falta da classe SceneOrganiser . Desconsidere essa mensagem, pois você criará essa classe mais adiante no tutorial.

  13. Salve suas alterações no Visual Studio antes de retornar ao Unity.

Capítulo 11 – Criar a classe De interações

A classe que você vai criar agora se chama Interações. Essa classe é usada para detectar o HoloLens Toque na Entrada do usuário.

Se o usuário tocar ao examinar o objeto Bot na cena e o Bot estiver pronto para escutar entradas de voz, o objeto Bot mudará de cor para vermelho e começará a escutar entradas de voz.

Essa classe herda da classe GazeInput e, portanto, é capaz de referenciar o método Start() e variáveis dessa classe, indicados pelo uso da base.

Para criar essa classe:

  1. Clique duas vezes na pasta Scripts para abri-la.

  2. Clique com o botão direito do mouse dentro da pasta Scripts , clique em Criar > Script em C#. Nomeie as interações de script.

  3. Clique duas vezes no novo script para abri-lo com Visual Studio.

  4. Atualize os namespaces e a herança de classe para serem iguais aos seguintes, na parte superior da classe Interações :

    using UnityEngine.XR.WSA.Input;
    
    public class Interactions : GazeInput
    {
    
  5. Dentro da classe Interações , adicione a seguinte variável:

        /// <summary>
        /// Allows input recognition with the HoloLens
        /// </summary>
        private GestureRecognizer _gestureRecognizer;
    
  6. Em seguida, adicione o método 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. Adicione o manipulador que será disparado quando o usuário executar o gesto de toque na frente da câmera de 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. Salve suas alterações no Visual Studio antes de retornar ao Unity.

Capítulo 12 – Criar a classe SceneOrganiser

A última classe necessária neste Laboratório é chamada SceneOrganiser. Essa classe configurará a cena programaticamente, adicionando componentes e scripts à Câmera Principal e criando os objetos apropriados na cena.

Para criar essa classe:

  1. Clique duas vezes na pasta Scripts para abri-la.

  2. Clique com o botão direito do mouse dentro da pasta Scripts , clique em Criar > Script em C#. Nomeie o script SceneOrganiser.

  3. Clique duas vezes no novo script para abri-lo com Visual Studio.

  4. Dentro da classe SceneOrganiser , adicione as seguintes variáveis:

        /// <summary>
        /// Static instance of this class
        /// </summary>
        public static SceneOrganiser Instance;
    
        /// <summary>
        /// The 3D text representing the Bot response
        /// </summary>
        internal TextMesh botResponseText;
    
  5. Em seguida, adicione os métodos Awake() e 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. Adicione o seguinte método, responsável por criar o objeto Bot na cena e configurar os parâmetros e componentes:

        /// <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. Adicione o seguinte método, responsável por criar o objeto de interface do usuário na cena, representando as respostas do Bot:

        /// <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. Salve suas alterações no Visual Studio antes de retornar ao Unity.

  9. No Editor do Unity, arraste o script SceneOrganiser da pasta Scripts para a Câmera Principal. O componente Organizador de Cena agora deve aparecer no objeto Main Câmera, conforme mostrado na imagem abaixo.

    Screenshot that shows the Scene Organiser script being added to the Main Camera object in the Unity Editor.

Capítulo 13 – Antes da construção

Para executar um teste completo do seu aplicativo, você precisará fazer sideload no HoloLens. Antes disso, verifique se:

  • Todas as configurações mencionadas no Capítulo 4 são definidas corretamente.
  • O script SceneOrganiser é anexado ao objeto Main Câmera.
  • Na classe Bot , verifique se você inseriu sua Chave Secreta do Bot na variável botSecret .

Capítulo 14 – Compilar e sideload para o HoloLens

Tudo o que é necessário para a seção unity deste projeto já foi concluído, portanto, é hora de compilá-lo do Unity.

  1. Navegue até criar Configurações, > Configurações de build de arquivo....

  2. Na janela Criar Configurações, clique em Compilar.

    Building the app from Unity

  3. Se ainda não estiver, marque Projetos C# do Unity.

  4. Clique em Compilar. O Unity iniciará uma janela Explorador de Arquivos, na qual você precisa criar e selecionar uma pasta para criar o aplicativo. Crie essa pasta agora e nomeie-a como Aplicativo. Em seguida, com a pasta Aplicativo selecionada, clique em Selecionar Pasta.

  5. O Unity começará a compilar seu projeto para a pasta Aplicativo .

  6. Depois que o Unity terminar de compilar (pode levar algum tempo), ele abrirá uma janela Explorador de Arquivos no local do build (verifique sua barra de tarefas, pois ela pode nem sempre aparecer acima das janelas, mas notificará você sobre a adição de uma nova janela).

Capítulo 15 – Implantar no HoloLens

Para implantar no HoloLens:

  1. Você precisará do endereço IP do seu HoloLens (para Implantação Remota) e garantir que seu HoloLens esteja no Modo de Desenvolvedor. Para fazer isso:

    1. Enquanto estiver usando sua HoloLens, abra a Configurações.
    2. Ir para Opções Avançadas de Wi-Fi > da Internet > de Rede &
    3. Observe o endereço IPv4 .
    4. Em seguida, navegue de volta para Configurações e, em seguida, para atualizar & a segurança > para desenvolvedores
    5. Definir modo de desenvolvedor ativado.
  2. Navegue até o novo build do Unity (a pasta Aplicativo) e abra o arquivo de solução com Visual Studio.

  3. Na Configuração da Solução , selecione Depurar.

  4. Na Plataforma de Solução, selecione x86, Máquina Remota.

    Deploy the solution from Visual Studio.

  5. Vá para o menu Compilar e clique em Implantar solução para carregar o aplicativo em seu HoloLens.

  6. Seu aplicativo agora deve aparecer na lista de aplicativos instalados em seu HoloLens, pronto para ser iniciado!

    Observação

    Para implantar em headset imersivo, defina a Plataforma de Solução como Computador Local e defina a Configuração como Depuração, com x86 como a Plataforma. Em seguida, implante no computador local, usando o menu Compilar, selecionando Implantar solução.

Capítulo 16 – Usando o aplicativo no HoloLens

  • Depois de iniciar o aplicativo, você verá o Bot como uma esfera azul na sua frente.

  • Use o Gesto de Toque enquanto você está olhando para a esfera para iniciar uma conversa.

  • Aguarde o início da conversa (a interface do usuário exibirá uma mensagem quando ela acontecer). Depois de receber a mensagem introdutória do Bot, toque novamente no Bot para que ele fique vermelho e comece a ouvir sua voz.

  • Depois que você parar de falar, seu aplicativo enviará sua mensagem para o Bot e você receberá prontamente uma resposta que será exibida na interface do usuário.

  • Repita o processo para enviar mais mensagens ao bot (você precisa tocar sempre que quiser detectar uma mensagem).

Esta conversa demonstra como o Bot pode reter informações (seu nome), ao mesmo tempo em que fornece informações conhecidas (como os itens que são abastecidos).

Algumas perguntas para fazer ao Bot:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Seu aplicativo do Bot de Aplicativo Web concluído (v4)

Parabéns, você criou um aplicativo de realidade misturada que aproveita o Bot de Aplicativo Web do Azure, Microsoft Bot Framework v4.

Final Product

Exercícios de bônus

Exercício 1

A estrutura de conversa neste Laboratório é muito básica. Use o Microsoft LUIS para fornecer aos seus recursos de compreensão da linguagem natural do bot.

Exercício 2

Este exemplo não inclui encerrar uma conversa e reiniciar uma nova. Para concluir o recurso bot, tente implementar o encerramento da conversa.