Intégrer des widgets Android à l'Assistant Google

1. Présentation

Dans le premier atelier de programmation sur les actions dans les applications, vous avez appris à intégrer à l'Assistant Google un exemple d'application de fitness en implémentant des intents intégrés de la catégorie "Santé et remise en forme".

Les actions dans les applications permettent aux utilisateurs de lancer directement des fonctionnalités d'application spécifiques depuis l'Assistant en disant, par exemple, "Hey Google, lance ExempleApp". En plus de lancer des applications, l'Assistant peut afficher un widget Android interactif pour exécuter les demandes pour des intents intégrés éligibles.

Écran montrant l'Assistant affichant un widget en réponse à une requête\nd'un utilisateur qui a déclenché la fonctionnalité d'intent intégré GET_EXERCISE_OBSERVATION d'une application

Ce que vous allez faire

Dans cet atelier de programmation, vous allez apprendre à afficher des widgets Android pour répondre aux requêtes que l'utilisateur adresse à l'Assistant. Vous allez également apprendre à réaliser les opérations suivantes :

  • Personnaliser des widgets grâce aux paramètres d'intents intégrés
  • Fournir des présentations par synthèse vocale dans l'Assistant pour vos widgets
  • Utiliser les références sur les intents intégrés pour identifier les intents intégrés compatibles avec l'exécution du widget

Conditions préalables

Avant de continuer, assurez-vous que votre environnement de développement est prêt pour développer des actions dans les applications. Il doit comporter les éléments suivants :

  • Un terminal permettant d'exécuter des commandes d'interface système, avec Git installé
  • La dernière version stable d'Android Studio
  • Un appareil Android physique ou virtuel avec accès à Internet
  • Un compte Google connecté à Android Studio, l'appli Google et l'appli Assistant Google

Si vous utilisez un appareil physique, connectez-le à votre ordinateur de développement local.

2. Comprendre le fonctionnement

