Cómo integrar widgets de Android con Asistente de Google

1. Descripción general

En el primer codelab de Acciones en apps, aprendiste a extender Asistente de Google a una app de fitness de ejemplo implementando intents integrados (BII) de la categoría Salud y fitness.

Las Acciones en apps permiten a los usuarios iniciar acciones de apps directamente desde Asistente con frases como "Hey Google, inicia una ejecución en AppDeEjemplo". Además de iniciar apps, Asistente puede mostrar un widget interactivo de Android al usuario a fin de completar solicitudes de BII aptas.

$Pantalla en la que Asistente muestra un widget en respuesta a una consulta a\nuser que activó una función de BII GET_EXERCISE_OBSERVATION.$

Qué compilarás

En este codelab, aprenderás a mostrar widgets de Android para cumplir con las solicitudes de los usuarios de Asistente. También aprenderás a hacer lo siguiente:

Utilizar parámetros de BII para personalizar widgets
Brindar introducciones de texto a voz (TTS) en Asistente para tus widgets
Usar la referencia del intent integrado para determinar el BII que admite la entrega de widgets

Requisitos previos

Antes de continuar, asegúrate de que tu entorno de desarrollo esté listo para el desarrollo de Acciones en apps. Debería tener lo siguiente:

Una terminal para ejecutar comandos shell con git instalado
La versión estable más reciente de Android Studio
Un dispositivo Android físico o virtual con acceso a Internet
Una Cuenta de Google con la que se haya accedido a Android Studio, Google app y la app del Asistente de Google

Si usas un dispositivo físico, conéctalo a la máquina de desarrollo local.

2. Comprende el funcionamiento

Asistente de Google usa la comprensión del lenguaje natural (CLN) para leer las solicitudes de un usuario y hacerlas coincidir con un intent integrado (BII) de Asistente. Luego, asigna el intent a la función (que implementa el BII) que registras para ese intent en tu app. Por último, para completar la solicitud del usuario, Asistente muestra el widget de Android que genera la app con los detalles que se encuentran en la función.

En este codelab, definirás una función compatible con el BII GET_EXERCISE_OBSERVATION. En esta función, le indicas a Asistente que genere un intent de Android para la clase del widget FitActions a fin de cumplir con las solicitudes para este BII. Debes actualizar esta clase a fin de generar un widget personalizado para que Asistente lo muestre al usuario y una introducción a TTS para que Asistente la anuncie.

En el siguiente diagrama, se muestra este flujo:

La app de ejemplo de FitActions contiene un widget de información de entrenamiento que los usuarios pueden agregar a su pantalla principal. Este widget es un gran candidato para completar consultas de los usuarios que activan el BII GET_EXERCISE_OBSERVATION.

Cuando un usuario agrega un widget a la pantalla principal, el widget hace ping al receptor de emisión del dispositivo. Este servicio recupera información sobre el widget desde la definición del receptor del widget en el recurso AndroidManifest.xml de la app. Usa esta información para generar un objeto RemoteViews que representa el widget.

La app de ejemplo define el receptor widgets.StatsWidgetProvider, que corresponde a la clase StatsWidgetProvider:

<!-- app/src/main/AndroidManifest.xml -->

<receiver
  android:name=".widgets.StatsWidgetProvider"
  android:exported="false">
  <intent-filter>
    <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
  </intent-filter>
  <meta-data
    android:name="android.appwidget.provider"
    android:resource="@xml/stats_widget" />
</receiver>

La clase StatsWidgetProvider, StatsWidgetProvider.kt, administra los flujos de creación de objetos StatsWidget. Además, controla estas responsabilidades:

Crear instancias de widget y propagarlas con datos de ejercicios desde la base de datos de la app
Formatear datos de entrenamiento para facilitar la lectura, con formatDataAndSetWidget()
Brindar valores predeterminados si los datos de entrenamiento no están disponibles, mediante setNoActivityDataWidget()

Cómo agregar compatibilidad con Asistente

En este codelab, actualizarás la app de ejemplo para controlar la funcionalidad de Acciones en apps. Entre estos cambios, se incluyen los siguientes:

Configurar la capacidad de BII GET_EXERCISE_OBSERVATION para mostrar una instancia del objeto StatsWidget
Actualizar la clase StatsWidget para usar funciones de Acciones en apps como las siguientes:
- Usar parámetros de BII (lo que permite a los usuarios ver estadísticas de entrenamiento específicas mediante preguntas como: "Hey Google, muéstrame mis estadísticas de entrenamiento en AppDeEjemplo")
- Proporcionar strings de introducción a TTS
- Administrar casos especiales (por ejemplo, cuando la consulta del usuario no incluye un parámetro de tipo de entrenamiento)

3. Prepara tu entorno de desarrollo

Descarga los archivos de base

Ejecuta este comando para clonar el repositorio de GitHub de la app de ejemplo:

git clone --branch start-widget-codelab https://github.com/actions-on-google/appactions-fitness-kotlin.git

Una vez que hayas clonado el repositorio, sigue estos pasos para abrirlo en Android Studio:

En el diálogo Welcome to Android Studio, haz clic en la opción Import project.
Busca y selecciona la carpeta donde clonaste el repositorio.

Para ver una versión de la app en la que se representa el codelab terminado, debes clonar el repositorio de la app de ejemplo con la marca --branch master.

Cómo cambiar el ID de aplicación para Android

Más adelante en este codelab, usarás el complemento de Asistente de Google para probar tus acciones en un dispositivo físico o virtual. La herramienta requiere que primero subas tu app a un proyecto de Google Play Console para poder ejecutarse. Para evitar que se produzca un error por duplicación de nombre del paquete cuando subes la app a Play Console, cambia el applicationId de la app de ejemplo a uno único (Google Play no permitirá que se suban dos apps con el mismo applicationId).

En app/build.gradle, actualiza el valor PUT_YOUR_APPLICATION_ID_HERE de applicationId a un ID único, por ejemplo, com.codelabs.myname. Para obtener más información sobre los ID de aplicación para Android, consulta Cómo establecer el ID de aplicación.
Abre app/src/res/xml/shortcuts.xml y actualiza las dos (2) instancias de android:targetPackage a tu applicationId único.

Sube la app a Play Console

La carga de la app a un proyecto de Google Play Console es un requisito previo para usar ela complemento de Asistente de Google en Android Studio. Compila tu app en Android Studio y súbela a Play Console como un borrador de versión interna.

Para compilar tu app en Android Studio:

Dirígete a Build > Generate Signed Bundle / APK.
Selecciona Android App Bundle y, luego, haz clic en Next.
Ingresa los detalles para firmar tu app y haz clic en Next. Realiza un seguimiento de la ruta en la que se genera tu paquete en la sección Destination Folder.
Selecciona la variante de compilación prodRelease o release, y haz clic en Finish.

En Play Console, sube el paquete de aplicación que creaste como una app nueva. Para ello, sigue estos pasos:

En la página Todas las apps, haz clic en Crear app.
En el cuadro Nombre de la app, ingresa cualquier nombre para la app, como "codelab de widget".
En App o juego, selecciona App.
En Gratuita o pagada, selecciona Gratuita.
Acepta cualquier Declaración de la lista.
Haz clic en Crear app.
En el menú lateral de Play Console, ve a Pruebas y busca la página Pruebas internas.
En esta página, haz clic en Crear una versión nueva.
Si se te solicita, haz clic en Continuar para aceptar la firma de apps de Google Play.
En el panel Paquetes de aplicaciones y APK, sube el archivo AAB que generaste en el paso anterior. Es probable que este archivo se encuentre en el directorio app/prod/release o app/release de tu proyecto. Haz clic en Guardar.

Instala el complemento de prueba

El complemento de Asistente de Google te permite probar tus Acciones en apps en un dispositivo de prueba. Para funcionar, envía información al Asistente mediante Google app en tu dispositivo Android. Si aún no tienes ese complemento, sigue los pasos que se indican a continuación para instalarlo:

Ve a File > Settings (Android Studio > Preferences en macOS).
En la sección de complementos, ve a Marketplace y busca "Google Assistant". También puedes descargar e instalar la herramienta de pruebas manualmente.
Instala la herramienta y reinicia Android Studio.

Prueba la app en tu dispositivo

Antes de realizar más cambios en la app, te recomendamos que la ejecutes para tener una idea de lo que puede hacer la app de ejemplo.

Ejecuta la app en tu dispositivo de prueba:

En Android Studio, selecciona tu dispositivo físico o virtual y, luego, Run > Run app o haz clic en Run, en la barra de herramientas.
Mantén presionado el botón de inicio para configurar Asistente y verificar que funcione. Si aún no lo hiciste, tendrás que acceder al Asistente en el dispositivo.

