Android-Widgets in Google Assistant einbinden

1. Übersicht

Im ersten App Actions-Codelab hast du gelernt, wie du Google Assistant auf eine Beispiel-Fitness-App erweitern kannst, indem du integrierte Intents (integrierte Intents) aus der Kategorie „Gesundheit und Fitness“ (BII) implementiert hast.

Mit App Actions können Nutzer bestimmte App-Funktionen direkt von Assistant aus starten, indem sie z. B. sagen: „Hey Google, Lauf in ExampleApp starten“. Assistant kann nicht nur Apps starten, sondern dem Nutzer auch ein interaktives Android-Widget anzeigen, um Anfragen nach geeigneten BIIs auszuführen.

Ein Bildschirm, auf dem Assistant ein Widget als Antwort auf eine Nutzeranfrage zurückgibt, die die BII-Funktion GET_EXERCISE_OBSERVATION für Apps ausgelöst hat.

Aufgaben

In diesem Codelab erfährst du, wie du Android-Widgets zurückgeben kannst, um Anfragen von Assistant-Nutzern zu erfüllen. Außerdem lernen Sie:

  • BII-Parameter verwenden, um Widgets zu personalisieren.
  • Stellen Sie in Assistant Einführungen in die Sprachausgabe für Ihre Widgets bereit.
  • Ermitteln Sie anhand der Referenz zu integrierten Intents, welche BIIs die Widget-Auftragsausführung unterstützen.

Vorbereitung

Bevor du fortfährst, muss deine Entwicklungsumgebung für die App Actions-Entwicklung bereit sein. Sie sollte Folgendes enthalten:

  • Ein Terminal zum Ausführen von Shell-Befehlen, auf dem Git installiert ist.
  • Die neueste stabile Version von Android Studio.
  • Ein physisches oder virtuelles Android-Gerät mit Internetzugang
  • Ein Google-Konto, mit dem Sie in Android Studio, in der Google App und in der Google Assistant App angemeldet sind.

Wenn Sie ein physisches Gerät verwenden, verbinden Sie es mit Ihrem lokalen Entwicklungscomputer.

2. Funktionsweise

Google Assistant verwendet Natural Language Understanding (NLU), um die Anfrage eines Nutzers zu lesen und einem integrierten Assistant (BII) zuzuordnen. Assistant ordnet den Intent dann der Funktion zu (die den BII implementiert), die Sie für diesen Intent in Ihrer App registrieren. Schließlich erfüllt Assistant die Anfrage des Nutzers, indem er das Android-Widget anzeigt, das Ihre App anhand der in der Funktion gefundenen Details generiert.

In diesem Codelab definieren Sie eine Funktion, die die Unterstützung für den BII GET_EXERCISE_OBSERVATION registriert. Bei dieser Funktion weisen Sie Assistant an, einen Android-Intent für die Widget-Klasse FitActions zu generieren, um Anfragen für diesen BII auszuführen. Du aktualisierst diesen Kurs, um ein personalisiertes Widget zu erstellen, das Assistant dem Nutzer anzeigen kann, sowie eine Sprachausgabe-Einführung, die Assistant ankündigt.

Das folgende Diagramm veranschaulicht diesen Ablauf:

Ein Flussdiagramm, das die Ausführung eines Assistant-Widgets zeigt.

Das FitActions-Widget

Die FitActions-Beispiel-App enthält ein Widget mit Trainingsinformationen, das Benutzer zu ihrem Startbildschirm hinzufügen können. Dieses Widget eignet sich hervorragend zur Erfüllung von Nutzeranfragen, die den BII GET_EXERCISE_OBSERVATION auslösen.

Funktionsweise des Widgets

Wenn ein Nutzer dem Startbildschirm ein Widget hinzufügt, pingt das Widget den Broadcast-Empfänger des Geräts an. Dieser Dienst ruft Informationen zum Widget aus der Empfängerdefinition des Widgets in der AndroidManifest.xml-Ressource der App ab. Anhand dieser Informationen wird ein RemoteViews-Objekt generiert, das das Widget darstellt.

