HoloLens (1.ª generación) y Azure 312: Integración de bots

Artículo
03/21/2023

Nota

Los tutoriales de Mixed Reality Academy se han diseñado teniendo en cuenta HoloLens (1.ª generación) y los cascos envolventes de realidad mixta. Por lo tanto, creemos que es importante conservar estos tutoriales para los desarrolladores que sigan buscando instrucciones sobre el desarrollo para esos dispositivos. Estos tutoriales no se actualizarán con los conjuntos de herramientas o las interacciones más recientes que se usan para HoloLens 2. Se mantendrán para que sigan funcionando en los dispositivos compatibles. Habrá una nueva serie de tutoriales que se publicarán en el futuro que demostrarán cómo desarrollar para HoloLens 2. Este aviso se actualizará con un vínculo a esos tutoriales cuando se publiquen.

En este curso, aprenderá a crear e implementar un bot mediante el Microsoft Bot Framework V4 y a comunicarse con él a través de una aplicación Windows Mixed Reality.

Captura de pantalla que muestra la comunicación a través de una aplicación de Windows Mixed Reality.

El Microsoft Bot Framework V4 es un conjunto de API diseñadas para proporcionar a los desarrolladores las herramientas para compilar una aplicación de bot extensible y escalable. Para obtener más información, visite la página Microsoft Bot Framework o el repositorio de Git V4.

Después de completar este curso, habrá creado una aplicación de Windows Mixed Reality, que podrá hacer lo siguiente:

Use un gesto de pulsación para iniciar el bot escuchando la voz de los usuarios.
Cuando el usuario haya dicho algo, el bot intentará proporcionar una respuesta.
Muestra la respuesta de los bots como texto, situado cerca del bot, en la escena de Unity.

En la aplicación, le corresponde la forma en que integrará los resultados con el diseño. Este curso está diseñado para enseñar a integrar un servicio de Azure con el proyecto de Unity. Es su trabajo usar los conocimientos que obtiene de este curso para mejorar la aplicación de realidad mixta.

Compatibilidad con dispositivos

Curso	HoloLens	Cascos envolventes
Realidad mixta y Azure (312): Integración de bots	✔️	✔️

Nota

Aunque este curso se centra principalmente en HoloLens, también puede aplicar lo que aprende en este curso para Windows Mixed Reality cascos envolventes (VR). Dado que los cascos envolventes (VR) no tienen cámaras accesibles, necesitará una cámara externa conectada a su PC. A medida que siga con el curso, verá notas sobre los cambios que puede que tenga que emplear para admitir cascos envolventes (VR).

Requisitos previos

Nota:

Este tutorial está diseñado para desarrolladores que tienen experiencia básica con Unity y C#. Tenga en cuenta también que los requisitos previos y las instrucciones escritas de este documento representan lo que se ha probado y comprobado en el momento de escribirlo (julio de 2018). Puede usar el software más reciente, como se muestra en el artículo de instalación de las herramientas , aunque no debe asumirse que la información de este curso coincidirá perfectamente con lo que encontrará en el software más reciente que lo que se muestra a continuación.

Se recomienda el siguiente hardware y software para este curso:

Un equipo de desarrollo, compatible con Windows Mixed Reality para el desarrollo de cascos envolventes (VR)
Windows 10 Fall Creators Update (o posterior) con el modo de desarrollador habilitado
El SDK de Windows 10 más reciente
Unity 2017.4
Visual Studio 2017
Casco envolvente (VR) Windows Mixed Reality o Microsoft HoloLens con el modo desarrollador habilitado
Acceso a Internet para Azure y para la recuperación de Azure Bot. Para obtener más información, siga este vínculo.

Antes de empezar