L'Assistant Google utilise la NLU (Natural Language Understanding, compréhension du langage naturel) pour lire la requête d'un utilisateur et l'associer à un intent intégré à l'Assistant. L'Assistant associe ensuite l'intent à la fonctionnalité (qui implémente l'intent intégré), que vous enregistrez pour cet intent dans votre application. Enfin, l'Assistant exécute la requête de l'utilisateur et affiche le widget Android que votre application génère à l'aide des informations dans la fonctionnalité.

Dans cet atelier de programmation, vous allez définir une fonctionnalité qui enregistre la prise en charge de l'intent intégré GET_EXERCISE_OBSERVATION. Dans cette fonctionnalité, vous demandez à l'Assistant de générer un intent Android dans la classe de widget FitActions pour exécuter les requêtes de cet intent intégré. Vous allez mettre à jour cette classe afin de générer un widget personnalisé que l'Assistant pourra présenter à l'utilisateur ainsi qu'une présentation par synthèse vocale que l'Assistant prononcera.

Le schéma suivant illustre le déroulement de ce processus :

Schéma illustrant l'exécution d'un widget par l'Assistant

Widget FitActions

L'application exemple FitActions contient un widget que les utilisateurs peuvent ajouter à leur écran d'accueil pour afficher des informations sur leurs entraînements. Ce widget est parfait pour illustrer l'exécution de requêtes utilisateur déclenchant l'intent intégré GET_EXERCISE_OBSERVATION.

Fonctionnement du widget

Lorsqu'un utilisateur ajoute un widget à l'écran d'accueil, le widget pingue le broadcast receiver de l'appareil. Ce service récupère des informations sur le widget à partir de la définition du récepteur du widget dans la ressource AndroidManifest.xml de l'application. Il utilise ces informations pour générer un objet RemoteViews représentant le widget.

L'application exemple définit le récepteur widgets.StatsWidgetProvider, qui correspond à la classe 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 classe StatsWidgetProvider, StatsWidgetProvider.kt, gère les flux de création d'objets StatsWidget. Elle gère également les responsabilités suivantes :

  • Créer des instances de widget et les renseigner à l'aide des données d'exercices issues de la base de données de l'application
  • Mettre en forme les données d'entraînement avec formatDataAndSetWidget() pour qu'elles soient lisibles
  • Fournir des valeurs par défaut avec setNoActivityDataWidget() si les données sur les entraînements ne sont pas disponibles

Ajouter la prise en charge de l'Assistant

Dans cet atelier de programmation, vous allez mettre à jour l'application exemple pour gérer la fonctionnalité Actions dans les applications. Ces modifications comprennent les opérations suivantes :

  1. Configurer l'intent intégré GET_EXERCISE_OBSERVATION pour renvoyer une instance de l'objet StatsWidget
  2. Mettre à jour la classe StatsWidget pour utiliser les fonctionnalités des actions dans les applications telles que :
    • Utiliser les paramètres d'intent intégré pour permettre aux utilisateurs d'afficher des statistiques spécifiques sur leurs séances d'entraînement en disant, par exemple "Hey Google, affiche mes statistiques de course à pied sur de ExampleApp".
    • Fournir des chaînes de présentation par synthèse vocale
    • Gérer des cas particuliers, par exemple lorsque la requête de l'utilisateur n'inclut pas de paramètres de type d'entraînement

3. Préparer votre environnement de développement

Télécharger vos fichiers de base

Exécutez la commande suivante pour cloner le dépôt GitHub de l'application exemple :

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

Une fois le dépôt cloné, procédez comme suit pour l'ouvrir dans Android Studio :

  1. Dans la boîte de dialogue Welcome to Android Studio (Bienvenue sur Android Studio), cliquez sur Import project (Importer le projet).
  2. Recherchez et sélectionnez le dossier dans lequel vous avez cloné le dépôt.

Pour afficher la version de l'application que vous obtiendrez à la fin de cet atelier de programmation, clonez le dépôt de l'application exemple à l'aide de l'indicateur --branch master.

Modifier l'identifiant d'application Android

Plus tard dans cet atelier de programmation, vous allez utiliser le plug-in Assistant Google pour tester vos actions sur un appareil physique ou virtuel. Pour que l'outil de test fonctionne, vous devez d'abord importer votre application dans un projet de la Google Play Console. Pour éviter une erreur du type "Duplicate package name" (Nom de package en double) lors de l'importation de l'application dans la Play Console, utilisez un identifiant unique pour l'applicationId de l'application exemple (Google Play n'autorise pas le téléchargement de deux applications ayant le même applicationId).

  1. Dans app/build.gradle, saisissez un applicationId unique pour PUT_YOUR_APPLICATION_ID_HERE, par exemple com.codelabs.myname. Pour en savoir plus sur les ID d'application Android, consultez l'article Définir l'ID d'application.
  2. Ouvrez app/src/res/xml/shortcuts.xml et mettez à jour les deux instances de android:targetPackage avec votre applicationId unique.

Effectuer l'importation dans la Play Console

Vous devez impérativement importer l'application dans un projet de la Google Play Console pour pouvoir utiliser le plug-in Assistant Google dans Android Studio. Créez votre application dans Android Studio et importez-la dans la Play Console en tant que version brouillon interne.

Pour créer votre application dans Android Studio :

  1. Accédez à Build > Generate Signed Bundle / APK (Créer > Générer un app bundle/APK signé).
  2. Sélectionnez Android App Bundle, puis cliquez sur Next (Suivant).
  3. Saisissez les informations pour signer votre application, puis cliquez sur Next (Suivant). Notez le chemin d'accès à votre bundle dans la section Destination Folder (Dossier de destination).
  4. Sélectionnez la variante de compilation prodRelease ou release, puis cliquez sur Finish (Terminer).

Dans la Play Console, importez l'app bundle que vous venez de créer en tant que nouvelle application :

  1. Sur la page Toutes les applications, cliquez sur Créer une application.
  2. Dans le champ Nom de l'application, saisissez un nom pour votre application, par exemple "Atelier de programmation Widget".
  3. Dans Application ou jeu, sélectionnez Application.
  4. Sous Application gratuite ou payante, sélectionnez Gratuite.
  5. Acceptez toutes les déclarations listées.
  6. Cliquez sur Créer l'application.
  7. Dans le menu latéral de la Play Console, accédez à Tests, puis ouvrez la page Tests internes.
  8. Sur cette page, cliquez sur Créer une release.
  9. Si vous y êtes invité, cliquez sur Continuer pour accepter la signature de l'application par Google Play.
  10. Dans le panneau App bundles et APK, importez le fichier AAB que vous avez généré à l'étape précédente. Ce fichier se trouve généralement dans le répertoire app/prod/release ou app/release de votre projet. Cliquez sur Enregistrer.

Installer le plug-in de test

Le plug-in Assistant Google vous permet de tester vos actions dans les applications sur un appareil de test. Pour cela, il envoie des informations à l'Assistant via l'appli Google sur votre appareil Android. Si vous ne l'avez pas encore installé, faites-le maintenant :

  1. Accédez à File > Settings (Fichier > Paramètres), ou à Android Studio > Preferences (Android Studio > Préférences) sous MacOs.
  2. Dans la section "Plugins", accédez à Marketplace et recherchez "Google Assistant". Vous pouvez également télécharger et installer manuellement l'outil de test.
  3. Installez l'outil, puis redémarrez Android Studio.

Tester l'application sur votre appareil

Avant d'apporter d'autres modifications à l'application, il est utile de tester les fonctionnalités de l'application exemple.

Exécutez l'application sur votre appareil de test :

  1. Dans Android Studio, sélectionnez votre appareil physique ou virtuel, puis sélectionnez Run > Run app (Exécuter > Exécuter l'application), ou cliquez sur Run Icône &quot;Run app&quot; (Exécuter l&#39;application) dans Android Studio. (Exécuter) dans la barre d'outils.
  2. Appuyez de manière prolongée sur le bouton d'accueil pour configurer l'Assistant et vérifier qu'il fonctionne. Si ce n'est pas déjà fait, vous devez vous connecter à l'Assistant sur votre appareil.

Pour en savoir plus sur les appareils virtuels Android, consultez la page Créer et gérer des appareils virtuels.

Explorez rapidement les fonctionnalités de l'application. L'application préremplit 10 activités sportives et affiche ces informations dans la première vue.

Essayer le widget existant

  1. Appuyez sur le bouton Home (Accueil) pour accéder à l'écran d'accueil de votre appareil de test.
  2. Appuyez de manière prolongée sur un espace vide de l'écran d'accueil, puis sélectionnez Widgets.
  3. Faites défiler la liste de widgets jusqu'à FitActions.
  4. Appuyez de manière prolongée sur l'icône FitActions et placez son widget sur l'écran d'accueil.

Capture d&#39;écran montrant le widget FitActions sur l&#39;écran d&#39;accueil de l&#39;appareil.

4. Ajouter l'action dans l'application

Au cours de cette étape, vous allez ajouter la fonctionnalité d'intent intégré GET_EXERCISE_OBSERVATION. Pour cela, ajoutez un nouvel élément capability dans shortcuts.xml. Cette fonctionnalité indique comment elle est déclenchée, comment les paramètres d'intent intégré sont utilisés et quels intents Android doivent être appelés pour traiter la requête.

  1. Ajoutez un élément capability à la ressource shortcuts.xml de l'exemple de projet avec la configuration suivante :
    <!-- 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>
    
    Remplacez la valeur android:targetPackage, PUT_YOUR_APPLICATION_ID_HERE, par votre applicationId unique.

Cette fonctionnalité associe l'intent intégré GET_EXERCISE_OBSERVATION à l'intent app-widget. Ainsi, lorsque l'intent intégré est déclenché, le widget est instancié et s'affiche.

Avant de déclencher le widget, l'Assistant extrait de la requête de l'utilisateur les paramètres d'intent intégré compatibles. Cet atelier de programmation nécessite le paramètre d'intent intégré exerciseObservation.aboutExercise.name, qui représente le type d'exercice demandé par l'utilisateur. L'application accepte trois types d'activités sportives : course à pied, marche et vélo. Vous fournissez un inventaire intégré pour informer l'Assistant de ces valeurs.

  1. Définissez ces éléments d'inventaire en ajoutant cette configuration, au-dessus de la fonctionnalité GET_EXERCISE_OBSERVATION, à shortcuts.xml :
    <!-- 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>
    

Ajouter un intent de remplacement

Les intents de remplacement gèrent les cas où une requête utilisateur ne peut pas être traitée, car il manque des paramètres requis par la fonctionnalité. La fonctionnalité GET_EXERCISE_OBSERVATION nécessite le paramètre exerciseObservation.aboutExercise.name, spécifié par l'attribut android:required="true". Pour ces cas, l'Assistant exige que vous définissiez un intent de remplacement afin que la requête aboutisse même si aucun paramètre n'est fourni dans la requête.

  1. Dans shortcuts.xml, ajoutez un intent de remplacement à la fonctionnalité GET_EXERCISE_OBSERVATION à l'aide de la configuration suivante :
    <!-- 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>
    

Dans cet exemple de configuration, l'intent de remplacement est un intent Android dont les données Extra ne contiennent aucun paramètre.

5. Activer le widget pour l'Assistant

Une fois la fonctionnalité GET_EXERCISE_OBSERVATION configurée, mettez à jour la classe de widget pour qu'elle accepte l'appel vocal "Actions dans les applications".

Ajouter la bibliothèque d'extensions de widgets

La bibliothèque d'extensions de widgets pour les actions dans les applications améliore vos widgets pour les expériences vocales avec l'Assistant. Elle vous permet plus particulièrement de personnaliser la présentation par synthèse vocale de vos widgets.

  1. Ajoutez la dépendance de la bibliothèque d'extensions de widgets à la /app/build.gradle de l'application exemple :
    // app/build.gradle
    
    dependencies {
      //...
      implementation "com.google.assistant.appactions:widgets:0.0.1"
    }
    
    Cliquez sur Sync Now (Synchroniser) dans l'avertissement qui s'affiche dans Android Studio. Procéder à la synchronisation après chaque modification de build.gradle permet d'éviter les erreurs lors de la création de l'appli.

Ajouter le service du widget

Un service est un composant d'application qui peut exécuter des opérations de longue durée en arrière-plan. Votre application doit fournir un service pour traiter les requêtes de widgets.

  1. Ajoutez un service à la ressource AndroidManifest.xml de l'application exemple à l'aide de la configuration suivante :
    <!-- 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>
    
    

Lors d'une requête vocale qui déclenche l'exécution du widget, l'Assistant utilise ce service pour envoyer la requête à l'application. Le service reçoit la requête ainsi que les données d'intent intégré. Grâce à ces données, il génère un objet de widget RemoteView à afficher dans l'Assistant.

Mettre à jour la classe du widget

Votre application est maintenant configurée pour transmettre les requêtes de la fonctionnalité GET_EXERCISE_OBSERVATION à votre classe de widget. À présent, mettez à jour la classe StatsWidget.kt pour générer une instance de widget personnalisée en fonction de la requête utilisateur, à l'aide des valeurs de paramètre d'intent intégré.

  1. Ouvrez la classe StatsWidget.kt et importez la bibliothèque d'extensions de widgets d'actions dans les applications :
    // StatsWidget.kt
    
    // ... Other import statements
    import com.google.assistant.appactions.widgets.AppActionsWidgetExtension
    
    
  2. Ajoutez ces variables privées, qui permettent de déterminer les informations à inclure dans le widget :
    // StatsWidget.kt
    
    private val hasBii: Boolean
    private val isFallbackIntent: Boolean
    private val aboutExerciseName: String
    private val exerciseType: FitActivity.Type
    
  3. Ajoutez la fonction init pour que la classe utilise les données des options du widget transmises par l'Assistant :
    // 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)
    }
    
    

Voyons comment ces mises à jour permettent à la classe StatsWidget.kt de répondre aux intents Android générés par la fonctionnalité GET_EXERCISE_OBSERVATION :

  • optionsBundle = Bundle
    • Les bundles sont des objets conçus pour être utilisés au-delà les limites des processus, entre les activités avec des intents, et pour stocker un état temporaire lors d'une modification de configuration. L'Assistant utilise des objets Bundle pour transmettre les données de configuration au widget.
  • bii = actions.intent.GET_EXERCISE_OBSERVATION
    • Le nom de l'intent intégré est disponible dans le bundle à l'aide de AppActionsWidgetExtension.
  • hasBii = true
    • Vérifie s'il existe un intent intégré.
  • params = Bundle[{aboutExerciseName=running}]
    • Un bundle spécial, généré par les actions dans les applications, est imbriqué dans les options du widget Bundle. Il contient les paires clé/valeur de l'intent intégré. Dans le cas présent, la valeur running a été extraite de l'exemple de requête "Hey Google, affiche mes statistiques de course à pied sur ExampleApp".
  • isFallbackIntent = false
    • Recherche la présence des paramètres d'intent intégré requis dans l'intent Extras.
  • aboutExerciseName = running
    • Récupère la valeur d'intent Extras pour aboutExerciseName.
  • exerciseType = RUNNING
    • Utilise aboutExerciseName pour rechercher l'objet de type de base de données correspondant.

Maintenant que la classe StatsWidget peut traiter les données d'intent Android Actions dans les applications entrantes, mettez à jour la logique du flux de création du widget pour vérifier si le widget a été déclenché par une action dans l'application.

  1. Dans StatsWidget.kt, remplacez la fonction updateAppWidget() par ce code :
    // 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()
    }
    
    

Le code précédent fait référence à une nouvelle fonction, observeAndUpdateRequestedExercise. Celle-ci génère les données du widget à l'aide des données du paramètre exerciseType transmises par l'intent Android Actions dans les applications.

  1. Ajoutez la fonction observeAndUpdateRequestedExercise avec le code suivant :
    // 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()
           }
       }
    }
    
    