Die Beispielanwendung definiert den Empfänger widgets.StatsWidgetProvider, der der Klasse StatsWidgetProvider entspricht:

<!-- 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>

Die Klasse StatsWidgetProvider, StatsWidgetProvider.kt, verwaltet die Abläufe zur Objekterstellung StatsWidget. Er übernimmt die folgenden Aufgaben:

  • Widget-Instanzen erstellen und mit Trainingsdaten aus der App-Datenbank füllen
  • Trainingsdaten werden mit formatDataAndSetWidget() zur besseren Lesbarkeit formatiert.
  • Mit setNoActivityDataWidget() werden Standardwerte angegeben, wenn keine Trainingsdaten verfügbar sind.

Assistant-Unterstützung hinzufügen

In diesem Codelab aktualisieren Sie die Beispiel-App so, dass sie die App Actions-Funktionen verarbeitet. Zu diesen Änderungen gehören:

  1. BII-Funktion GET_EXERCISE_OBSERVATION konfigurieren, um eine Instanz des StatsWidget-Objekts zurückzugeben.
  2. Die StatsWidget-Klasse aktualisieren, um App Actions-Funktionen wie die folgenden zu verwenden:
    • Mithilfe von BII-Parametern können Nutzer bestimmte Trainingsstatistiken aufrufen, indem sie beispielsweise fragen: „Hey Google, zeig meine Laufstatistiken in ExampleApp an.“
    • Einleitungsstrings für die Sprachausgabe
    • Verwaltung von Sonderfällen, z. B. wenn die Nutzeranfrage keinen Workout-Typ-Parameter enthält.

3. Bereiten Sie Ihre Entwicklungsumgebung vor

Basisdateien herunterladen

Führen Sie den folgenden Befehl aus, um das GitHub-Repository der Beispiel-App zu klonen:

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

Gehen Sie nach dem Klonen des Repositorys folgendermaßen vor, um es in Android Studio zu öffnen:

  1. Klicken Sie im Dialogfeld „Willkommen bei Android Studio“ auf Projekt importieren.
  2. Wählen Sie den Ordner aus, in den Sie das Repository geklont haben.

Wenn Sie eine Version der Anwendung sehen möchten, die das abgeschlossene Codelab darstellt, klonen Sie das Repository der Beispielanwendung mit dem Flag --branch master.

Android-App-ID aktualisieren

Durch die Aktualisierung der App-ID wird die App auf Ihrem Testgerät eindeutig identifiziert. „Doppelte Paketnamen“ werden vermieden. wenn die App in die Play Console hochgeladen wird. Öffnen Sie app/build.gradle, um die Anwendungs-ID zu aktualisieren:

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

Ersetzen Sie "MYUNIQUENAME". im Feld applicationId in ein für Sie einzigartiges Feld ein.

Test-Plug-in installieren

Mit dem Google Assistant-Plug-in können Sie App Actions auf einem Testgerät testen. Dabei werden über die Google App auf deinem Android-Gerät Informationen an Assistant gesendet. Wenn Sie das Plug-in noch nicht haben, installieren Sie es mit den folgenden Schritten:

  1. Gehen Sie zu Datei > Einstellungen (Android Studio > Einstellungen unter macOS)
  2. Rufen Sie im Abschnitt „Plug-ins“ den Marketplace auf und suchen Sie nach „Google Assistant“. Du kannst das Testtool auch manuell herunterladen und installieren.
  3. Installieren Sie das Tool und starten Sie Android Studio neu.

App auf dem Gerät testen

Bevor Sie weitere Änderungen an der App vornehmen, sollten Sie sich ein Bild davon machen, was die Beispiel-App leisten kann.