Si quieres obtener más información sobre los dispositivos virtuales de Android, consulta el artículo para crear y administrar dispositivos virtuales.

Explora la app brevemente para descubrir lo que puede hacer. La app prepropaga 10 actividades de ejercicio y muestra esta información en la primera vista.

Presiona el botón de inicio para ir a la pantalla principal de tu dispositivo de prueba.
Mantén presionado un espacio vacío en la pantalla principal y selecciona Widgets.
Desplázate por la lista de widgets hasta FitActions.
Mantén presionado el ícono de FitActions y coloca el widget en la pantalla principal.

4. Agrega Acciones en apps

En este paso, agregarás la función de BII GET_EXERCISE_OBSERVATION. Para ello, agrega un nuevo elemento capability en shortcuts.xml. Esta capacidad determina cómo se activa la capacidad, cómo se usan los parámetros de BII y qué intents de Android se deben invocar para completar la solicitud.

Agrega un elemento capability nuevo al recurso shortcuts.xml del proyecto de muestra con la siguiente configuración:

<!-- fitnessactions/app/src/main/res/xml/shortcuts.xml -->

<capability android:name="actions.intent.GET_EXERCISE_OBSERVATION">
  <app-widget
    android:identifier="GET_EXERCISE_OBSERVATION"
    android:targetClass="com.devrel.android.fitactions.widgets.StatsWidgetProvider"
    android:targetPackage="PUT_YOUR_APPLICATION_ID_HERE">
    <parameter
      android:name="exerciseObservation.aboutExercise.name"
      android:key="aboutExerciseName"
      android:required="true">
    </parameter>
    <extra android:name="hasTts" android:value="true"/>
  </app-widget>
  <!-- Add Fallback Intent-->
</capability>

Reemplaza el valor android:targetPackage, PUT_YOUR_APPLICATION_ID_HERE, por tu applicationId único.

Esta función asigna el BII GET_EXERCISE_OBSERVATION al intent app-widget, de modo que, cuando se activa el BII, el widget crea una instancia y se muestra al usuario.

Antes de activar el widget, Asistente extrae parámetros de BII admitidos de la búsqueda del usuario. Este codelab requiere el parámetro de BII exerciseObservation.aboutExercise.name, que representa el tipo de ejercicio solicitado por el usuario. La app admite tres tipos de ejercicios: "correr", "caminar" y "ciclismo". Proporciona un inventario intercalado para informar al Asistente sobre estos valores admitidos.

Para definir estos elementos de inventario, agrega la siguiente configuración a shortcuts.xml, arriba de la capacidad de GET_EXERCISE_OBSERVATION:

<!-- shortcuts.xml -->

<!-- shortcuts are bound to the GET_EXERCISE_OBSERVATION capability and
     represent the types of exercises supported by the app. -->

<shortcut
  android:shortcutId="running"
  android:shortcutShortLabel="@string/activity_running">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/runningSynonyms"/>
  </capability-binding>
</shortcut>

<shortcut
  android:shortcutId="walking"
  android:shortcutShortLabel="@string/activity_walking">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/walkingSynonyms"/>
  </capability-binding>
</shortcut>

<shortcut
  android:shortcutId="cycling"
  android:shortcutShortLabel="@string/activity_cycling">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/cyclingSynonyms"/>
  </capability-binding>
</shortcut>

<capability android:name="actions.intent.GET_EXERCISE_OBSERVATION">
  <!-- ... -->
</capability>

Cómo agregar un intent de resguardo

Los intents de resguardo controlan situaciones en las que una consulta de usuario no se puede completar porque en ella faltan parámetros que requiere la capacidad. La función GET_EXERCISE_OBSERVATION requiere el parámetro exerciseObservation.aboutExercise.name, especificado por el atributo android:required="true". En estos casos, Asistente requiere que definas un intent de resguardo para permitir que la solicitud se realice correctamente, incluso si no se proporcionan parámetros en la consulta.

En shortcuts.xml, agrega un intent de resguardo a la función GET_EXERCISE_OBSERVATION con esta configuración:

<!-- shortcuts.xml -->