Para evitar problemas al compilar este proyecto, se recomienda encarecidamente crear el proyecto mencionado en este tutorial en una carpeta raíz o casi raíz (las rutas de acceso de carpeta largas pueden causar problemas en tiempo de compilación).
Configure y pruebe holoLens. Si necesita compatibilidad con la configuración de HoloLens, asegúrese de visitar el artículo de configuración de HoloLens.
Es una buena idea realizar la calibración y la optimización del sensor al empezar a desarrollar una nueva aplicación de HoloLens (a veces puede ayudar a realizar esas tareas para cada usuario).

Para obtener ayuda sobre calibración, siga este vínculo al artículo Calibración de HoloLens.

Para obtener ayuda sobre la optimización de sensores, siga este vínculo al artículo Optimización del sensor de HoloLens.

Capítulo 1: Creación de la aplicación bot

El primer paso es crear el bot como una aplicación web local ASP.Net Core. Una vez que haya terminado y probado, lo publicará en Azure Portal.

Abra Visual Studio. Cree un proyecto, seleccione Aplicación web de ASP NET Core como el tipo de proyecto (lo encontrará en la subsección .NET Core) y llámalo MyBot. Haga clic en OK.
En la ventana que aparecerá, seleccione Vacío. Asegúrese también de que el destino está establecido en ASP NET Core 2.0 y la autenticación está establecida en Sin autenticación. Haga clic en OK.
Ahora se abrirá la solución. Haga clic con el botón derecho en Solución Mybot en el Explorador de soluciones y haga clic en Administrar paquetes NuGet para la solución.
En la pestaña Examinar , busque Microsoft.Bot.Builder.Integration.AspNet.Core (asegúrese de que ha activado Incluir versión preliminar ). Seleccione la versión 4.0.1-preview del paquete y marque las casillas del proyecto. A continuación, haga clic en Instalar. Ahora ha instalado las bibliotecas necesarias para Bot Framework v4. Cierre la página NuGet.
Haga clic con el botón derecho en el proyecto, MyBot, en el Explorador de soluciones y haga clic en Agregar|clase.
Asigne un nombre a la clase MyBot y haga clic en Agregar.
Repita el punto anterior para crear otra clase denominada ConversationContext.
Haga clic con el botón derecho en wwwroot en el Explorador de soluciones y haga clic en Agregar|nuevo elemento. Seleccione Página HTML (la encontrará en la subsección Web). Asigne al archivo el nombre default.html. Haga clic en Agregar.
La lista de clases y objetos de la Explorador de soluciones debe ser similar a la imagen siguiente.
Haga doble clic en la clase ConversationContext . Esta clase es responsable de contener las variables usadas por el bot para mantener el contexto de la conversación. Estos valores de contexto de conversación se mantienen en una instancia de esta clase, ya que cualquier instancia de la clase MyBot se actualizará cada vez que se reciba una actividad. Agregue el código siguiente a la clase :
```
namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}
```

Haga doble clic en la clase MyBot . Esta clase hospedará los controladores a los que llama cualquier actividad entrante del cliente. En esta clase, agregará el código usado para compilar la conversación entre el bot y el cliente. Como se mencionó anteriormente, se inicializa una instancia de esta clase cada vez que se recibe una actividad. Agregue el código siguiente a esta clase:

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

        }
    }
}

Haga doble clic en la clase Startup . Esta clase inicializará el bot. Agregue el código siguiente a la clase :

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 el archivo de clase Program y compruebe que el código de es el mismo que el siguiente:

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

Recuerde guardar los cambios para hacerlo, vaya a Guardar>todo en la barra de herramientas de la parte superior de Visual Studio.

Capítulo 2: Creación del Bot Service de Azure

Ahora que ha creado el código para el bot, debe publicarlo en una instancia de Web App Bot Service, en Azure Portal. En este capítulo se muestra cómo crear y configurar el Bot Service en Azure y, a continuación, publicar el código en él.

