Android-Widgets in Google Assistant einbinden

1. Übersicht

Im ersten App Actions-Codelab haben Sie gelernt, wie Sie Google Assistant auf eine Beispiel-Fitness-App ausweiten, indem Sie integrierte Intents (BIIs) aus der BII-Kategorie „Gesundheit und Fitness“ implementieren.

Mit App Actions können Nutzer bestimmte App-Funktionen direkt über Assistant starten, indem sie z. B. „Hey Google, starte einen Lauf in Beispiel-App“ sagen. Assistant kann nicht nur Apps starten, sondern auch ein interaktives Android-Widget für den Nutzer anzeigen, um Anfragen für infrage kommende BIIs zu erfüllen.

Auf dem Bildschirm ist zu sehen, wie Assistant ein Widget als Antwort auf eine Nutzeranfrage zurückgibt, die die BII-Funktion GET_EXERCISE_OBSERVATION einer App ausgelöst hat.

Aufgaben

In diesem Codelab erfahren Sie, wie Sie Android-Widgets zurückgeben, um Nutzeranfragen an Assistant zu erfüllen. Außerdem lernen Sie Folgendes:

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

Vorbereitung

Bevor Sie fortfahren, prüfen Sie, ob Ihre Entwicklungsumgebung für die Entwicklung von App Actions bereit ist. Sie sollte Folgendes enthalten:

  • Ein Terminal zum Ausführen von Shell-Befehlen, auf dem Git installiert ist.
  • Die aktuelle stabile Version von Android Studio.
  • Ein physisches oder virtuelles Android-Gerät mit Internetzugang.
  • Ein Google-Konto, mit dem Sie in Android Studio, der Google App und 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 sie mit einem integrierten Assistant-Intent (Built-in Intent, BII) abzugleichen. Assistant ordnet die Intention dann der Funktion zu, die das BII implementiert und die Sie für diese Intention in Ihrer App registrieren. Schließlich erfüllt Assistant die Anfrage des Nutzers, indem das Android-Widget angezeigt wird, das Ihre App anhand der Details in der Funktion generiert.

In diesem Codelab definieren Sie eine Funktion, die die Unterstützung für den GET_EXERCISE_OBSERVATION-BII 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. Sie aktualisieren diese Klasse, um ein personalisiertes Widget für Assistant zu generieren, das dem Nutzer angezeigt wird, und eine TTS-Einführung, die von Assistant vorgelesen wird.

Das folgende Diagramm veranschaulicht diesen Ablauf:

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

FitActions-Widget

Die FitActions-Beispiel-App enthält ein Widget mit Trainingsinformationen, das Nutzer ihrem Startbildschirm hinzufügen können. Dieses Widget eignet sich hervorragend, um Nutzeranfragen zu erfüllen, die den BII GET_EXERCISE_OBSERVATION auslösen.

Funktionsweise des Widgets

Wenn ein Nutzer dem Startbildschirm ein Widget hinzufügt, sendet das Widget ein Signal an den Broadcast Receiver des Geräts. 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 erstellt, das das Widget darstellt.

In der Beispiel-App wird der Empfänger widgets.StatsWidgetProvider definiert, 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 Erstellung von StatsWidget-Objekten. Dazu gehören folgende Aufgaben:

  • Widget-Instanzen erstellen und mit Trainingsdaten aus der App-Datenbank füllen.
  • Formatierung von Trainingsdaten für eine bessere Lesbarkeit mit formatDataAndSetWidget().
  • Standardwerte bereitstellen, wenn keine Trainingsdaten verfügbar sind, mit setNoActivityDataWidget().

Assistant-Unterstützung hinzufügen

In diesem Codelab aktualisieren Sie die Beispiel-App, um die App Actions-Funktionalität zu unterstützen. Diese Änderungen sind geplant:

  1. Konfigurieren der BII-Funktion GET_EXERCISE_OBSERVATION, um eine Instanz des StatsWidget-Objekts zurückzugeben.
  2. Aktualisieren Sie die Klasse StatsWidget, um App Actions-Funktionen wie die folgenden zu verwenden:
    • Mithilfe von BII-Parametern können Nutzer sich bestimmte Trainingsstatistiken ansehen, indem sie z. B. „Hey Google, zeig mir meine Laufstatistiken in ExampleApp.“ fragen.
    • Bereitstellung von TTS-Einführungsstrings
    • Sonderfälle verwalten, z. B. wenn die Nutzeranfrage keinen Parameter für den Trainingstyp enthält.