Dans le code précédent, utilisez une classe de dépôt existante de l'application pour récupérer des données de fitness depuis la base de données locale de l'application. Cette classe fournit une API simplifiant l'accès à la base de données. Le dépôt fonctionne en exposant un objet LiveData lors de l'exécution de requêtes à partir de la base de données. Dans votre code, vous pouvez constater que cet objet LiveData récupère la dernière activité physique.

Activer la synthèse vocale

Vous pouvez fournir une chaîne de synthèse vocale que l'Assistant doit prononcer lorsqu'il affiche votre widget. Nous vous recommandons d'inclure cette présentation pour fournir un contexte sonore à vos widgets. Cette fonctionnalité est fournie par la bibliothèque d'extensions de widgets d'actions dans les applications, qui vous permet de définir le texte et les présentations par synthèse vocale qui accompagnent vos widgets dans l'Assistant.

Vous pouvez indiquer vos présentations par synthèse vocale dans la fonction formatDataAndSetWidget, qui met en forme les données d'activité renvoyées par la base de données de l'application.

  1. Dans StatsWidget.kt, ajoutez le code suivant à la fonction 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)
          }
    }
    
    

Le code précédent fait référence à deux ressources de chaîne : une pour la voix et l'autre pour le texte. Pour des recommandations sur la synthèse vocale, consultez la section Recommandations de style pour la synthèse vocale de notre vidéo sur les widgets. L'exemple fait également référence à setTts, une nouvelle fonction qui fournit les informations de synthèse vocale à l'instance de widget.

  1. Ajoutez cette nouvelle fonction setTts à StatsWidget.kt à l'aide du code suivant :
    // 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)
    }
    