En primer lugar, inicie sesión en Azure Portal (https://portal.azure.com).
1. Si aún no tiene una cuenta de Azure, deberá crear una. Si sigue este tutorial en una situación de clase o laboratorio, pida a su instructor o a uno de los proctores que le ayuden a configurar su nueva cuenta.
Una vez que haya iniciado sesión, haga clic en Crear un recurso en la esquina superior izquierda y busque Bot de aplicación web y haga clic en Entrar.
La nueva página proporcionará una descripción de Web App Bot Service. En la parte inferior izquierda de esta página, seleccione el botón Crear para crear una asociación con este servicio.
Una vez que haya hecho clic en Crear:
1. Inserte el nombre deseado para esta instancia de servicio.
2. Seleccione una opción en Suscripción.
3. Elija un grupo de recursos o cree uno nuevo. Un grupo de recursos proporciona una manera de supervisar, controlar el acceso, aprovisionar y administrar la facturación de una colección de recursos de Azure. Se recomienda mantener todos los servicios de Azure asociados a un único proyecto (por ejemplo, estos cursos) en un grupo de recursos común).
  
  Si desea obtener más información sobre los grupos de recursos de Azure, siga este vínculo.
4. Determine la ubicación del grupo de recursos (si va a crear un nuevo grupo de recursos). Idealmente, la ubicación sería en la región donde se ejecutaría la aplicación. Algunos recursos de Azure solo están disponibles en determinadas regiones.
5. Seleccione el plan de tarifa adecuado para usted, si es la primera vez que se crea una instancia de Web App Bot Service, debe estar disponible un nivel gratuito (denominado F0).
6. El nombre de la aplicación se puede dejar igual que el nombre del bot.
7. Deje la plantilla bot como Básica (C#).
8. El plan o la ubicación de App Service deben haberse rellenado automáticamente para su cuenta.
9. Establezca Azure Storage que desea usar para hospedar el bot. Si aún no tiene una, puede crearla aquí.
10. También deberá confirmar que ha comprendido los Términos y Condiciones aplicados a este Servicio.
11. Haga clic en Crear.
Una vez que haya hecho clic en Crear, tendrá que esperar a que se cree el servicio, esto puede tardar un minuto.
Una notificación aparecerá en el portal una vez creada la instancia de servicio.
Haga clic en la notificación para explorar la nueva instancia de servicio.
Haga clic en el botón Ir al recurso en la notificación para explorar la nueva instancia de servicio. Se le dirigirá a la nueva instancia de servicio de Azure.
En este momento, debe configurar una característica denominada Direct Line para permitir que la aplicación cliente se comunique con este Bot Service. Haga clic en Canales y, a continuación, en la sección Agregar un canal destacado, haga clic en Configurar Direct Line canal.
En esta página encontrará las claves secretas que permitirán que la aplicación cliente se autentique con el bot. Haga clic en el botón Mostrar y copie una de las claves mostradas, ya que lo necesitará más adelante en el proyecto.

Capítulo 3: Publicación del bot en azure Web App Bot Service

Ahora que el servicio está listo, debe publicar el código del bot, que creó anteriormente, en la Bot Service de aplicación web recién creada.

Nota

Tendrá que publicar el bot en el servicio de Azure cada vez que realice cambios en la solución o el código del bot.

Volver a la solución de Visual Studio que creó anteriormente.
Haga clic con el botón derecho en el proyecto MyBot, en el Explorador de soluciones y, a continuación, haga clic en Publicar.
En la página Elegir un destino de publicación, haga clic en App Service y, a continuación, en Seleccionar existente, haga clic por último en Crear perfil (es posible que tenga que hacer clic en la flecha desplegable junto al botón Publicar, si no está visible).
Si aún no ha iniciado sesión en su cuenta Microsoft, debe hacerlo aquí.
En la página Publicar encontrará que tiene que establecer la misma suscripción que usó para la creación de Web App Bot Service. A continuación, establezca la vista como grupo de recursos y, en la estructura de carpetas desplegables, seleccione el grupo de recursos que ha creado anteriormente. Haga clic en OK.
Ahora haga clic en el botón Publicar y espere a que se publique el bot (puede tardar unos minutos).

Capítulo 4: Configuración del proyecto de Unity

A continuación se muestra una configuración típica para desarrollar con realidad mixta y, como tal, es una buena plantilla para otros proyectos.

Abra Unity y haga clic en Nuevo.
Ahora deberá proporcionar un nombre de proyecto de Unity. Inserte el bot de HoloLens. Asegúrese de que la plantilla de proyecto está establecida en 3D. Establezca la ubicación en algún lugar adecuado para usted (recuerde que más cerca de los directorios raíz es mejor). A continuación, haga clic en Crear proyecto.
Con Unity abierto, vale la pena comprobar que el Editor de scripts predeterminado está establecido en Visual Studio. Vaya a Editar > preferencias y, a continuación, en la nueva ventana, vaya a Herramientas externas. Cambie el Editor de scripts externos a Visual Studio 2017. Cierre la ventana Preferencias.
A continuación, vaya a Configuración de compilación de archivos > y seleccione Plataforma universal de Windows y haga clic en el botón Switch Platform (Cambiar plataforma) para aplicar la selección.
Mientras sigue en Configuración de compilación de archivos > y asegúrese de que:
1. El dispositivo de destino está establecido en HoloLens.
  
  Para los cascos envolventes, establezca Dispositivo de destino en Cualquier dispositivo.
2. El tipo de compilación se establece en D3D.
3. El SDK se establece en Latest installed (Versión más reciente instalada)
4. La versión de Visual Studio se establece en Latest installed (Versión más reciente instalada)
5. Compilar y ejecutar está establecido en Equipo local
6. Guarde la escena y agréguela a la compilación.
  1. Para ello, seleccione Agregar escenas abiertas. Aparecerá una ventana de guardado.
  2. Cree una nueva carpeta para esto y cualquier escena futura y, a continuación, seleccione el botón Nueva carpeta para crear una carpeta nueva, asígnela el nombre Scenes.
  3. Abra la carpeta Escenas recién creada y, a continuación, en el campo Nombre de archivo: texto, escriba BotScene y, a continuación, haga clic en Guardar.
7. La configuración restante, en Configuración de compilación, debe dejarse como predeterminada por ahora.
En la ventana Configuración de compilación, haga clic en el botón Configuración del reproductor ; se abrirá el panel relacionado en el espacio donde se encuentra el Inspector .
En este panel, es necesario comprobar algunas opciones de configuración:
1. En la pestaña Otros valores:
  1. La versión del entorno de ejecución de scripting debe ser Experimental (NET 4.6 Equivalente); cambiar esto requerirá un reinicio del Editor.
  2. El back-end de scripting debe ser .NET
  3. El nivel de compatibilidad de API debe ser .NET 4.6
2. En la pestaña Configuración de publicación, en Funcionalidades, active:
  - InternetClient
  - Micrófono
3. Más abajo en el panel, en Configuración de XR (que se encuentra a continuación de Configuración de publicación), marque Virtual Reality Supported (Compatible con Realidad virtual), asegúrese de que se agrega el SDK de Windows Mixed Reality.
De nuevo en Build SettingsUnity C# Projects ya no está atenuado; marque la casilla situada junto a esto.
Cierre la ventana Build Settings (Configuración de compilación).
Guarde la escena y el proyecto (ARCHIVO > SAVE SCENE /FILE > SAVE PROJECT).

Capítulo 5: Configuración de la cámara

Importante

Si desea omitir el componente Configuración de Unity de este curso y continuar directamente en el código, no dude en descargar este paquete Azure-MR-312-Package.unitypackage, impórtelo en el proyecto como paquete personalizado y, a continuación, continúe desde el capítulo 7.

En el panel Jerarquía, seleccione la cámara principal.
Una vez seleccionado, podrá ver todos los componentes de la cámara principal en el panel Inspector.
1. El objeto Camera debe denominarse Cámara principal (tenga en cuenta la ortografía)
2. La etiqueta de cámara principal debe establecerse en MainCamera (tenga en cuenta la ortografía).
3. Asegúrese de que la posición de transformación está establecida en 0, 0, 0
4. Establezca Borrar marcas en Color sólido.
5. Establezca el color de fondo del componente cámara en Negro, Alfa 0 (Código hexadecimal: #000000000)

Capítulo 6: Importación de la biblioteca Newtonsoft

Para ayudarle a deserializar y serializar objetos recibidos y enviados al Bot Service debe descargar la biblioteca Newtonsoft. Encontrará una versión compatible ya organizada con la estructura de carpetas de Unity correcta aquí.

Para importar la biblioteca Newtonsoft en el proyecto, use el paquete de Unity que se incluye con este curso.

Agregue el paquete .unitypackage a Unity mediante la opción de menúImportar paquetepersonalizadodel> paquete > de activos.
En el cuadro Importar paquete de Unity que aparece, asegúrese de que está seleccionado todo en Complementos (e incluidos).
Haga clic en el botón Importar para agregar los elementos al proyecto.
Vaya a la carpeta Newtonsoft en Complementos en la vista del proyecto y seleccione el complemento Newtonsoft.
Con el complemento Newtonsoft seleccionado, asegúrese de que Cualquier plataforma está desactivada y, a continuación, asegúrese de que WSAPlayer también está desactivado y, a continuación, haga clic en Aplicar. Esto es solo para confirmar que los archivos están configurados correctamente.

Nota

Marcar estos complementos los configura para que solo se usen en el Editor de Unity. Hay un conjunto diferente en la carpeta WSA que se usará después de exportar el proyecto desde Unity.
A continuación, debe abrir la carpeta WSA , dentro de la carpeta Newtonsoft . Verá una copia del mismo archivo que acaba de configurar. Seleccione el archivo y, a continuación, en el inspector, asegúrese de que
- Cualquier plataforma está desactivada
- solo se compruebaWSAPlayer
- No se comprueba el proceso

Capítulo 7: Creación de botTag

Cree un nuevo objeto Tag denominado BotTag. Seleccione la Cámara principal en la escena. Haga clic en el menú desplegable Etiqueta del panel Inspector. Haga clic en Agregar etiqueta.
Haga clic en el + símbolo. Asigne un nombre a la nueva etiqueta como BotTag, Guardar.

Advertencia

No aplique botTag a la cámara principal. Si lo ha hecho accidentalmente, asegúrese de volver a cambiar la etiqueta Cámara principal a MainCamera.

Capítulo 8: Creación de la clase BotObjects

El primer script que necesita crear es la clase BotObjects , que es una clase vacía creada para que se pueda almacenar una serie de otros objetos de clase en el mismo script y tener acceso a ellos otros scripts de la escena.

La creación de esta clase es simplemente una opción arquitectónica, estos objetos podrían hospedarse en el script bot que creará más adelante en este curso.

Para crear esta clase:

Haga clic con el botón derecho en el panel Proyecto y, a continuación, en Crear > carpeta. Asigne un nombre a la carpeta Scripts.
Haga doble clic en la carpeta Scripts para abrirla. A continuación, dentro de esa carpeta, haga clic con el botón derecho y seleccione Crear > script de C#. Asigne al script el nombre BotObjects.
Haga doble clic en el nuevo script BotObjects para abrirlo con Visual Studio.

Elimine el contenido del script y reemplácelo por el código siguiente:

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

Asegúrese de guardar los cambios en Visual Studio antes de volver a Unity.

Capítulo 9: Creación de la clase GazeInput

La siguiente clase que va a crear es la clase GazeInput . Esta clase es responsable de:

Crear un cursor que represente la mirada del jugador.
Detectar objetos alcanzados por la mirada del jugador y mantener una referencia a los objetos detectados.

Para crear esta clase:

Vaya a la carpeta Scripts que creó anteriormente.
Haga clic con el botón derecho dentro de la carpeta Crear > script de C#. Llame al script GazeInput.
Haga doble clic en el nuevo script GazeInput para abrirlo con Visual Studio.

Inserte la siguiente línea justo en la parte superior del nombre de clase:

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

A continuación, agregue las siguientes variables dentro de la clase GazeInput, encima del 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;

Se debe agregar código para el método Start(). Se llamará a esto cuando se inicialice la clase :

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

Implemente un método que cree instancias y configure el cursor de mirada:

    /// <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 los métodos que configurarán Raycast desde la cámara principal y realizará un seguimiento del objeto centrado actual.

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

Asegúrese de guardar los cambios en Visual Studio antes de volver a Unity.

Capítulo 10: Creación de la clase Bot

El script que va a crear ahora se denomina Bot. Esta es la clase principal de la aplicación, almacena:

Credenciales del bot de aplicación web
Método que recopila los comandos de voz del usuario.
El método necesario para iniciar conversaciones con el bot de aplicación web
El método necesario para enviar mensajes al bot de aplicación web

Para enviar mensajes a la Bot Service, la corrutina SendMessageToBot() creará una actividad, que es un objeto reconocido por Bot Framework como datos enviados por el usuario.

Para crear esta clase:

Haga doble clic en la carpeta Scripts para abrirla.
Haga clic con el botón derecho en la carpeta Scripts y haga clic en Crear > script de C#. Asigne un nombre al bot de script.
Haga doble clic en el nuevo script para abrirlo con Visual Studio.

Actualice los espacios de nombres para que sean los mismos que los siguientes, en la parte superior de la clase Bot :

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

Dentro de la clase Bot , agregue las siguientes variables:

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

Nota

Asegúrese de insertar la clave secreta del bot en la variable botSecret . Habrá anotado la clave secreta del bot al principio de este curso, en el capítulo 2, paso 10.

Ahora es necesario agregar código para Awake() e Start().

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

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

Agregue los dos controladores a los que llaman las bibliotecas de voz cuando comienza y termina la captura de voz. El DictadoRecognizer dejará de capturar automáticamente la voz del usuario cuando el usuario deje de hablar.

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

El siguiente controlador recopila el resultado de la entrada de voz del usuario y llama a la corrutina responsable de enviar el mensaje a web App Bot Service.

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

Se llama a la corrutina siguiente para iniciar una conversación con el bot. Observará que una vez completada la llamada de conversación, llamará a SendMessageToCoroutine() pasando una serie de parámetros que establecerán la actividad que se enviará a la Bot Service como un mensaje vacío. Esto se hace para pedir al Bot Service que inicie el 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"));
    }

Se llama a la corrutina siguiente para compilar la actividad que se enviará al Bot Service.

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

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

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

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

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

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

            yield return www.SendWebRequest();

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

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

Se llama a la corrutina siguiente para solicitar una respuesta después de enviar una actividad al Bot Service.

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

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

            yield return unityWebRequest1.SendWebRequest();

            string jsonResponse = unityWebRequest1.downloadHandler.text;

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

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

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

El último método que se va a agregar a esta clase es necesario para mostrar el mensaje en la escena:
```
    /// <summary>
    /// Set the UI Response Text of the bot
    /// </summary>
    internal void SetBotResponseText(string responseString)
    {        
        SceneOrganiser.Instance.botResponseText.text =  responseString;
    }
```
Nota

Es posible que vea un error en la consola del editor de Unity, sobre la falta de la clase SceneOrganiser . Omita este mensaje, ya que creará esta clase más adelante en el tutorial.
Asegúrese de guardar los cambios en Visual Studio antes de volver a Unity.

Capítulo 11: Crear la clase Interactions

La clase que va a crear ahora se denomina Interacciones. Esta clase se usa para detectar la entrada de Pulsación de HoloLens del usuario.

Si el usuario pulsa mientras examina el objeto Bot en la escena y el bot está listo para escuchar entradas de voz, el objeto Bot cambiará el color al rojo y comenzará a escuchar las entradas de voz.

Esta clase hereda de la clase GazeInput , por lo que es capaz de hacer referencia al método Start() y las variables de esa clase, indicadas por el uso de base.

Para crear esta clase:

Haga doble clic en la carpeta Scripts para abrirla.
Haga clic con el botón derecho en la carpeta Scripts y haga clic en Crear > script de C#. Asigne un nombre a las interacciones del script.
Haga doble clic en el nuevo script para abrirlo con Visual Studio.
Actualice los espacios de nombres y la herencia de clases para que sean los mismos que los siguientes, en la parte superior de la clase Interactions :
```
using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{
```

Dentro de la clase Interactions , agregue la siguiente variable:

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

A continuación, agregue el 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();
    }