3. Bereiten Sie Ihre Entwicklungsumgebung vor

Basisdateien herunterladen

Führen Sie diesen 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

Nachdem Sie das Repository geklont haben, gehen Sie so vor, um es in Android Studio zu öffnen:

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

Wenn Sie eine Version der App sehen möchten, die dem abgeschlossenen Codelab entspricht, klonen Sie das Beispiel-App-Repository mit dem Flag --branch master.

Android-App-ID aktualisieren

Durch das Aktualisieren der Anwendungs-ID der App wird die App auf Ihrem Testgerät eindeutig identifiziert. Außerdem wird der Fehler „Doppelter Paketname“ vermieden, wenn die App in die Play Console hochgeladen wird. So aktualisieren Sie die Anwendungs-ID:app/build.gradle

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

Ersetzen Sie „MYUNIQUENAME“ im Feld applicationId durch einen eindeutigen Namen.

Test-Plug-in installieren

Mit dem Google Assistant-Plug-in können Sie Ihre App Actions auf einem Testgerät testen. Dazu werden Informationen über die Google App auf Ihrem Android-Gerät an Assistant gesendet. Wenn Sie das Plug‑in noch nicht haben, installieren Sie es so:

  1. Klicken Sie auf Datei > Einstellungen (unter MacOS Android Studio > Einstellungen).
  2. Rufen Sie im Bereich „Plug‑ins“ den Marketplace auf und suchen Sie nach „Google Assistant“. Sie können das Testtool auch manuell herunterladen und installieren.
  3. Installieren Sie das Tool und starten Sie Android Studio neu.

App auf Ihrem Gerät testen

Bevor Sie weitere Änderungen an der App vornehmen, sollten Sie sich einen Überblick über die Funktionen der Beispiel-App verschaffen.

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

  1. Wählen Sie in Android Studio Ihr physisches oder virtuelles Gerät und dann Run > Run app (Ausführen > App ausführen) aus oder klicken Sie in der Symbolleiste auf RunSymbol zum Ausführen der App in Android Studio.
  2. Halte den Home-Button gedrückt, um Assistant einzurichten und zu prüfen, ob er funktioniert. Sie müssen sich auf Ihrem Gerät in Assistant anmelden, falls Sie das noch nicht getan haben.

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

Sehen Sie sich die App kurz an, um zu sehen, was sie kann. In der ersten Ansicht werden 10 Trainingsaktivitäten vorab ausgefüllt angezeigt.

Vorhandenes Widget ausprobieren

  1. Tippen Sie auf die Schaltfläche Startbildschirm, um zum Startbildschirm Ihres Testgeräts zu wechseln.
  2. Halten Sie eine freie Stelle auf dem Startbildschirm gedrückt und wählen Sie Widgets aus.
  3. Scrolle in der Widget-Liste nach unten zu FitActions.
  4. Halte das FitActions-Symbol gedrückt und platziere das Widget auf dem Startbildschirm.

Screenshot des FitActions-Widgets 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 in shortcuts.xml ein neues capability-Element hinzu. Diese Funktion gibt an, wie die Funktion ausgelöst wird, wie BII-Parameter verwendet werden und welche Android-Intents aufgerufen werden, um die Anfrage zu erfüllen.

  1. Fügen Sie der shortcuts.xml-Ressource des Beispielprojekts ein neues capability-Element mit dieser Konfiguration 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 Wert android:targetPackage, PUT_YOUR_APPLICATION_ID_HERE, durch Ihre eindeutige 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 Nutzeranfrage. Für dieses Codelab ist der BII-Parameter exerciseObservation.aboutExercise.name erforderlich, der den vom Nutzer angeforderten Trainingstyp darstellt. Die App unterstützt drei Trainingsarten: „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 diese Konfiguration über der GET_EXERCISE_OBSERVATION-Funktion zu shortcuts.xml 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 werden in Situationen verwendet, in denen eine Nutzeranfrage nicht erfüllt werden kann, weil in der Anfrage 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 müssen Sie einen Fallback-Intent für Assistant definieren, damit die Anfrage erfolgreich ausgeführt werden kann, auch wenn in der Anfrage keine Parameter angegeben sind.

  1. Fügen Sie in shortcuts.xml der Funktion GET_EXERCISE_OBSERVATION mit dieser 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-Ausführung ein Android-Intent ohne Parameter in den Extra-Daten.