Führen Sie die App auf dem Testgerät aus:

  1. Wählen Sie in Android Studio Ihr physisches oder virtuelles Gerät und dann Ausführen > App ausführen oder in der Symbolleiste auf AusführenApp-Symbol in Android Studio klicken
  2. Halte die Startbildschirmtaste lange gedrückt, um Assistant einzurichten und zu prüfen, ob er funktioniert. Dazu musst du dich auf deinem Gerät in Assistant anmelden.

Weitere Informationen zu virtuellen Android-Geräten finden Sie unter Virtuelle Android-Geräte erstellen und verwalten.

Sehen Sie sich kurz die App an, um zu sehen, was sie alles kann. Die App füllt vorab zehn Trainingsaktivitäten und zeigt diese Informationen in der ersten Ansicht an.

Vorhandenes Widget ausprobieren

  1. Tippen Sie auf die Schaltfläche Startseite, um den Startbildschirm des Testgeräts aufzurufen.
  2. Drücken Sie lange auf eine leere Stelle auf dem Startbildschirm und wählen Sie Widgets aus.
  3. Scrollen Sie in der Widget-Liste nach unten zu FitActions.
  4. Drücke lange auf das FitActions-Symbol und platziere das Widget auf dem Startbildschirm.

Screenshot mit dem FitActions-Widget auf dem Startbildschirm des Geräts

4. App Action hinzufügen

In diesem Schritt fügen Sie die BII-Funktion GET_EXERCISE_OBSERVATION hinzu. Dazu fügen Sie ein neues capability-Element in shortcuts.xml hinzu. Diese Capability gibt an, wie die Capability ausgelöst wird, wie BII-Parameter verwendet werden und welche Android-Intents aufgerufen werden sollen, um die Anfrage zu erfüllen.

  1. Fügen Sie der Ressource des Beispielprojekts shortcuts.xml mit dieser Konfiguration ein neues capability-Element hinzu:
    <!-- 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>
    Ersetzen Sie den android:targetPackage-Wert PUT_YOUR_APPLICATION_ID_HERE durch Ihren eindeutigen applicationId.

Diese Funktion ordnet den BII GET_EXERCISE_OBSERVATION dem Intent app-widget zu. Wenn der BII ausgelöst wird, wird das Widget instanziiert und dem Nutzer angezeigt.

Bevor das Widget ausgelöst wird, extrahiert Assistant unterstützte BII-Parameter aus der Nutzerabfrage. Für dieses Codelab ist der BII-Parameter exerciseObservation.aboutExercise.name erforderlich, der den vom Nutzer angeforderten Trainingstyp darstellt. Die App unterstützt drei Trainingstypen: „Laufen“, „Gehen“ und „Radfahren“. Sie stellen ein Inline-Inventar bereit, um Assistant über diese unterstützten Werte zu informieren.

  1. Definieren Sie diese Inventarelemente, indem Sie shortcuts.xml diese Konfiguration oberhalb der Funktion GET_EXERCISE_OBSERVATION hinzufügen:
    <!-- 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>

Fallback-Intent hinzufügen

Fallback-Intents verarbeiten Situationen, in denen eine Nutzeranfrage nicht ausgeführt werden kann, weil in der Abfrage Parameter fehlen, die für die Funktion erforderlich sind. Für die Funktion GET_EXERCISE_OBSERVATION ist der Parameter exerciseObservation.aboutExercise.name erforderlich, der durch das Attribut android:required="true" angegeben wird. In diesen Fällen erfordert Assistant, dass Sie einen Fallback-Intent definieren, damit die Anfrage ausgeführt werden kann, auch wenn keine Parameter in der Abfrage angegeben sind.

  1. Fügen Sie in shortcuts.xml der Funktion GET_EXERCISE_OBSERVATION mit der folgenden Konfiguration einen Fallback-Intent hinzu:
    <!-- 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>

In dieser Beispielkonfiguration ist die Fallback-Auftragsausführung ein Android-Intent ohne Parameter in den Extra-Daten.