Enfin, pour terminer la logique de synthèse vocale, définissez les informations de synthèse vocale lorsque la base de données d'exercices renvoie des données vides pour un type d'entraînement demandé.

  1. Mettez à jour la fonction setNoActivityDataWidget() dans StatsWidget.kt avec le code suivant :
    // 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. Tester l'action dans l'application

Pendant le développement, utilisez le plug-in Assistant Google pour prévisualiser les actions dans l'application de l'Assistant sur un appareil de test. Vous pouvez ajuster les paramètres d'intent pour une action dans l'application à l'aide de l'outil afin de tester la façon dont votre action gère les différentes manières dont un utilisateur peut demander à l'Assistant de l'exécuter.

Créer un aperçu

Pour tester votre action dans l'application avec le plug-in, procédez comme suit :

  1. Accédez à Tools > Google Assistant > App Actions Test Tool (Outils > Assistant Google > Outil de test des actions dans les applications). Vous serez peut-être invité à vous connecter à Android Studio. Si c'est le cas, utilisez le même compte que celui utilisé précédemment dans la Google Play Console.
  2. Cliquez sur Create Preview (Créer un aperçu) pour créer un aperçu.

Tester un type d'exercice attendu

Pour afficher un widget contenant les informations de la dernière course enregistrée dans l'application, suivez cette procédure dans l'outil de test :

  1. À la première étape, lorsque l'outil vous demande de sélectionner et de configurer un intent intégré, sélectionnez actions.intent.GET_EXERCISE_OBSERVATION.
  2. Dans le champ exerciseObservation, remplacez le nom par défaut de l'exercice climbing par run.
  3. Cliquez sur Run App Action (Exécuter l'action dans l'application).