Agregue el controlador que se desencadenará cuando el usuario realice el gesto de pulsación delante de la cámara 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());
                }                                  
            }
        }
    }

Asegúrese de guardar los cambios en Visual Studio antes de volver a Unity.

Capítulo 12: Creación de la clase SceneOrganiser

La última clase necesaria en este laboratorio se denomina SceneOrganiser. Esta clase configurará la escena mediante programación, agregando componentes y scripts a la cámara principal y creando los objetos adecuados en la escena.

Para crear esta clase:

Haga doble clic en la carpeta Scripts para abrirla.
Haga clic con el botón derecho en la carpeta Scripts y haga clic en Crear > script de C#. Asigne al script el nombre SceneOrganiser.
Haga doble clic en el nuevo script para abrirlo con Visual Studio.

Dentro de la clase SceneOrganiser , agregue las siguientes variables:

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

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

A continuación, agregue los 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();
    }

Agregue el método siguiente, responsable de crear el objeto Bot en la escena y configurar los parámetros y 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";
    }

Agregue el método siguiente, responsable de crear el objeto de interfaz de usuario en la escena, que representa las respuestas del 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;
    }

Asegúrese de guardar los cambios en Visual Studio antes de volver a Unity.
En el Editor de Unity, arrastre el script SceneOrganiser desde la carpeta Scripts a la cámara principal. El componente Organizador de escena debería aparecer ahora en el objeto Cámara principal, como se muestra en la imagen siguiente.