<capability android:name="actions.intent.GET_EXERCISE_OBSERVATION">

  <app-widget>
    <!-- ... -->
  </app-widget>

  <!-- Fallback intent with no parameters needed to successfully execute.-->
  <intent
    android:identifier="GET_EXERCISE_OBSERVATION_FALLBACK"
    android:action="android.intent.action.VIEW"
    android:targetClass="com.devrel.android.fitactions.widgets.StatsWidgetProvider">
  </intent>
</capability>

En esta configuración de muestra, la entrega de resguardo es un intent de Android sin parámetros en sus datos de Extra.

5. Habilita el widget para Asistente

Con la función GET_EXERCISE_OBSERVATION establecida, actualiza la clase de widget para admitir la invocación de voz de Acciones en apps.

Cómo agregar la biblioteca de extensiones de widgets

La biblioteca de extensiones de widgets de Acciones en apps mejora tus widgets para las experiencias de Asistente de voz. Específicamente, te permite proporcionar una introducción a TTS personalizada para tus widgets.

Agrega la dependencia de la biblioteca de extensiones de widgets al recurso /app/build.gradle de la app de ejemplo:
```
// app/build.gradle

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
```
En el cuadro de advertencia que aparece en Android Studio, haz clic en Sync Now. La sincronización después de cada cambio build.gradle te ayuda a evitar errores durante la compilación de la app.

Un servicio es un componente de la aplicación que puede realizar operaciones de larga duración en segundo plano. Tu app debe brindar un servicio para procesar las solicitudes de widgets.

Agrega un servicio al recurso AndroidManifest.xml de la app de ejemplo con esta configuración:

<!-- AndroidManifest.xml -->
<service
   android:name=".widgets.StatsWidgetProvider"
   android:enabled="true"
   android:exported="true">
   <intent-filter>
       <action
           android:name="com.google.assistant.appactions.widgets.PIN_APP_WIDGET" />
   </intent-filter>
</service>

Durante una consulta por voz que activa la entrega del widget, Asistente usa este servicio para enviar solicitudes a la app. El servicio recibe la solicitud junto con los datos de BII. El servicio usa estos datos a fin de generar un objeto de widget RemoteView que renderizará en Asistente.

Ahora tu app está configurada para enrutar las solicitudes de capacidad GET_EXERCISE_OBSERVATION a la clase de tu widget. A continuación, actualiza la clase StatsWidget.kt a fin de generar una instancia de widget personalizada para la solicitud del usuario mediante valores de parámetros de BII.

Abre la clase StatsWidget.kt e importa la biblioteca de extensiones de widgets de Acciones en apps:

// StatsWidget.kt

// ... Other import statements
import com.google.assistant.appactions.widgets.AppActionsWidgetExtension

Agrega estas variables privadas, que usarás cuando determines la información que debe propagar el widget:

// StatsWidget.kt

private val hasBii: Boolean
private val isFallbackIntent: Boolean
private val aboutExerciseName: String
private val exerciseType: FitActivity.Type

Agrega la función init para permitir que la clase use los datos de opciones del widget que se pasan desde Asistente:

// StatsWidget.kt

init {
  val optionsBundle = appWidgetManager.getAppWidgetOptions(appWidgetId)
  val bii = optionsBundle.getString(AppActionsWidgetExtension.EXTRA_APP_ACTIONS_BII)
  hasBii = !bii.isNullOrBlank()
  val params = optionsBundle.getBundle(AppActionsWidgetExtension.EXTRA_APP_ACTIONS_PARAMS)

  if (params != null) {
    isFallbackIntent = params.isEmpty
    if (isFallbackIntent) {
      aboutExerciseName = context.resources.getString(R.string.activity_unknown)
    } else {
        aboutExerciseName = params.get("aboutExerciseName") as String
      }
  } else {
      isFallbackIntent = false
      aboutExerciseName = context.resources.getString(R.string.activity_unknown)
  }
  exerciseType = FitActivity.Type.find(aboutExerciseName)
}

Veamos cómo estas actualizaciones permiten que la clase StatsWidget.kt responda a los intents de Android generados por la capacidad GET_EXERCISE_OBSERVATION:

optionsBundle = Paquete
- Los paquetes son objetos diseñados para usarse entre límites de procesos, entre actividades con intents y para almacenar el estado transitorio en los cambios de configuración. Asistente usa objetos Bundle para pasar datos de configuración al widget.
bii = actions.intent.GET_EXERCISE_OBSERVATION
- El nombre de BII está disponible en el paquete mediante AppActionsWidgetExtension.
hasBii = true
- Comprueba si hay un BII.
params = Bundle[{aboutExerciseName=running}]
- Un paquete especial, generado por Acciones en apps, está anidado dentro de las opciones de widget Bundle. Contiene los pares clave-valor de BII. En este caso, se extrajo el valor running de la consulta de ejemplo "Hey Google, muestra mis estados en ejecución en AppdeEjemplo".
isFallbackIntent = false
- Comprueba la presencia de parámetros de BII obligatorios en el intent Extras.
aboutExerciseName = running
- Obtiene el valor Extras del intent para aboutExerciseName.
exerciseType = RUNNING
- Usa aboutExerciseName para buscar el objeto del tipo de base de datos correspondiente.

Ahora que la clase StatsWidget puede procesar datos de intents entrantes de Acciones en apps de Android, actualiza la lógica de creación del widget para verificar si una acción en la app activó el widget.

En StatsWidget.kt, reemplaza la función updateAppWidget() por este código:

// StatsWidget.kt

fun updateAppWidget() {
   /**
    * Checks for App Actions BII invocation and if BII parameter data is present.
    * If parameter data is missing, use data from last exercise recorded to the
    *  fitness tracking database.
    */
   if (hasBii && !isFallbackIntent) {
       observeAndUpdateRequestedExercise()
   } else observeAndUpdateLastExercise()
}

El código anterior hace referencia a una función nueva, observeAndUpdateRequestedExercise. Esta función genera datos del widget con los datos del parámetro exerciseType que pasa el intent de Android de Acciones en apps.

Agrega la función observeAndUpdateRequestedExercise con este código:

// StatsWidget.kt

/**
* Create and observe the last exerciseType activity LiveData.
*/
private fun observeAndUpdateRequestedExercise() {
  val activityData = repository.getLastActivities(1, exerciseType)

   activityData.observeOnce { activitiesStat ->
       if (activitiesStat.isNotEmpty()) {
           formatDataAndSetWidget(activitiesStat[0])
           updateWidget()
       } else {
           setNoActivityDataWidget()
           updateWidget()
       }
   }
}

En el código anterior, usa una clase de repositorio existente que se encuentra en la app para recuperar datos de actividad física de la base de datos local de la app. Esta clase proporciona una API que simplifica el acceso a la base de datos. El repositorio expone un objeto LiveData cuando se realizan consultas en la base de datos. En tu código, observa este LiveData para recuperar la actividad de entrenamiento más reciente.

Cómo habilitar TTS

Puedes proporcionar una string de TTS para que Asistente la anuncie cuando muestre tu widget. Se recomienda incluir esta string para brindar contexto audible con tus widgets. La funcionalidad de la biblioteca de extensiones de widgets de Acciones de apps te permite establecer las introducciones de texto y TTS que acompañan a los widgets en Asistente.

Un buen lugar para proporcionar tu introducción a TTS es la función formatDataAndSetWidget, que da formato a los datos de actividad que se muestran en la base de datos de la app.

En StatsWidget.kt, agrega este código a la función formatDataAndSetWidget:

// StatsWidget.kt

private fun formatDataAndSetWidget(
  activityStat: FitActivity,
) {
      // ...

      // Add conditional for hasBii for widget with data
      if (hasBii) {
         // Formats TTS speech and display text for Assistant
         val speechText = context.getString(
             R.string.widget_activity_speech,
             activityExerciseTypeFormatted,
             formattedDate,
             durationInMin,
             distanceInKm
         )
         val displayText = context.getString(
             R.string.widget_activity_text,
             activityExerciseTypeFormatted,
             formattedDate
         )
         setTts(speechText, displayText)
      }
}

El código anterior hace referencia a dos recursos de strings: uno para voz y otro para texto. Consulta la sección Recomendación de estilo de texto a voz de nuestro video sobre widgets para ver las recomendaciones de TTS. El ejemplo también hace referencia a setTts, una nueva función que proporciona la información de TTS a la instancia del widget.

Agrega esta nueva función setTts a StatsWidget.kt con este código:

// StatsWidget.kt

/**
 * Sets TTS to widget
 */
