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

Artigo
07/12/2023

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.

Captura de tela que mostra a comunicação por meio de um aplicativo Windows Mixed Reality.

O Microsoft Bot Framework V4 é um conjunto de APIs projetadas 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:

Use um Gesto de Toque para iniciar o bot escutando a voz dos usuários.
Quando o usuário tiver dito algo, o bot tentará fornecer uma resposta.
Exiba os bots responderem como texto, posicionados perto do bot, na Cena do Unity.

Em seu aplicativo, cabe a você como 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 no HoloLens, você também pode aplicar o que aprender neste curso para 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ê está livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas , embora não se presuma que as informações neste curso corresponderão perfeitamente ao que você encontrará no software mais recente do que o listado abaixo.

Recomendamos o seguinte hardware e software para este curso:

Um computador de desenvolvimento, compatível com Windows Mixed Reality para desenvolvimento imersivo de headset (VR)
Windows 10 Fall Creators Update (ou posterior) com o modo desenvolvedor habilitado
O SDK do Windows 10 mais recente
Unity 2017.4
Visual Studio 2017
Um headset imersivo (VR) Windows Mixed Reality ou Microsoft HoloLens com o modo desenvolvedor habilitado
Acesso à Internet para o Azure e para recuperação do Bot do Azure. Para obter mais informações, siga este link.

Antes de começar

Para evitar problemas ao criar este projeto, é altamente recomendável que você crie o projeto mencionado neste tutorial em uma pasta raiz ou quase raiz (caminhos de pasta longa podem causar problemas no tempo de build).
Configure e teste o HoloLens. Se você precisar de suporte para configurar o HoloLens, visite o artigo de configuração do HoloLens.
É uma boa ideia executar a Calibragem e o Ajuste do 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 Calibragem, siga este link para o artigo Calibragem do HoloLens.

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

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.

