Intégrer des widgets Android à l'Assistant Google

1. Présentation

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

Les actions dans l'application permettent aux utilisateurs d'utiliser directement certaines fonctionnalités de l'application 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 permettant à l'utilisateur de répondre aux demandes des intents intégrés éligibles.

$Écran montrant l'Assistant renvoyant un widget en réponse \nà une requête de l'utilisateur ayant déclenché une capacité d'intent intégré GET_EXERCISE_OBSERVATION dans l'application.$

Objectifs de l'atelier

Dans cet atelier de programmation, vous apprendrez à renvoyer des widgets Android pour répondre aux requêtes utilisateur de l'Assistant. Vous apprendrez également à :

utiliser des paramètres d'intent intégré permettant de personnaliser les widgets ;
fournir une synthèse vocale (TTS) présentant les widgets dans l'Assistant ;
utiliser la documentation de référence sur les intents intégrés pour déterminer lesquels sont compatibles avec le traitement des widgets.

Conditions préalables

Avant de continuer, vérifiez que votre environnement est prêt pour le développement d'actions dans les applications. Il doit comporter :

un terminal permettant d'exécuter des commandes shell et avec git installé ;
la dernière version stable d'Android Studio ;
un appareil Android physique ou virtuel connecté à Internet ;
un compte Google connecté à Android Studio, à l'appli Google et à l'application Assistant Google.

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

2. Principes de fonctionnement

L'Assistant Google utilise la compréhension du langage naturel (NLU) pour lire la requête d'un utilisateur et l'associer à un intent intégré. Il mappe ensuite l'intent à la capacité (qui implémente l'intent intégré), que vous enregistrez pour cet intent dans votre application. Enfin, l'Assistant traite la demande de l'utilisateur en affichant le widget Android généré par votre application à l'aide des détails trouvés dans la capacité.

Dans cet atelier de programmation, vous allez définir une capacité qui enregistre la compatibilité avec l'intent intégré GET_EXERCISE_OBSERVATION. Dans cette capacité, vous allez demander à l'Assistant de générer un intent Android vers la classe de widget FitActions afin de répondre aux requêtes pour cet intent intégré. Vous allez modifier cette classe pour générer un widget personnalisé et une présentation par synthèse vocale que l'Assistant pourra présenter à l'utilisateur.

Le schéma suivant illustre ce flux :

L'application exemple FitActions contient un widget d'informations sur l'entraînement que les utilisateurs peuvent ajouter à leur écran d'accueil. Ce widget est idéal pour traiter les requêtes utilisateur qui déclenchent l'intent intégré GET_EXERCISE_OBSERVATION.

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 qui représente 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. Voici ses responsabilités :

Créer des instances de widget et les remplir à l'aide de données d'exercice provenant de la base de données de l'application
Mettre en forme les données d'entraînement pour une meilleure lisibilité, avec formatDataAndSetWidget()
Fournir des valeurs par défaut si les données d'entraînement ne sont pas disponibles, à l'aide de setNoActivityDataWidget()

Ajouter la compatibilité avec l'Assistant

Dans cet atelier de programmation, vous allez modifier l'application exemple pour qu'elle puisse gérer la fonctionnalité "Actions dans l'application". Vous allez entre autres :

configurer la capacité d'intent intégré GET_EXERCISE_OBSERVATION pour renvoyer une instance de l'objet StatsWidget ;
modifier la classe StatsWidget pour qu'elle utilise les fonctionnalités des actions dans les applications. Ces fonctionnalités sont les suivantes :
- Utiliser des paramètres d'intent intégré, qui permettent aux utilisateurs d'afficher des statistiques d'entraînement spécifiques en disant, par exemple, "Hey Google, affiche mes statistiques de course à pied sur 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ètre 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'exemple d'application :

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 dans Android Studio), cliquez sur Import project (Importer un projet).
Recherchez et sélectionnez le dossier dans lequel vous avez cloné le dépôt.

Pour voir une version de l'application telle qu'elle est à la fin de l'atelier de programmation, clonez le dépôt de l'exemple d'application à l'aide de l'indicateur --branch master.

Modifier l'ID d'application Android

Modifier l'ID de l'application permet d'identifier de manière unique l'application sur votre appareil de test et d'éviter une erreur "Duplicate package name" (Nom de package en double) si l'application est importée dans la Play Console. Pour modifier l'ID application, ouvrez app/build.gradle :