private fun setTts(
  speechText: String,
  displayText: String,
) {
  val appActionsWidgetExtension: AppActionsWidgetExtension =
      AppActionsWidgetExtension.newBuilder(appWidgetManager)
        .setResponseSpeech(speechText)  // TTS to be played back to the user
        .setResponseText(displayText)  // Response text to be displayed in Assistant
        .build()

  // Update widget with TTS
  appActionsWidgetExtension.updateWidget(appWidgetId)
}

Por último, completa la lógica de TTS estableciendo la información de TTS cuando la base de datos de ejercicios muestre datos vacíos para un tipo de entrenamiento solicitado.

Actualiza la función setNoActivityDataWidget() en StatsWidget.kt con este código:

// StatsWidget.kt

private fun setNoActivityDataWidget() {
  // ...
  // Add conditional for hasBii for widget without data
  if (hasBii) {
    // formats speech and display text for Assistant
    // https://developers.google.com/assistant/app/widgets#library
    val speechText =
      context.getString(R.string.widget_no_activity_speech, aboutExerciseName)
    val displayText =
      context.getString(R.string.widget_no_activity_text)

    setTts(speechText, displayText)
  }
}

6. Prueba las Acciones en apps

Durante la etapa de desarrollo, usa el complemento de Asistente de Google para obtener una vista previa de las Acciones en apps de Asistente en un dispositivo de prueba. Puedes ajustar los parámetros de intents de una Acción en la app con la herramienta a fin de probar cómo tu acción procesa las diferentes maneras en que un usuario puede pedirle a Asistente que la ejecute.

Cómo crear una vista previa

Para probar tu Acción en la app con el complemento, haz lo siguiente:

Ve a Tools > Google Assistant > App Actions Test Tool. Es posible que debas acceder a Android Studio. Si es así, usa la misma cuenta que utilizaste antes con Google Play Console.
Haz clic en Create Preview para generar una vista previa.

Cómo probar un tipo de ejercicio esperado

Sigue estos pasos en la herramienta de prueba para mostrar un widget que brinda información sobre la última ejecución realizada en la app:

En el primer paso, en el que la herramienta te solicitará que selecciones y configures un BII, selecciona actions.intent.GET_EXERCISE_OBSERVATION.
En el cuadro exerciseObservación, actualiza el nombre predeterminado del ejercicio de climbing a run.
Haz clic en Run App Action.

Cómo probar un tipo de ejercicio inesperado

Para probar un tipo de ejercicio inesperado en la herramienta de prueba:

En el cuadro exerciseObservation, actualiza el valor name de Run a Climbing.
Haz clic en Run App Action.

Asistente debería mostrar un widget con la información "No se encontró actividad".

Cómo probar el intent de resguardo

Las consultas que activan el intent de resguardo deben mostrar un widget con información sobre la última actividad registrada de cualquier tipo de ejercicio.

Para probar el intent de resguardo, haz lo siguiente:

En el cuadro exerciseObservation, borra el objeto aboutExercise.
Haz clic en Run App Action.

Asistente debería mostrar un widget con la información del último ejercicio completado.

7. Próximos pasos

Felicitaciones.

Ahora puedes entregar las consultas de los usuarios mediante un widget de Android con Asistente.

Temas abordados

En este codelab aprendiste a hacer lo siguiente:

Agregar un widget de la app a un BII
Modificar un widget para acceder a los parámetros desde Extras de Android

Próximos pasos

Desde aquí, puedes definir mejor tu app de fitness. Para hacer referencia al proyecto finalizado, consulta el repositorio principal en GitHub.

Estas son algunas sugerencias para descubrir más sobre el alcance extendido de esta app con Acciones en apps:

Visita la referencia de los intents integrados de Acciones en apps para descubrir más formas de extender tus apps a Asistente.

Para continuar tu recorrido de Actions on Google, explora los siguientes recursos:

developers.google.com/assistant/app: Sitio de documentación oficial sobre Acciones en apps de Asistente de Google
Índice de ejemplos de Acciones en apps: Código y apps de ejemplo para explorar las capacidades de Acciones en apps
Repositorio de GitHub de Actions on Google: Código de muestra y bibliotecas
r/GoogleAssistantDev: Comunidad oficial de Reddit para desarrolladores que trabajan con Asistente de Google

Síguenos en Twitter (@ActionsOnGoogle) para mantenerte al tanto de los anuncios más recientes y envía tuits con #appactions para compartir tu compilación.

Encuesta de opinión

Por último, completa esta encuesta a fin de enviar comentarios sobre tu experiencia con este codelab.