Capítulo 13: Antes de la construcción

Para realizar una prueba exhaustiva de la aplicación, deberá transferirla localmente a HoloLens. Antes de hacerlo, asegúrese de que:

Todas las configuraciones mencionadas en el capítulo 4 se establecen correctamente.
El script SceneOrganiser se adjunta al objeto Cámara principal .
En la clase Bot , asegúrese de que ha insertado la clave secreta del bot en la variable botSecret .

Capítulo 14: Compilación y transferencia local a HoloLens

Todo lo necesario para la sección Unity de este proyecto se ha completado, por lo que es el momento de compilarlo desde Unity.

Vaya a Configuración de compilación, Configuración de compilación de archivos > ....
En la ventana Configuración de compilación , haga clic en Compilar.
Si aún no es así, marque Proyectos de C# de Unity.
Haga clic en Generar. Unity iniciará una ventana de Explorador de archivos, donde debe crear y, a continuación, seleccionará una carpeta en la que compilará la aplicación. Cree esa carpeta ahora y asígnela el nombre App. A continuación, con la carpeta Aplicación seleccionada, haga clic en Seleccionar carpeta.
Unity comenzará a compilar el proyecto en la carpeta Aplicación .
Una vez que Unity haya terminado de compilar (es posible que tarde algún tiempo), se abrirá una ventana de Explorador de archivos en la ubicación de la compilación (compruebe la barra de tareas, ya que puede que no siempre aparezca encima de las ventanas, pero le notificará la adición de una nueva ventana).