android {
...
  defaultConfig {
    applicationId "com.MYUNIQUENAME.android.fitactions"
    ...
  }
}

Dans le champ applicationId, remplacez "MYUNIQUENAME" par un nom qui vous est propre.

Installer le plug-in de test

Le plug-in Assistant Google vous permet de tester vos actions dans l'application sur un appareil de test. Le plug-in envoie des informations à l'Assistant via l'appli Google sur votre appareil Android. Si vous ne disposez pas encore du plug-in, procédez comme suit pour l'installer :

Accédez à File > Settings (Fichier > Paramètres), ou à Android Studio > Preferences (Android Studio > Préférences) sous macOS.
Dans la section "Plugins" (Plug-ins), accédez à Marketplace et recherchez "Google Assistant" (Assistant Google). 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 peut être utile de vous faire une idée des 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 Accueil pour configurer l'Assistant et vérifier qu'il fonctionne. Vous devrez vous connecter à l'Assistant sur votre appareil si ce n'est pas déjà fait.

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

Parcourez l'application pour en voir les fonctionnalités. Elle préremplit 10 activités sportives et affiche ces informations dans le premier affichage.

Appuyez sur le bouton 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'à trouver 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 capacité d'intent intégré GET_EXERCISE_OBSERVATION. Pour cela, ajoutez un nouvel élément capability dans shortcuts.xml. Cela définit comment la capacité 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 ressource shortcuts.xml du projet exemple 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é mappe l'intent intégré GET_EXERCISE_OBSERVATION sur l'intent app-widget. Ainsi, lorsque l'intent intégré est déclenché, le widget est instancié est visible par l'utilisateur.

Avant de déclencher le widget, l'Assistant extrait les paramètres d'intent intégré compatibles à partir de la requête de l'utilisateur. 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'exercice : "course", "marche" et "vélo". Vous fournissez un inventaire intégré pour que l'Assistant dispose de ces valeurs acceptées.

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 capacité. La capacité GET_EXERCISE_OBSERVATION nécessite le paramètre exerciseObservation.aboutExercise.name, spécifié par l'attribut android:required="true". Dans ces situations, l'Assistant exige que vous définissiez un intent de remplacement pour 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, le traitement 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 établie, modifiez 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. Plus précisément, elle vous permet de fournir une présentation personnalisée de vos widgets avec une synthèse vocale.

Ajoutez la dépendance de la bibliothèque d'extensions de widgets à la ressource /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'encadré d'avertissement qui s'affiche dans Android Studio. Synchroniser après chaque modification de build.gradle permet d'éviter les erreurs lorsque vous créez l'application.

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 widget.

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 le traitement du widget, l'Assistant utilise ce service pour envoyer des requêtes à l'application. Le service reçoit la requête ainsi que les données d'intent intégré. Le service utilise ces données pour générer un objet widget RemoteView à afficher dans l'Assistant.

Votre application est maintenant configurée pour acheminer les requêtes de capacité GET_EXERCISE_OBSERVATION vers votre classe de widget. La prochaine étape consiste à modifier la classe StatsWidget.kt pour générer une instance de widget personnalisée en fonction de la requête de l'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 vous permettent de déterminer les informations à insérer 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 permettre à la classe d'utiliser 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 modifications 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à des limites des processus, entre les activités avec des intents, et pour stocker un état temporaire lors des modifications 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 d'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 l'application, est imbriqué dans les options de widget Bundle. Il contient les paires clé/valeur de l'intent intégré. Dans ce cas, la valeur running a été extraite de l'exemple de requête, "Hey Google, montre-moi mes statistiques de course à pied sur ExampleApp".
isFallbackIntent = false
- Vérifie 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, modifiez la logique du flux de création de widgets pour vérifier si le widget a été déclenché par une action dans l'application.

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. Cette fonction génère des données de widget à l'aide des données de 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 repository existante qui se trouve dans l'application pour récupérer des données de fitness à partir de la base de données locale de l'application. Cette classe fournit une API qui simplifie l'accès à la base de données. Le dépôt fonctionne en exposant un objet LiveData lorsque vous interrogez la base de données. Dans votre code, vous observez ces LiveData pour récupérer la dernière activité physique.