5. Widget für Assistant aktivieren

Sobald die GET_EXERCISE_OBSERVATION-Funktion eingerichtet ist, aktualisieren Sie die Widget-Klasse so, dass sie App Actions-Sprachaufrufe unterstützt.

Bibliothek der Widget-Erweiterung hinzufügen

Die Widgets-Erweiterungsbibliothek für App Actions optimiert Ihre Widgets für die Sprachsteuerung von Assistant. Insbesondere können Sie eine benutzerdefinierte Text-in-Sprache-Einführung für Ihre Widgets anbieten.

  1. Fügen Sie die Abhängigkeit der Widget-Erweiterungsbibliothek zur Ressource /app/build.gradle der Beispiel-App hinzu:
    // app/build.gradle

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
    Klicken Sie im Warnfenster in Android Studio auf Jetzt synchronisieren. Durch die Synchronisierung nach jeder build.gradle-Änderung lassen sich Fehler beim Erstellen der App vermeiden.

Widget-Dienst hinzufügen

Ein Dienst ist eine Anwendungskomponente, die lang andauernde Vorgänge im Hintergrund ausführen kann. Ihre App muss einen Dienst zur Verarbeitung von Widget-Anfragen bereitstellen.

  1. Fügen Sie der Ressource AndroidManifest.xml der Beispiel-App mit der folgenden Konfiguration einen Dienst hinzu:
    <!-- 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>

Während einer Sprachanfrage, durch die eine Widget-Ausführung ausgelöst wird, verwendet Assistant diesen Dienst, um Anfragen an die App zu senden. Der Dienst empfängt die Anfrage zusammen mit den BII-Daten. Der Dienst verwendet diese Daten, um ein RemoteView-Widget-Objekt zu generieren, das innerhalb von Assistant gerendert wird.

Widget-Klasse aktualisieren

Deine App ist jetzt so konfiguriert, dass Funktionsanfragen vom Typ GET_EXERCISE_OBSERVATION an deine Widgetklasse weitergeleitet werden. Aktualisieren Sie als Nächstes die Klasse StatsWidget.kt, um mithilfe von BII-Parameterwerten eine Widget-Instanz zu generieren, die auf die Nutzeranfrage zugeschnitten ist.

  1. Öffnen Sie die Klasse StatsWidget.kt und importieren Sie die Bibliothek mit den App Actions Widget-Erweiterungen:
    // StatsWidget.kt

// ... Other import statements
import com.google.assistant.appactions.widgets.AppActionsWidgetExtension
  2. Fügen Sie die folgenden privaten Variablen hinzu, um festzulegen, welche Informationen in das Widget eingefügt werden sollen:
    // StatsWidget.kt

private val hasBii: Boolean
private val isFallbackIntent: Boolean
private val aboutExerciseName: String
private val exerciseType: FitActivity.Type
  3. Füge die Funktion init hinzu, damit die Klasse die von Assistant übergebenen Widget-Optionsdaten verwenden kann:
    // 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)
}

Sehen wir uns an, wie diese Updates es der StatsWidget.kt-Klasse ermöglichen, auf Android-Intents zu reagieren, die von der GET_EXERCISE_OBSERVATION-Funktion generiert wurden:

  • optionsBundle = Set
    • Bundles sind Objekte, die über Prozessgrenzen hinweg, zwischen Aktivitäten mit Intents und zum Speichern eines vorübergehenden Status über Konfigurationsänderungen hinweg verwendet werden sollen. Der Assistent verwendet Bundle-Objekte, um Konfigurationsdaten an das Widget zu übergeben.
  • bii = actions.intent.GET_EXERCISE_OBSERVATION
    • Der Name des BII ist im Bundle mit der AppActionsWidgetExtension verfügbar.
  • hasBii = true
    • Prüft, ob ein BII vorhanden ist.
  • params = Bundle[{aboutExerciseName=running}]
    • Ein spezielles Bundle, das durch App Actions generiert wurde, ist in den Widget-Optionen Bundle verschachtelt. Es enthält die Schlüssel/Wert-Paare des BII. In diesem Fall wurde der Wert running aus der Beispielabfrage Hey Google, zeig mir meine Laufstatistiken in ExampleApp extrahiert.
  • isFallbackIntent = false
    • Prüft, ob im Intent Extras erforderliche BII-Parameter vorhanden sind.
  • aboutExerciseName = running
    • Ruft den Extras-Wert des Intents für aboutExerciseName ab.
  • exerciseType = RUNNING
    • Verwendet aboutExerciseName, um das entsprechende Datenbanktypobjekt zu suchen.