Capítulo 15: Implementación en HoloLens

Para realizar la implementación en HoloLens:

Necesitará la dirección IP de HoloLens (para la implementación remota) y para asegurarse de que HoloLens está en modo de desarrollador. Para ello, siga estos pasos:
1. Mientras llevas tu HoloLens, abre la configuración.
2. Vaya a Opciones avanzadas de Red & Internet > Wi-Fi >
3. Anote la dirección IPv4 .
4. A continuación, vuelva a Configuración y, a continuación, a Actualizar & Seguridad > para desarrolladores.
5. Establezca el modo de desarrollador activado.
Vaya a la nueva compilación de Unity (la carpeta Aplicación ) y abra el archivo de solución con Visual Studio.
En Configuración de la solución , seleccione Depurar.
En la Plataforma de soluciones, seleccione x86, Máquina remota.
Vaya al menú Compilar y haga clic en Implementar solución para transferir localmente la aplicación a HoloLens.
La aplicación debería aparecer ahora en la lista de aplicaciones instaladas en HoloLens, lista para iniciarse.

Nota

Para realizar la implementación en cascos envolventes, establezca la Plataforma de soluciones en Máquina local y establezca la configuración en Depurar, con x86 como plataforma. A continuación, implemente en el equipo local, con el menú Compilar y seleccione Implementar solución.