Abra o Visual Studio. Crie um novo projeto, selecione Aplicativo Web ASP NET Core como o tipo de projeto (você o encontrará na subseção .NET Core) e chame-o de MyBot. Clique em OK.
Na Janela que aparecerá, selecione Vazio. Verifique também se o destino está definido como ASP NET Core 2.0 e se a Autenticação está definida como Sem Autenticação. Clique em OK.
A solução agora será aberta. Clique com o botão direito do mouse em Solution Mybot no Gerenciador de Soluções e clique em Gerenciar Pacotes NuGet para solução.
Na guia Procurar, pesquiseMicrosoft.Bot.Builder.Integration.AspNet.Core (verifique se a opção Incluir pré-lançamento está marcada). Selecione o pacote versão 4.0.1-preview e marque as caixas do projeto. Em seguida, clique em Instalar. Agora você instalou as bibliotecas necessárias para o Bot Framework v4. Feche a página NuGet.
Clique com o botão direito do mouse em seu Projeto, MyBot, no Gerenciador de Soluções e clique em Adicionar|Classe.
Nomeie a classe MyBot e clique em Adicionar.
Repita o ponto anterior para criar outra classe chamada ConversationContext.
Clique com o botão direito do mouse em wwwroot no Gerenciador de Soluções e clique em Adicionar|Novo Item. Selecione Página HTML (você a encontrará na Web de subseção). Nomeie o arquivo default.html. Clique em Adicionar.
A lista de classes/objetos no Gerenciador de Soluções deve ser semelhante à imagem abaixo.
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, porque 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;
    }
}
```

Clique duas vezes na classe MyBot . Essa classe hospedará os manipuladores chamados por qualquer atividade de entrada do cliente. Nessa 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?");
            }

        }
    }
}

Clique duas vezes na classe Startup . 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();
        }
    }
}

Abra o arquivo de classe Programa 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();
    }
}

Lembre-se de salvar suas alterações, para fazer isso, vá para Arquivo>Salvar Tudo, 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 seu 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, em seguida, publicar seu código nele.

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.
Depois de fazer logon, clique em Criar um recurso no canto superior esquerdo, pesquise bot de aplicativo Web e clique em Enter.
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 esse Serviço.
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 o Local 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 que entendeu os Termos e Condições aplicados a este Serviço.
11. Clique em Criar.
Depois de clicar em Criar, você terá que aguardar a criação do Serviço, isso pode levar um minuto.
Uma notificação será exibida no Portal depois que a instância de Serviço for criada.
Clique na notificação para explorar sua nova instância de Serviço.
Clique no botão Ir para o 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.
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.
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 pegue uma cópia de uma das Chaves exibidas, pois você precisará disso mais tarde em seu projeto.

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.

Voltar à solução do Visual Studio que você criou anteriormente.
Clique com o botão direito do mouse em seu projeto MyBot, no Gerenciador de Soluções, em seguida, clique em Publicar.
Na página Escolher um destino de publicação, clique em Serviço de Aplicativo, selecione Existente e, por fim, clique em Criar Perfil (talvez seja necessário clicar na seta suspensa ao lado do botão Publicar, se isso não estiver visível).
Se você ainda não estiver conectado à sua conta da Microsoft, precisará fazer isso aqui.
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 a Exibição como Grupo de Recursos e, na estrutura de pastas suspensas, selecione o Grupo de Recursos que você criou anteriormente. Clique em OK.
Agora, clique no botão Publicar e aguarde até que o Bot seja publicado (pode levar alguns minutos).

Capítulo 4 – Configurar o projeto do Unity

Veja a seguir uma configuração típica para o desenvolvimento com realidade misturada e, como tal, é um bom modelo para outros projetos.

Abra o Unity e clique em Novo.
Agora você precisará fornecer um nome de projeto do Unity. Insira o Bot do HoloLens. Verifique se o modelo de projeto está definido como 3D. Defina o Local como em algum lugar apropriado para você (lembre-se de que mais perto dos diretórios raiz é melhor). Em seguida, clique em Criar projeto.
Com o Unity aberto, vale a pena verificar se o Editor de Scripts padrão está definido como Visual Studio. Vá para Editar > Preferências e, na nova janela, navegue até Ferramentas Externas. Altere o Editor de Script Externo para o Visual Studio 2017. Feche a janela Preferências.
Em seguida, vá para Configurações de Build de Arquivo > e selecione Plataforma Universal do Windows, em seguida, clique no botão Alternar Plataforma para aplicar sua seleção.
Ainda em Configurações de Build de Arquivo > e certifique-se de que:
1. O dispositivo de destino está definido como HoloLens
  
  Para os headsets imersivos, defina Dispositivo de Destino como Qualquer Dispositivo.
2. O Tipo de Build é definido como D3D
3. O SDK está definido como Mais recente instalado
4. A versão do Visual Studio 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 salvar será exibida.
  2. Crie uma nova pasta para essa cena e qualquer cena futura e, em seguida, selecione o botão Nova pasta para criar uma nova pasta, nomeie-a cenas.
  3. Abra a pasta Cenas recém-criada e, em seguida, no campo de texto Nome do arquivo: , digite BotScene e clique em Salvar.
7. As configurações restantes, em Configurações de Build, devem ser deixadas como padrão por enquanto.
Na janela Configurações de Build , clique no botão Configurações do Player . Isso abrirá o painel relacionado no espaço em que o Inspetor está localizado.
Neste painel, algumas configurações precisam ser verificadas:
1. Na guia Outras Configurações :
  1. A versão do 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
2. Na guia Configurações de Publicação, em Recursos, marcar:
  - InternetClient
  - Microfone
3. Mais abaixo no painel, em Configurações de XR (encontradas abaixo de Configurações de Publicação), marque Com suporte à Realidade Virtual, verifique se o SDK do Windows Mixed Reality foi adicionado.
De volta às Configurações de Build, os projetos C# do Unity não estão mais esmaecidos; marque a caixa de seleção ao lado disso.
Feche a janela Configurações de Build.
Salve a cena e o projeto (FILE > SAVE SCENE/FILE > SAVE PROJECT).

Capítulo 5 – Configuração da câmera

Importante

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

No painel Hierarquia, selecione a Câmera Principal.
Depois de selecionado, você poderá ver todos os componentes da Câmera Principal no painel Inspetor.
1. O objeto Camera deve ser chamado de Câmera Principal (observe a ortografia)
2. A Marca da 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 Limpar Sinalizadores como Cor Sólida.
5. Defina a Cor da Tela de Fundo do componente Câmera como Preto, Alfa 0 (Código Hex: #000000000)

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 correta de pastas do Unity aqui.

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

Adicione o pacote .unity ao Unity usando a opção de menuPacote Personalizado importarpacote>de ativos>.
Na caixa Importar Pacote do Unity que aparece, verifique se tudo em (e incluindo) Plug-ins está selecionado.
Clique no botão Importar para adicionar os itens ao seu projeto.
Vá para a pasta Newtonsoft em Plug-ins na exibição do projeto e selecione o plug-in Newtonsoft.
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.

Observação

Marcar esses plug-ins configura-os 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.
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 é verificado

Capítulo 7 – Criar o BotTag

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.
Clique no + símbolo . Nomeie a nova Marca como BotTag, Salvar.

Aviso

Não aplique o BotTag à Câmera Principal. Se você tiver feito isso acidentalmente, altere a marca câmera principal 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 possa ser armazenada dentro do mesmo script e acessada 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:

Clique com o botão direito do mouse no painel Projeto e, em seguida, crie > pasta. Nomeie a pasta Scripts.
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.
Clique duas vezes no novo script BotObjects para abri-lo com o Visual Studio.

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

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:

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

Para criar essa classe:

Vá para a pasta Scripts que você criou anteriormente.
Clique com o botão direito do mouse dentro da pasta Criar > Script C#. Chame o script GazeInput.
Clique duas vezes no novo script GazeInput para abri-lo com o Visual Studio.

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

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;

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

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

Implemente os métodos que configurarão o Raycast da Câmera Principal e manterão o controle do 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);
                }
            }
        }
    }

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 aplicativo, que armazena:

Suas credenciais do Bot de 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 corrotina SendMessageToBot() criará uma atividade, que é um objeto reconhecido pelo Bot Framework como dados enviados pelo usuário.

Para criar essa classe:

Clique duas vezes na pasta Scripts para abri-la.
Clique com o botão direito do mouse na pasta Scripts e clique em Criar > Script C#. Nomeie o bot de script.
Clique duas vezes no novo script para abri-lo com o Visual Studio.

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;

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 a Chave Secreta do Bot na variável botSecret . Você anotou sua Chave Secreta do Bot no início deste curso, no Capítulo 2, etapa 10.

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

Adicione os dois manipuladores que são chamados pelas bibliotecas de fala quando a captura de voz começa e termina. 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();
    }

O manipulador a seguir coleta o resultado da entrada de voz do usuário e chama a corrotina 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();
    }

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

A corrotina a seguir é chamada para criar 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));
        }
    }

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

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

Capítulo 11 – Criar a classe Interactions

A classe que você vai criar agora é chamada de Interações. Essa classe é usada para detectar a Entrada de Toque do HoloLens 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, indicadas pelo uso de base.

Para criar essa classe:

Clique duas vezes na pasta Scripts para abri-la.
Clique com o botão direito do mouse na pasta Scripts e clique em Criar > Script C#. Nomeie o script como Interações.
Clique duas vezes no novo script para abri-lo com o Visual Studio.
Atualize os namespaces e a herança de classe para serem iguais aos seguintes, na parte superior da classe Interactions :
```
using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{
```

Dentro da classe Interactions , adicione a seguinte variável:

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

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

Adicione o manipulador que será disparado quando o usuário executar o gesto de toque na frente da câmera do 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());
                }                                  
            }
        }
    }

Salve as 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:

Clique duas vezes na pasta Scripts para abri-la.
Clique com o botão direito do mouse na pasta Scripts e clique em Criar > Script C#. Nomeie o script SceneOrganiser.
Clique duas vezes no novo script para abri-lo com o Visual Studio.

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;

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

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

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

Salve as alterações no Visual Studio antes de retornar ao Unity.
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 Câmera Principal, conforme mostrado na imagem abaixo.

Capítulo 13 – Antes de compilar

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

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

Capítulo 14 – Build e Sideload para o HoloLens

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

Navegue até Configurações de Build, Configurações de Build de Arquivo > ....
Na janela Configurações de Build , clique em Compilar.
Caso ainda não tenha feito isso, marque Projetos C# do Unity.
Clique em Compilar. O Unity iniciará uma janela de Explorador de Arquivos, na qual você precisa criar e selecionar uma pasta para compilar o aplicativo. Crie essa pasta agora e nomeie-a como Aplicativo. Em seguida, com a pasta Aplicativo selecionada, clique em Selecionar Pasta.
O Unity começará a compilar seu projeto para a pasta Aplicativo .
Depois que o Unity terminar de compilar (pode levar algum tempo), ele abrirá uma janela Explorador de Arquivos no local do build (marcar 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:

Você precisará do endereço IP do HoloLens (para Implantação Remota) e para garantir que o HoloLens esteja no modo de desenvolvedor. Para fazer isso:
1. Enquanto estiver usando o HoloLens, abra as Configurações.
2. Acesse Rede & Internet > Wi-Fi > Opções Avançadas
3. Observe o endereço IPv4 .
4. Em seguida, navegue de volta para Configurações e, em seguida, para Atualizar & Segurança > para Desenvolvedores
5. Defina Modo de Desenvolvedor Ativado.
Navegue até o novo build do Unity (a pasta Aplicativo ) e abra o arquivo de solução com o Visual Studio.
Na Configuração da Solução , selecione Depurar.
Na Plataforma de Solução, selecione x86, Computador Remoto.
Vá para o menu Compilar e clique em Implantar Solução para fazer sideload do aplicativo para o HoloLens.
Seu aplicativo agora deve aparecer na lista de aplicativos instalados em seu HoloLens, prontos para serem iniciados!

Observação

Para implantar no 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 estiver 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á imediatamente 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 Bot de Aplicativo Web (v4) concluído

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

Produto Final

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.

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

Suporte a dispositivos

Pré-requisitos

Antes de começar

Capítulo 1 – Criar o aplicativo bot

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

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

Capítulo 4 – Configurar o projeto do Unity

Capítulo 5 – Configuração da câmera

Capítulo 6 – Importar a biblioteca Newtonsoft

Capítulo 7 – Criar o BotTag

Capítulo 8 – Criar a classe BotObjects

Capítulo 9 – Criar a classe GazeInput

Capítulo 10 – Criar a classe Bot

Capítulo 11 – Criar a classe Interactions

Capítulo 12 – Criar a classe SceneOrganiser

Capítulo 13 – Antes de compilar

Capítulo 14 – Build e Sideload para o HoloLens

Capítulo 15 – Implantar no HoloLens

Capítulo 16 – Usando o aplicativo no HoloLens

Algumas perguntas para fazer ao Bot:

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

Exercícios de bônus

Exercício 1

Exercício 2

Recursos adicionais