Activer la synthèse vocale

Vous pouvez fournir une chaîne de synthèse vocale que l'Assistant lira lorsque vous afficherez votre widget. Nous vous recommandons d'inclure cette information 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.

La fonction formatDataAndSetWidget est idéale pour fournir cette présentation. Elle 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 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 : l'une pour la voix et l'autre pour le texte. Pour en savoir plus 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, terminez la logique de la synthèse vocale en définissant les informations correspondantes lorsque la base de données d'exercices renvoie des données vides pour un type d'entraînement demandé.

Modifiez 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 cet outil. Il permet de tester la manière 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 :

Accédez à Tools > Google Assistant > App Actions Test Tool (Outils > Assistant Google > Outil de test des actions dans l'application). Vous serez peut-être invité à vous connecter à Android Studio avec votre compte Google.
Cliquez sur Create Preview (Créer un aperçu). Si vous y êtes invité, lisez et acceptez les règles et les conditions d'utilisation des actions dans les applications.

Tester un type d'exercice attendu

Pour afficher un widget contenant des informations sur la dernière course dans l'application, procédez comme suit dans l'outil de test :

Lors de la première étape, quand 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 d'exercice par défaut climbing par run.
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 :

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

L'Assistant doit renvoyer un widget affichant 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 affichant des informations sur la dernière activité enregistrée pour tout type d'exercice.

Pour tester l'intent de remplacement :

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 terminé.

7. Étapes suivantes

Félicitations !

Vous pouvez désormais répondre aux requêtes des utilisateurs à l'aide d'un widget Android avec 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 "Extras" d'Android.

Étapes suivantes

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

Voici quelques suggestions pour en savoir plus sur l'intégration d'actions dans l'application :

Consultez la documentation de référence sur les intents intégrés concernant les actions dans les applications et découvrez d'autres façons d'intégrer l'Assistant à vos applications.

Pour poursuivre votre parcours Actions on Google, consultez les ressources suivantes :

developers.google.com/assistant/app : site de documentation officiel sur les actions dans l'application Assistant Google
Exemple d'index des actions dans l'application : exemples d'applications et de code pour découvrir les fonctionnalités des actions dans les applications
Dépôt GitHub sur Actions on Google : exemples de code et de bibliothèques
r/GoogleAssistantDev : communauté Reddit officielle des développeurs qui utilisent l'Assistant Google

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

Enquête

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

Intégrer des widgets Android à l'Assistant Google

1. Présentation

Objectifs de l'atelier

Conditions préalables

2. Principes de fonctionnement

Widget FitActions

Fonctionnement du widget

Ajouter la compatibilité avec l'Assistant

3. Préparer votre environnement de développement

Télécharger vos fichiers de base

Modifier l'ID d'application Android

Installer le plug-in de test

Tester l'application sur votre appareil

Essayer le widget existant

4. Ajouter l'action dans l'application

Ajouter un intent de remplacement

5. Activer le widget pour l'Assistant

Ajouter la bibliothèque d'extensions de widgets

Ajouter le service Widget

Modifier la classe de widget

Activer la synthèse vocale

6. Tester l'action dans l'application

Créer un aperçu

Tester un type d'exercice attendu

Tester un type d'exercice inattendu

Tester l'intent de remplacement

7. Étapes suivantes

Points abordés

Étapes suivantes

Intégrer des widgets Android à l'Assistant Google Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

1. Présentation

Objectifs de l'atelier

Conditions préalables

2. Principes de fonctionnement

Widget FitActions

Fonctionnement du widget

Ajouter la compatibilité avec l'Assistant

3. Préparer votre environnement de développement

Télécharger vos fichiers de base

Modifier l'ID d'application Android

Installer le plug-in de test

Tester l'application sur votre appareil

Essayer le widget existant

4. Ajouter l'action dans l'application

Ajouter un intent de remplacement

5. Activer le widget pour l'Assistant

Ajouter la bibliothèque d'extensions de widgets

Ajouter le service Widget

Modifier la classe de widget

Activer la synthèse vocale

6. Tester l'action dans l'application

Créer un aperçu

Tester un type d'exercice attendu

Tester un type d'exercice inattendu

Tester l'intent de remplacement

7. Étapes suivantes

Points abordés

Étapes suivantes

Intégrer des widgets Android à l'Assistant Google