Capítulo 16: Uso de la aplicación en HoloLens

Una vez que haya iniciado la aplicación, verá el bot como una esfera azul delante de usted.
Usa el gesto de pulsar mientras observas en la esfera para iniciar una conversación.
Espere a que se inicie la conversación (la interfaz de usuario mostrará un mensaje cuando se produzca). Una vez que reciba el mensaje introductorio del bot, pulse de nuevo en el bot para que se vuelva rojo y empiece a escuchar su voz.
Una vez que deje de hablar, la aplicación enviará el mensaje al bot y recibirá rápidamente una respuesta que se mostrará en la interfaz de usuario.
Repita el proceso para enviar más mensajes al bot (tendrá que pulsar cada vez que desee inicializar un mensaje).

En esta conversación se muestra cómo el bot puede conservar la información (su nombre), mientras que también proporciona información conocida (por ejemplo, los artículos que se almacenan).

Algunas preguntas para formular el bot:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Aplicación de bot de aplicación web (v4) finalizada

Enhorabuena, ha creado una aplicación de realidad mixta que aprovecha azure Web App Bot, Microsoft Bot Framework v4.

Producto final

Ejercicios extra

Ejercicio 1

La estructura de conversación de este laboratorio es muy básica. Use Microsoft LUIS para proporcionar a su bot funcionalidades de comprensión del lenguaje natural.