Écran affichant un widget renvoyé à l&#39;aide du plug-in Assistant Google.

Tester un type d'exercice inattendu

Pour tester un type d'exercice inattendu dans l'outil de test, procédez comme suit :

  1. Dans le champ exerciseObservation, remplacez la valeur Run de name par Climbing.
  2. Cliquez sur Run App Action (Exécuter l'action dans l'application).

L'Assistant doit renvoyer le widget avec le message "Aucune activité trouvée".

Écran affichant un widget renvoyé sans informations d&#39;exercice à l&#39;aide du plug-in Assistant Google.

Tester l'intent de remplacement

Les requêtes qui déclenchent l'intent de remplacement doivent renvoyer un widget contenant des informations sur la dernière activité enregistrée pour n'importe quel type d'exercice.

Pour tester l'intent de remplacement, procédez comme suit :

  1. Dans le champ exerciseObservation, supprimez l'objet aboutExercise.
  2. Cliquez sur Run App Action (Exécuter l'action dans l'application).

L'Assistant doit renvoyer un widget contenant des informations sur le dernier exercice réalisé.

Écran montrant un widget qui affiche la dernière activité enregistrée à l&#39;aide du plug-in Assistant Google.

7. Étapes suivantes

Félicitations !

Vous pouvez désormais répondre aux requêtes des utilisateurs via un widget Android sur l'Assistant.

Points abordés

Dans cet atelier de programmation, vous avez appris à :

  • Ajouter un widget d'application à un intent intégré
  • Modifier un widget pour accéder aux paramètres de fonctionnalités supplémentaires depuis Android Extras

Étapes suivantes

À présent, vous pouvez essayer de peaufiner votre application de fitness. Pour référencer le projet terminé, consultez le dépôt principal sur GitHub.

Voici quelques suggestions pour vous aider à développer cette application avec des actions dans l'application :

Pour continuer à explorer Actions on Google, consultez les ressources suivantes :

Suivez-nous sur Twitter (@ActionsOnGoogle) pour connaître les dernières informations, et envoyez un tweet à #appactions pour montrer votre création.

Enquête

Enfin, veuillez répondre à cette enquête pour nous faire part de vos commentaires sur cet atelier de programmation.