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.
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 :
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 :
- Configurer l'intent intégré
GET_EXERCISE_OBSERVATION
pour renvoyer une instance de l'objetStatsWidget
- 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 :
- Dans la boîte de dialogue Welcome to Android Studio (Bienvenue sur Android Studio), cliquez sur Import project (Importer le projet).
- 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
).
- Dans
app/build.gradle
, saisissez unapplicationId
unique pourPUT_YOUR_APPLICATION_ID_HERE
, par exemplecom.codelabs.myname
. Pour en savoir plus sur les ID d'application Android, consultez l'article Définir l'ID d'application. - Ouvrez
app/src/res/xml/shortcuts.xml
et mettez à jour les deux instances deandroid:targetPackage
avec votreapplicationId
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 :
- Accédez à Build > Generate Signed Bundle / APK (Créer > Générer un app bundle/APK signé).
- Sélectionnez Android App Bundle, puis cliquez sur Next (Suivant).
- 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).
- Sélectionnez la variante de compilation
prodRelease
ourelease
, puis cliquez sur Finish (Terminer).
Dans la Play Console, importez l'app bundle que vous venez de créer en tant que nouvelle application :
- Sur la page Toutes les applications, cliquez sur Créer une application.
- Dans le champ Nom de l'application, saisissez un nom pour votre application, par exemple "Atelier de programmation Widget".
- Dans Application ou jeu, sélectionnez Application.
- Sous Application gratuite ou payante, sélectionnez Gratuite.
- Acceptez toutes les déclarations listées.
- Cliquez sur Créer l'application.
- Dans le menu latéral de la Play Console, accédez à Tests, puis ouvrez la page Tests internes.
- Sur cette page, cliquez sur Créer une release.
- Si vous y êtes invité, cliquez sur Continuer pour accepter la signature de l'application par Google Play.
- 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
ouapp/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 :
- Accédez à File > Settings (Fichier > Paramètres), ou à Android Studio > Preferences (Android Studio > Préférences) sous MacOs.
- Dans la section "Plugins", accédez à Marketplace et recherchez "Google Assistant". Vous pouvez également télécharger et installer manuellement l'outil de test.
- 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 :
- 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 (Exécuter) dans la barre d'outils.
- 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
- Appuyez sur le bouton Home (Accueil) pour accéder à l'écran d'accueil de votre appareil de test.
- Appuyez de manière prolongée sur un espace vide de l'écran d'accueil, puis sélectionnez Widgets.
- Faites défiler la liste de widgets jusqu'à FitActions.
- Appuyez de manière prolongée sur l'icône FitActions et placez son widget sur l'écran d'accueil.
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.
- Ajoutez un élément
capability
à la ressourceshortcuts.xml
de l'exemple de projet avec la configuration suivante :
Remplacez la valeur<!-- 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>
android:targetPackage
,PUT_YOUR_APPLICATION_ID_HERE
, par votreapplicationId
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.
- 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.
- 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.
- Ajoutez la dépendance de la bibliothèque d'extensions de widgets à la
/app/build.gradle
de l'application exemple :
Cliquez sur Sync Now (Synchroniser) dans l'avertissement qui s'affiche dans Android Studio. Procéder à la synchronisation après chaque modification de// app/build.gradle dependencies { //... implementation "com.google.assistant.appactions:widgets:0.0.1" }
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.
- 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é.
- 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
- 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
- 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.
- 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
bii
=actions.intent.GET_EXERCISE_OBSERVATION
- Le nom de l'intent intégré est disponible dans le bundle à l'aide de
AppActionsWidgetExtension
.
- Le nom de l'intent intégré est disponible dans le bundle à l'aide de
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 valeurrunning
a été extraite de l'exemple de requête "Hey Google, affiche mes statistiques de course à pied sur ExampleApp".
- Un bundle spécial, généré par les actions dans les applications, est imbriqué dans les options du widget
isFallbackIntent
=false
- Recherche la présence des paramètres d'intent intégré requis dans l'intent
Extras
.
- Recherche la présence des paramètres d'intent intégré requis dans l'intent
aboutExerciseName
=running
- Récupère la valeur d'intent
Extras
pouraboutExerciseName
.
- Récupère la valeur d'intent
exerciseType
=RUNNING
- Utilise
aboutExerciseName
pour rechercher l'objet de type de base de données correspondant.
- Utilise
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.
- Dans
StatsWidget.kt
, remplacez la fonctionupdateAppWidget()
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.
- 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.
- Dans
StatsWidget.kt
, ajoutez le code suivant à la fonctionformatDataAndSetWidget
:// 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.
- 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é.
- Mettez à jour la fonction
setNoActivityDataWidget()
dansStatsWidget.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 :
- 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.
- 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 :
- À 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
. - Dans le champ exerciseObservation, remplacez le nom par défaut de l'exercice
climbing
parrun
. - Cliquez sur Run App Action (Exécuter l'action dans l'application).
Tester un type d'exercice inattendu
Pour tester un type d'exercice inattendu dans l'outil de test, procédez comme suit :
- Dans le champ exerciseObservation, remplacez la valeur
Run
dename
parClimbing
. - 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".
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 :
- Dans le champ exerciseObservation, supprimez l'objet
aboutExercise
. - 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é.
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 :
- Consultez la documentation de référence sur les intents intégrés aux actions dans l'application pour découvrir d'autres moyens d'intégrer l'Assistant à vos applications.
Pour continuer à explorer Actions on Google, consultez les ressources suivantes :
- developers.google.com/assistant/app : site officiel de documentation sur les actions dans l'application Assistant Google
- Index d'exemples d'actions dans les applications : exemples d'applications et de code pour explorer les fonctionnalités des actions dans les applications
- Dépôt Actions on Google sur GitHub : exemples de code et de bibliothèques
- r/GoogleAssistantDev : communauté Reddit officielle des développeurs qui travaillent sur l'Assistant Google
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.