Ejercicio 2

En este ejemplo no se incluye la terminación de una conversación y el reinicio de uno nuevo. Para completar la característica bot, intente implementar el cierre en la conversación.

HoloLens (1.ª generación) y Azure 312: Integración de bots

Compatibilidad con dispositivos

Requisitos previos

Antes de empezar

Capítulo 1: Creación de la aplicación bot

Capítulo 2: Creación del Bot Service de Azure

Capítulo 3: Publicación del bot en azure Web App Bot Service

Capítulo 4: Configuración del proyecto de Unity

Capítulo 5: Configuración de la cámara

Capítulo 6: Importación de la biblioteca Newtonsoft

Capítulo 7: Creación de botTag

Capítulo 8: Creación de la clase BotObjects

Capítulo 9: Creación de la clase GazeInput

Capítulo 10: Creación de la clase Bot

Capítulo 11: Crear la clase Interactions

Capítulo 12: Creación de la clase SceneOrganiser

Capítulo 13: Antes de la construcción

Capítulo 14: Compilación y transferencia local a HoloLens

Capítulo 15: Implementación en HoloLens

Capítulo 16: Uso de la aplicación en HoloLens

Algunas preguntas para formular el bot:

Aplicación de bot de aplicación web (v4) finalizada

Ejercicios extra

Ejercicio 1

Ejercicio 2

Recursos adicionales