Da die StatsWidget-Klasse jetzt eingehende Android-Intent-Daten von App Actions verarbeiten kann, aktualisieren Sie die Ablauflogik der Widget-Erstellung, um zu prüfen, ob das Widget durch eine App Action ausgelöst wurde.

  1. Ersetzen Sie in StatsWidget.kt die Funktion updateAppWidget() durch diesen 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()
}

Der vorherige Code verweist auf die neue Funktion observeAndUpdateRequestedExercise. Diese Funktion generiert Widget-Daten mithilfe der exerciseType-Parameterdaten, die vom Android-Intent „App Actions“ übergeben werden.

  1. Fügen Sie die Funktion observeAndUpdateRequestedExercise mit diesem Code hinzu:
    // 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()
       }
   }
}

Verwenden Sie im vorstehenden Code eine vorhandene Repository-Klasse aus der App, um Fitnessdaten aus der lokalen Datenbank der App abzurufen. Diese Klasse bietet eine API, die den Zugriff auf die Datenbank vereinfacht. Das Repository macht bei Abfragen der Datenbank ein LiveData-Objekt verfügbar. In Ihrem Code beobachten Sie diesen LiveData, um die letzte Fitnessaktivität abzurufen.

Sprachausgabe aktivieren

Sie können einen Text für Sprachausgabe angeben, den Assistant bei der Anzeige Ihres Widgets ankündigt. Wir empfehlen, diesen Hinweis zu verwenden, um hörbaren Kontext für Ihre Widgets bereitzustellen. Diese Funktion wird von der Erweiterungsbibliothek für Widgets für App Actions zur Verfügung gestellt. Damit kannst du den Text und die Text-in-Sprache-Einleitungen festlegen, die deinen Widgets in Assistant angezeigt werden.

Die Funktion formatDataAndSetWidget bietet die Möglichkeit, die Aktivitätsdaten zu formatieren, die aus der App-Datenbank zurückgegeben werden.

  1. Fügen Sie in StatsWidget.kt diesen Code zur Funktion formatDataAndSetWidget hinzu:
    // 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)
      }
}

Der vorherige Code verweist auf zwei Stringressourcen: eine für Sprache und eine für Text. Sehen Sie sich die Empfehlungen für den Sprachausgabe-Stil in unserem Widget-Video mit Empfehlungen zur Text-in-Sprache-Funktion an. Das Beispiel bezieht sich auch auf setTts, eine neue Funktion, die die Text-in-Sprache-Informationen an die Widget-Instanz bereitstellt.

  1. Fügen Sie StatsWidget.kt die neue setTts-Funktion mit diesem Code hinzu:
    // 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)
}

Vervollständigen Sie die Sprachausgabe-Logik, indem Sie Text-in-Sprache-Informationen festlegen, wenn die Trainingsdatenbank leere Daten für einen angeforderten Trainingstyp zurückgibt.

  1. Aktualisieren Sie die Funktion setNoActivityDataWidget() in StatsWidget.kt mit diesem Code:
    // 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. App Action testen