5. Widget für Assistant aktivieren

Nachdem die Funktion GET_EXERCISE_OBSERVATION eingerichtet wurde, aktualisieren Sie die Widget-Klasse, um die Sprachaufrufe von App Actions zu unterstützen.

Widgets Extension-Bibliothek hinzufügen

Die Widgets Extension-Bibliothek für App Actions verbessert Ihre Widgets für die sprachgesteuerte Nutzung von Assistant. Insbesondere können Sie eine benutzerdefinierte TTS-Einführung für Ihre Widgets bereitstellen.

  1. Fügen Sie der /app/build.gradle-Ressource der Beispiel-App die Abhängigkeit der Widgets Extension-Bibliothek hinzu:
    // app/build.gradle

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
    Klicken Sie im Warnfeld, das in Android Studio angezeigt wird, auf Jetzt synchronisieren. Wenn Sie nach jeder build.gradle-Änderung synchronisieren, können Sie 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 AndroidManifest.xml-Ressource der Beispiel-App einen Dienst mit dieser Konfiguration 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>

Bei einer Sprachanfrage, die die Widget-Ausführung auslöst, 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 in Assistant gerendert werden soll.

Widget-Klasse aktualisieren

Ihre App ist jetzt so konfiguriert, dass GET_EXERCISE_OBSERVATION-Funktionsanfragen an Ihre Widget-Klasse 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 App Actions Widget Extension-Bibliothek:
    // StatsWidget.kt

// ... Other import statements
import com.google.assistant.appactions.widgets.AppActionsWidgetExtension
  2. Fügen Sie diese privaten Variablen hinzu, mit denen Sie die Informationen bestimmen, die im Widget angezeigt werden sollen:
    // StatsWidget.kt

private val hasBii: Boolean
private val isFallbackIntent: Boolean
private val aboutExerciseName: String
private val exerciseType: FitActivity.Type
  3. Fügen Sie die init-Funktion hinzu, damit die Klasse die vom Assistenten ü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 Klasse StatsWidget.kt ermöglichen, auf Android-Intents zu reagieren, die von der Funktion GET_EXERCISE_OBSERVATION generiert werden:

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

Da die Klasse StatsWidget jetzt eingehende Android-Intent-Daten für App Actions verarbeiten kann, müssen Sie die Logik für die Widget-Erstellung aktualisieren, 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()
}

Im vorherigen Code wird auf eine neue Funktion verwiesen: observeAndUpdateRequestedExercise. Mit dieser Funktion werden Widget-Daten anhand der exerciseType-Parameterdaten generiert, die vom Android-Intent für 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()
       }
   }
}

Im vorherigen Code wird eine vorhandene Repository-Klasse verwendet, die in der App enthalten ist, um Fitnessdaten aus der lokalen Datenbank der App abzurufen. Diese Klasse bietet eine API, die den Zugriff auf die Datenbank vereinfacht. Das Repository stellt ein LiveData-Objekt bereit, wenn Abfragen für die Datenbank ausgeführt werden. In Ihrem Code sehen Sie LiveData, um die letzte Fitnessaktivität abzurufen.

TTS aktivieren

Sie können einen TTS-String angeben, den Assistant beim Anzeigen Ihres Widgets vorlesen soll. Wir empfehlen, diese Funktion zu nutzen, um Ihren Widgets einen hörbaren Kontext zu geben. Diese Funktion wird von der App Actions Widgets Extension-Bibliothek bereitgestellt. Damit können Sie den Text und die TTS-Einführungen festlegen, die Ihre Widgets in Assistant begleiten.