Verwenden Sie während der Entwicklung das Google Assistant-Plug-in, um Assistant App Actions auf einem Testgerät als Vorschau anzusehen. Du kannst Intent-Parameter für eine App Action mit dem Tool anpassen, um zu testen, wie deine Aktion mit den verschiedenen Möglichkeiten umgeht, die ein Nutzer Assistant zum Ausführen der Aktion bittet.

Vorschau erstellen

So testen Sie Ihre App Action mit dem Plug-in:

  1. Klicken Sie auf Tools > Google Assistant > App Actions-Testtool Möglicherweise wirst du aufgefordert, dich mit deinem Google-Konto in Android Studio anzumelden.
  2. Klicken Sie auf Vorschau erstellen. Wenn du dazu aufgefordert wirst, lies und akzeptiere die Richtlinien und Nutzungsbedingungen für App Actions.

Erwarteten Trainingstyp testen

Rückgabe eines Widgets mit Informationen über die letzte Ausführung in der App durch Befolgen der folgenden Schritte im Testtool:

  1. Im ersten Schritt, in dem Sie aufgefordert werden, einen BII auszuwählen und zu konfigurieren, wählen Sie actions.intent.GET_EXERCISE_OBSERVATION aus.
  2. Ändern Sie im Feld exerciseObservation den Standardnamen der Übung von climbing zu run.
  3. Klicken Sie auf Run App Action (App-Aktion ausführen).

Ein Bildschirm, auf dem ein Widget zu sehen ist, das mit dem Google Assistant-Plug-in zurückgegeben wird.

Unerwarteten Trainingstyp testen

So testest du eine unerwartete Trainingsart im Testtool:

  1. Ändern Sie im Feld exerciseObservation den Wert für name von Run auf Climbing.
  2. Klicken Sie auf Run App Action (App-Aktion ausführen).

Assistant sollte ein Widget zurückgeben, auf dem „Keine Aktivität gefunden“ angezeigt wird Informationen.

Ein Bildschirm, auf dem ein Widget ohne Trainingsinformationen zu sehen ist, die über das Google Assistant-Plug-in zurückgegeben werden.

Fallback-Intent testen

Abfragen, die den Fallback-Intent auslösen, sollten ein Widget zurückgeben, das Informationen über die letzte protokollierte Aktivität eines beliebigen Trainingstyps anzeigt.

So testen Sie den Fallback-Intent:

  1. Löschen Sie im Feld exerciseObservation das Objekt aboutExercise.
  2. Klicken Sie auf Run App Action (App-Aktion ausführen).

Assistant sollte ein Widget zurückgeben, das Informationen für das letzte abgeschlossene Training anzeigt.

Ein Bildschirm mit einem Widget, das die letzte aufgezeichnete Aktivität zeigt. Dabei wird das Google Assistant-Plug-in verwendet.

7. Nächste Schritte

Glückwunsch!

Sie haben jetzt die Möglichkeit, über ein Android-Widget und Assistant.

Behandelte Themen

In diesem Codelab haben Sie gelernt, wie Sie:

  • Ein App-Widget zu einem BII hinzufügen.
  • Ändere ein Widget, um auf Parameter aus Android-Extras zuzugreifen.

Nächste Schritte

Von hier aus können Sie weitere Optimierungen an Ihrer Fitness-App vornehmen. Informationen zum abgeschlossenen Projekt finden Sie im Haupt-Repository auf GitHub.

Hier sind einige Vorschläge, wie du diese App mit App Actions erweitern kannst:

Wenn Sie Actions on Google weiter nutzen möchten, sollten Sie sich die folgenden Ressourcen ansehen:

Folge uns auf Twitter (@ActionsOnGoogle), um dich über unsere neuesten Ankündigungen zu informieren, und twittere unter #appactions, um deine Arbeit mit anderen zu teilen.

Feedback-Umfrage

Wir würden uns freuen, wenn du uns an dieser Umfrage teilnimmst, um uns Feedback zu diesem Codelab zu geben.