Die TTS-Einführung kann gut in der Funktion formatDataAndSetWidget platziert werden, die die aus der App-Datenbank zurückgegebenen Aktivitätsdaten formatiert.

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

Im vorherigen Code wird auf zwei String-Ressourcen verwiesen: eine für Sprache und eine für Text. Im Video zu Widgets finden Sie im Abschnitt Empfehlungen für den Stil der Sprachausgabe Empfehlungen zur Sprachausgabe. Im Beispiel wird auch auf setTts verwiesen, eine neue Funktion, die der Widget-Instanz die TTS-Informationen bereitstellt.

  1. Fügen Sie die neue Funktion setTts mit diesem Code in StatsWidget.kt ein:
    // 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ändige schließlich die TTS-Logik, indem du TTS-Informationen festlegst, 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 sich eine Vorschau von Assistant App Actions auf einem Testgerät anzusehen. Mit dem Tool können Sie Intent-Parameter für eine App Action anpassen, um zu testen, wie Ihre Action auf die verschiedenen Arten reagiert, mit denen Nutzer Assistant bitten, sie auszuführen.

Vorschau erstellen

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

  1. Klicken Sie auf Tools > Google Assistant > App Actions Test Tool. Möglicherweise werden Sie aufgefordert, sich mit Ihrem Google-Konto in Android Studio anzumelden.
  2. Klicken Sie auf Vorschau erstellen. Lesen und akzeptieren Sie die Richtlinien und Nutzungsbedingungen für App Actions, wenn Sie dazu aufgefordert werden.

Erwarteten Trainingstyp testen

So geben Sie ein Widget zurück, das Informationen zum letzten Lauf enthält, der in der App abgeschlossen wurde:

  1. Wählen Sie im ersten Schritt, in dem Sie aufgefordert werden, ein BII auszuwählen und zu konfigurieren, actions.intent.GET_EXERCISE_OBSERVATION aus.
  2. Aktualisieren Sie im Feld exerciseObservation den Standardnamen der Übung von climbing zu run.
  3. Klicken Sie auf App-Aktion ausführen.

Ein Bildschirm mit einem Widget, das über das Google Assistant-Plug-in zurückgegeben wurde.

Unerwarteten Trainingstyp testen

So testen Sie einen unerwarteten Trainingstyp im Testtool:

  1. Aktualisieren Sie im Feld exerciseObservation den Wert von name von Run auf Climbing.
  2. Klicken Sie auf App-Aktion ausführen.

Assistant sollte ein Widget mit der Meldung „Keine Aktivität gefunden“ zurückgeben.

Ein Bildschirm mit einem Widget, in dem keine Trainingsinformationen angezeigt werden, die über das Google Assistant-Plug-in zurückgegeben wurden.

Fallback-Intent testen

Bei Anfragen, die den Fallback-Intent auslösen, sollte ein Widget zurückgegeben werden, in dem Informationen zur letzten protokollierten Aktivität eines beliebigen Trainingstyps angezeigt werden.

So testen Sie den Fallback-Intent:

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

Assistant sollte ein Widget mit Informationen zum letzten abgeschlossenen Training zurückgeben.

Ein Bildschirm mit einem Widget, das die letzte aufgezeichnete Aktivität mit dem Google Assistant-Plug-in anzeigt.

7. Nächste Schritte

Glückwunsch!

Sie können jetzt Nutzeranfragen über ein Android-Widget mit Assistant beantworten.

Behandelte Themen

In diesem Codelab haben Sie Folgendes gelernt:

  • App-Widget zu einem BII hinzufügen
  • Widget ändern, um auf Parameter aus Android Extras zuzugreifen

Nächste Schritte

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

Hier sind einige Vorschläge, wie Sie diese App mit App Actions erweitern können:

Wenn Sie Ihre Reise mit Actions on Google fortsetzen möchten, sehen Sie sich diese Ressourcen an:

Folgen Sie uns auf Twitter unter @ActionsOnGoogle, um über unsere neuesten Ankündigungen auf dem Laufenden zu bleiben, und twittern Sie unter #appactions, um zu teilen, was Sie entwickelt haben.

Feedbackumfrage

Füllen Sie diese Umfrage aus, um Feedback zu diesem Codelab zu geben.