Dynamische Verknüpfungen mit App Actions auf Google Assistant erweitern

1. Übersicht

Im vorherigen Codelab haben Sie statische Verknüpfungen verwendet, um häufig verwendete integrierte Intents (Built-in Intents, BIIs) in einer Beispiel-App zu implementieren. Android-Entwickler verwenden App Actions, um die App-Funktionalität auf Google Assistant auszuweiten.

Statische Verknüpfungen sind in einer App enthalten und können nur durch die Veröffentlichung neuer Versionen der App aktualisiert werden. Die Sprachsteuerung dynamischer Elemente in einer App, z. B. nutzergenerierter Inhalte, wird über dynamische Verknüpfungen ermöglicht. Apps pushen dynamische Verknüpfungen, nachdem Nutzer relevante Aktionen ausgeführt haben, z. B. eine neue Notiz in einer Aufgaben-Tracking-App erstellt haben. Mit App Actions können Sie diese Verknüpfungen für die Sprachsteuerung aktivieren, indem Sie sie an einen integrierten Intent binden. So können Nutzer über Assistant auf ihre Inhalte zugreifen, indem sie z. B. Hey Google, öffne meine Einkaufsliste in Beispiel-App sagen.

Drei progressive Screenshots, auf denen zu sehen ist, wie Google Assistant eine dynamische Verknüpfung startet.

Abbildung 1. Drei progressive Screenshots, auf denen eine vom Nutzer erstellte Aufgabe und Google Assistant zu sehen sind, die eine dynamische Verknüpfung zu dieser Aufgabe starten.

Aufgaben

In diesem Codelab aktivieren Sie dynamische Verknüpfungen für die Sprachsteuerung in einer Beispiel-Android-App für To-do-Listen. So können Nutzer Assistant bitten, die in der App erstellten Aufgabenlisten zu öffnen. Dazu verwenden Sie Android-Architekturmuster, insbesondere die Muster Repository, Service Locator und ViewModel.

Vorbereitung

Dieses Codelab baut auf den App Actions-Konzepten auf, die im vorherigen Codelab behandelt wurden, insbesondere BIIs und statische Verknüpfungen. Wenn Sie noch nicht mit App Actions vertraut sind, empfehlen wir Ihnen, dieses Codelab durchzuarbeiten, bevor Sie fortfahren.

Außerdem muss Ihre Entwicklungsumgebung die folgenden Anforderungen erfüllen, bevor Sie fortfahren:

  • Ein Terminal zum Ausführen von Shell-Befehlen mit installiertem Git.
  • 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.

2. Funktionsweise

So aktivieren Sie eine dynamische Verknüpfung für Voice Access:

  • Eine dynamische Verknüpfung an ein geeignetes BII binden
  • Assistant kann die Verknüpfungen aufnehmen, wenn Sie die Google Shortcuts Integration-Bibliothek hinzufügen.
  • Pushing a shortcut whenever a user completes the relevant in-app task.

Tastenkombinationen

Damit ein dynamischer Shortcut über Assistant aufgerufen werden kann, muss er an einen relevanten BII gebunden sein. Wenn ein BII mit einem Shortcut ausgelöst wird, vergleicht Assistant die Parameter in der Nutzeranfrage mit den Keywords, die im gebundenen Shortcut definiert sind. Beispiel:

  • Mit einem Shortcut, der an den BII GET_THING gebunden ist, können Nutzer bestimmte In‑App-Inhalte direkt über Assistant anfordern. * „Hey Google, öffne meine Einkaufsliste in Beispiel-App.“
  • Mit einer Verknüpfung, die an den BII START_EXERCISE gebunden ist, können Nutzer ihre Trainingseinheiten aufrufen. * „Hey Google, bitte ExampleApp, mein übliches Training zu starten.“

Eine vollständige kategorisierte Liste der integrierten Intents finden Sie in der Referenz zu integrierten Intents.

Kurzbefehle für Assistant bereitstellen

Nachdem Sie Ihre Verknüpfungen an ein BII gebunden haben, müssen Sie Assistant ermöglichen, diese Verknüpfungen zu erfassen. Dazu fügen Sie Ihrem Projekt die Google Shortcuts Integration-Bibliothek hinzu. Wenn diese Bibliothek vorhanden ist, kennt Assistant jede von Ihrer App übertragene Verknüpfung. Nutzer können diese Verknüpfungen dann starten, indem sie die Auslöserphrase der Verknüpfung in Assistant verwenden.

3. Bereiten Sie Ihre Entwicklungsumgebung vor

In diesem Codelab wird eine Beispiel-App für eine Aufgabenliste verwendet, die für Android entwickelt wurde. Mit dieser App können Nutzer Elemente zu Listen hinzufügen, nach Aufgabenlistenelementen nach Kategorie suchen und Aufgaben nach Abschlussstatus filtern. Laden Sie die Beispiel-App herunter und bereiten Sie sie vor, indem Sie diesen Abschnitt durcharbeiten.

Basisdateien herunterladen

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

git clone https://github.com/actions-on-google/app-actions-dynamic-shortcuts.git

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

  1. Klicken Sie im Dialogfeld Welcome to Android Studio auf Import project.
  2. Wählen Sie den Ordner aus, in den Sie das Repository geklont haben.

Alternativ können Sie sich eine Version der Beispiel-App ansehen, die das abgeschlossene Codelab darstellt, indem Sie den codelab-complete-Branch des zugehörigen GitHub-Repositorys klonen:

git clone https://github.com/actions-on-google/app-actions-dynamic-shortcuts.git --branch codelab-complete

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.

Abhängigkeiten für die Shortcuts API hinzufügen

Fügen Sie der Ressourcendatei app/build.gradle die folgenden Jetpack-Bibliotheken hinzu:

app/build.gradle

dependencies {
   ...
   // Shortcuts library
   implementation "androidx.core:core:1.6.0"
   implementation 'androidx.core:core-google-shortcuts:1.0.1'
   ...
}

App auf Ihrem Gerät testen

Bevor Sie weitere Änderungen an der App vornehmen, sollten Sie sich ansehen, was die Beispiel-App kann. So führen Sie die App auf Ihrem Emulator aus:

  1. Wählen Sie in Android Studio „Run“ > „Run app“ (Ausführen > App ausführen) aus oder klicken Sie in der Symbolleiste auf RunSymbol zum Ausführen von Apps in Android Studio.
  2. Wählen Sie im Dialogfeld Bereitstellungsziel auswählen ein Gerät aus und klicken Sie auf OK. Die empfohlene Betriebssystemversion ist Android 10 (API-Level 30) oder höher. App Actions funktionieren jedoch auch auf Geräten mit Android 5 (API-Level 21).
  3. Halten Sie die Startbildschirmtaste 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. Wenn Sie auf das Pluszeichen tippen, wird ein neues Aufgabenelement erstellt. Über die Menüelemente oben rechts können Sie nach Aufgabenelementen suchen und sie nach Abschlussstatus filtern.

4. Klasse für das Shortcut-Repository erstellen

Mehrere Klassen in unserer Beispiel-App rufen die ShortcutManagerCompat API auf, um dynamische Verknüpfungen zu pushen und zu verwalten. Um Code-Redundanz zu reduzieren, implementieren Sie ein Repository, damit Ihre Projektklassen dynamische Verknüpfungen einfach verwalten können.

Das Repository-Designmuster bietet eine übersichtliche API zum Verwalten von Verknüpfungen. Der Vorteil eines Repositorys besteht darin, dass die Details der zugrunde liegenden API einheitlich hinter einer minimalen API abstrahiert werden. So implementieren Sie das Repository:

  1. Erstellen Sie eine ShortcutsRepository-Klasse, um die ShortcutManagerCompat-API zu abstrahieren.
  2. Fügen Sie dem Service Locator der App ShortcutsRepository-Methoden hinzu.
  3. Registrieren Sie den Dienst ShortcutRepository in der Hauptanwendung.

Repository erstellen

Erstellen Sie im Paket com.example.android.architecture.blueprints.todoapp.data.source eine neue Kotlin-Klasse mit dem Namen ShortcutsRepository. Sie finden dieses Paket im Ordner app/src/main/java. Mit dieser Klasse implementieren Sie eine Schnittstelle mit einer minimalen Anzahl von Methoden, die den Anwendungsfall unseres Codelabs abdecken.

Android Studio-Fenster mit dem Speicherort der Klasse „ShortcutsRepository“.

Abbildung 2: Das Fenster „Android Studio Project Files“ (Android Studio-Projektdateien) mit dem Speicherort der Klasse „ShortcutsRepository“.

Fügen Sie den folgenden Code in die neue Klasse ein:

package com.example.android.architecture.blueprints.todoapp.data.source

import android.content.Context
import android.content.Intent
import androidx.annotation.WorkerThread
import androidx.core.content.pm.ShortcutInfoCompat
import androidx.core.content.pm.ShortcutManagerCompat
import com.example.android.architecture.blueprints.todoapp.data.Task
import com.example.android.architecture.blueprints.todoapp.tasks.TasksActivity

private const val GET_THING_KEY = "q"

/**
* ShortcutsRepository provides an interface for managing dynamic shortcuts.
*/
class ShortcutsRepository(val context: Context) {

   private val appContext = context.applicationContext

   /**
    * Pushes a dynamic shortcut. The task ID is used as the shortcut ID.
    * The task's title and description are used as shortcut's short and long labels.
    * The resulting shortcut corresponds to the GET_THING capability with task's
    * title used as BII's "name" argument.
    *
    * @param task Task object for which to create a shortcut.
    */
   @WorkerThread
   fun pushShortcut(task: Task) {
      // TODO
   }

   private fun createShortcutCompat(task: Task): ShortcutInfoCompat {
      //...
   }

   /**
    *  Updates a dynamic shortcut for the provided task. If the shortcut
    *  associated with this task doesn't exist, this method throws an error.
    *  This operation may take a few seconds to complete.
    *
    * @param tasks list of tasks to update.
    */
   @WorkerThread
   fun updateShortcuts(tasks: List<Task>) {
       //...
   }

   /**
    * Removes shortcuts if IDs are known.
    *
    * @param ids list of shortcut IDs
    */
   @WorkerThread
   fun removeShortcutsById(ids: List<String>) {
       //...
   }

   /**
    * Removes shortcuts associated with the tasks.
    *
    * @param tasks list of tasks to remove.
    */
   @WorkerThread
   fun removeShortcuts(tasks: List<Task>) {
       //...
   }
}

Aktualisieren Sie als Nächstes die Methode pushShortcut, um die ShortcutManagerCompat API aufzurufen. Aktualisieren Sie die ShortcutsRepository-Klasse mit dem folgenden Code:

ShortcutsRepository.kt

/**
* Pushes a dynamic shortcut for the task. The task's ID is used as a shortcut
* ID. The task's title and description are used as shortcut's short and long
* labels. The created shortcut corresponds to GET_THING capability with task's
* title used as BII's "name" argument.
*
* @param task Task object for which to create a shortcut.
*/


@WorkerThread
fun pushShortcut(task: Task) {
   ShortcutManagerCompat.pushDynamicShortcut(appContext, createShortcutCompat(task))
}

Im vorherigen Codebeispiel haben wir appContext an die API übergeben. Dies ist eine Klassen-Property, die einen Application Context enthält. Es ist wichtig, einen Application Context (im Gegensatz zu einem Activity Context) zu verwenden, um Speicherlecks zu vermeiden, da der Kontext möglicherweise länger als der Lebenszyklus der Host-Aktivität beibehalten wird.

Außerdem muss für das Task-Objekt ein ShortcutInfoCompat-Objekt übergeben werden. Im vorherigen Codebeispiel wird dies durch Aufrufen der privaten Methode createShortcutCompat erreicht, die wir aktualisieren, um ein ShortcutInfoCompat-Objekt zu erstellen und zurückzugeben. Aktualisieren Sie dazu den createShortcutCompat-Stub mit dem folgenden Code:

ShortcutsRepository.kt

private fun createShortcutCompat(task: Task): ShortcutInfoCompat {
   val intent = Intent(appContext, TasksActivity::class.java)
   intent.action = Intent.ACTION_VIEW
   // Filtering is set based on currentTitle.
   intent.putExtra(GET_THING_KEY, task.title)

   // A unique ID is required to avoid overwriting an existing shortcut.
   return ShortcutInfoCompat.Builder(appContext, task.id)
           .setShortLabel(task.title)
           .setLongLabel(task.title)
           // Call addCapabilityBinding() to link this shortcut to a BII. Enables user to invoke a shortcut using its title in Assistant.
           .addCapabilityBinding(
                   "actions.intent.GET_THING", "thing.name", listOf(task.title))
           .setIntent(intent)
           .setLongLived(false)
       .build()
}

Die verbleibenden Funktions-Stubs in dieser Klasse befassen sich mit dem Aktualisieren und Löschen dynamischer Verknüpfungen. Aktivieren Sie diese Funktionen, indem Sie sie mit dem folgenden Code aktualisieren:

ShortcutsRepository.kt

/**
* Updates a Dynamic Shortcut for the task. If the shortcut associated with this task
* doesn't exist, throws an error. This operation may take a few seconds to complete.
*
* @param tasks list of tasks to update.
*/
@WorkerThread
fun updateShortcuts(tasks: List<Task>) {
   val scs = tasks.map { createShortcutCompat(it) }
   ShortcutManagerCompat.updateShortcuts(appContext, scs)
}

/**
* Removes shortcuts if IDs are known.
* @param ids list of shortcut IDs
*/
@WorkerThread
fun removeShortcutsById(ids: List<String>) {
   ShortcutManagerCompat.removeDynamicShortcuts(appContext, ids)
}

/**
* Removes shortcuts associated with the tasks.
*
* @param tasks list of tasks to remove.
*/
@WorkerThread
fun removeShortcuts(tasks: List<Task>) {
   ShortcutManagerCompat.removeDynamicShortcuts (appContext,
           tasks.map { it.id })
}

Klasse zum Satellitenfinder hinzufügen

Nachdem die ShortcutsRepository-Klasse erstellt wurde, müssen instanziierte Objekte dieser Klasse für den Rest der App verfügbar gemacht werden. In dieser App werden Klassendependencies durch die Implementierung des Service Locator-Musters verwaltet. Öffnen Sie die ServiceLocator-Klasse in Android Studio über den Klassenbrowser. Klicken Sie dazu auf Navigate > Class und geben Sie „ServiceLocator“ ein. Klicken Sie auf die resultierende Kotlin-Datei, um sie in Ihrer IDE zu öffnen.

Fügen Sie oben in ServiceLocator.kt den folgenden Code ein, um die Pakete ShortcutsRepository und SuppressLint zu importieren:

ServiceLocator.kt

package com.example.android.architecture.blueprints.todoapp

// ...Other import statements
import com.example.android.architecture.blueprints.todoapp.data.source.ShortcutsRepository
import android.annotation.SuppressLint

Fügen Sie die Dienstmitglieder und Methoden ShortcutRepository hinzu, indem Sie den folgenden Code in den Text von ServiceLocator.kt einfügen:

ServiceLocator.kt

object ServiceLocator {

   // ...
   // Only the code immediately below this comment needs to be copied and pasted
   // into the body of ServiceLocator.kt:

   @SuppressLint("StaticFieldLeak")
   @Volatile
   var shortcutsRepository: ShortcutsRepository? = null


   private fun createShortcutsRepository(context: Context): ShortcutsRepository {
       val newRepo = ShortcutsRepository(context.applicationContext)
       shortcutsRepository = newRepo
       return newRepo
   }

   fun provideShortcutsRepository(context: Context): ShortcutsRepository {
       synchronized(this) {
           return shortcutsRepository ?: shortcutsRepository ?: createShortcutsRepository(context)
       }
   }
 }

Verknüpften Dienst registrieren

Im letzten Schritt registrieren Sie Ihren neuen ShortcutsRepository-Dienst bei der Anwendung. Öffnen Sie in Android Studio die Datei TodoApplication.kt und kopieren Sie den folgenden Code in den oberen Bereich der Datei:

TodoApplication.kt

package com.example.android.architecture.blueprints.todoapp
/// ... Other import statements

import com.example.android.architecture.blueprints.todoapp.data.source.ShortcutsRepository

Registrieren Sie den Dienst als Nächstes, indem Sie den folgenden Code in den Hauptteil der Klasse einfügen:

TodoApplication.kt

//...
class TodoApplication : Application() {

   //...

   val shortcutsRepository: ShortcutsRepository
       get() = ServiceLocator.provideShortcutsRepository(this)

   //...
}

Erstellen Sie die App und prüfen Sie, ob sie weiterhin ausgeführt wird.

5. Neue Verknüpfung per Push übertragen

Nachdem Sie Ihren Dienst für Verknüpfungen erstellt haben, können Sie Verknüpfungen pushen. Da Nutzer in dieser App Inhalte (Aufgaben) erstellen und erwarten, später darauf zurückgreifen zu können, ermöglichen wir den sprachgesteuerten Zugriff auf diese Inhalte, indem wir jedes Mal, wenn ein Nutzer eine neue Aufgabe erstellt, eine dynamische Verknüpfung pushen, die an den GET_THING-BII gebunden ist. So kann Assistant Nutzer direkt zur gewünschten Aufgabe weiterleiten, wenn sie den BII mit Fragen wie „Hey Google, öffne meine Einkaufsliste in Beispiel-App.“ auslösen.

So aktivieren Sie diese Funktion in der Beispiel-App:

  1. Importieren des ShortcutsRepository-Dienstes in die AddEditTaskViewModel-Klasse, die für die Verwaltung von Aufgabenlistenobjekten zuständig ist.
  2. Dynamische Verknüpfung wird gepusht, wenn der Nutzer eine neue Aufgabe erstellt.

ShortcutsRepository importieren

Zuerst müssen wir den ShortcutsRepository-Dienst für AddEditTaskViewModel verfügbar machen. Importieren Sie dazu den Dienst in ViewModelFactory, die Factory-Klasse, die die App zum Instanziieren von ViewModel-Objekten verwendet, einschließlich AddEditTaskViewModel.

Öffnen Sie den Klassenbrowser in Android Studio über Navigate > Class und geben Sie „ViewModelFactory“ ein. Klicken Sie auf die resultierende Kotlin-Datei, um sie in Ihrer IDE zu öffnen.

Fügen Sie oben in ViewModelFactory.kt den folgenden Code ein, um die Pakete ShortcutsRepository und SuppressLint zu importieren:

ViewModelFactory.kt

package com.example.android.architecture.blueprints.todoapp

// ...Other import statements
import com.example.android.architecture.blueprints.todoapp.data.source.ShortcutsRepository

Ersetzen Sie als Nächstes den Hauptteil von ViewModelFactory durch den folgenden Code:

ViewModelFactory.kt

/**
 * Factory for all ViewModels.
 */
@Suppress("UNCHECKED_CAST")
class ViewModelFactory constructor(
    private val tasksRepository: TasksRepository,
    private val shortcutsRepository: ShortcutsRepository,
    owner: SavedStateRegistryOwner,
    defaultArgs: Bundle? = null
) : AbstractSavedStateViewModelFactory(owner, defaultArgs) {

    override fun <T : ViewModel> create(
        key: String,
        modelClass: Class<T>,
        handle: SavedStateHandle
    ) = with(modelClass) {
        when {
            isAssignableFrom(StatisticsViewModel::class.java) ->
                StatisticsViewModel(tasksRepository)
            isAssignableFrom(TaskDetailViewModel::class.java) ->
                TaskDetailViewModel(tasksRepository)
            isAssignableFrom(AddEditTaskViewModel::class.java) ->
                AddEditTaskViewModel(tasksRepository, shortcutsRepository)
            isAssignableFrom(TasksViewModel::class.java) ->
                TasksViewModel(tasksRepository, handle)
            else ->
                throw IllegalArgumentException("Unknown ViewModel class: ${modelClass.name}")
        }
    } as T
}

Schließen Sie die ViewModelFactory-Änderungen ab, indem Sie eine Ebene nach oben gehen, und übergeben Sie ShortcutsRepository an den Konstruktor der Factory. Öffnen Sie den Dateibrowser von Android Studio über Navigate > File und geben Sie „FragmentExt.kt“ ein. Klicken Sie auf die resultierende Kotlin-Datei im Paket util, um sie in Ihrer IDE zu öffnen.

Ersetzen Sie den Hauptteil von FragmentExt.kt durch den folgenden Code:

fun Fragment.getViewModelFactory(): ViewModelFactory {
   val taskRepository = (requireContext().applicationContext as TodoApplication).taskRepository
   val shortcutsRepository = (requireContext().applicationContext as TodoApplication).shortcutsRepository
   return ViewModelFactory(taskRepository, shortcutsRepository, this)
}

Verknüpfung senden

Da die Abstraktionsklasse ShortcutsRepository für die ViewModel-Klassen der Beispiel-App verfügbar ist, aktualisieren Sie AddEditTaskViewModel, die ViewModel-Klasse, die für das Erstellen von Notizen zuständig ist, um jedes Mal, wenn ein Nutzer eine neue Notiz erstellt, eine dynamische Verknüpfung zu pushen.

Öffnen Sie in Android Studio den Klassenbrowser und geben Sie „AddEditTaskViewModel“ ein. Klicken Sie auf die resultierende Kotlin-Datei, um sie in Ihrer IDE zu öffnen.

Fügen Sie zuerst das Paket ShortcutsRepository mit der folgenden Importanweisung zu dieser Klasse hinzu:

package com.example.android.architecture.blueprints.todoapp.addedittask

//Other import statements
import com.example.android.architecture.blueprints.todoapp.data.source.ShortcutsRepository

Fügen Sie als Nächstes die Klassenattribute shortcutsRepository hinzu, indem Sie den Klassenkonstruktor mit dem folgenden Code aktualisieren:

AddEditTaskViewModel.kt

//...

/**
* ViewModel for the Add/Edit screen.
*/
class AddEditTaskViewModel(
   private val tasksRepository: TasksRepository,
   private val shortcutsRepository: ShortcutsRepository
) : ViewModel() {

    //...

Nachdem Sie die Klasse ShortcutsRepository hinzugefügt haben, erstellen Sie eine neue Funktion, pushShortcut(), um diese Klasse aufzurufen. Fügen Sie die folgende private Funktion in den Textkörper von AddEditTaskViewModel ein:

AddEditTaskViewModel.kt

//...
private fun pushShortcut(newTask: Task) = viewModelScope.launch {
   shortcutsRepository.pushShortcut(newTask)
}

Senden Sie schließlich einen neuen dynamischen Shortcut, wenn eine Aufgabe erstellt wird. Ersetzen Sie den Inhalt der Funktion saveTask() durch den folgenden Code:

AddEditTaskViewModel.kt

fun saveTask() {
    val currentTitle = title.value
    val currentDescription = description.value

    if (currentTitle == null || currentDescription == null) {
        _snackbarText.value = Event(R.string.empty_task_message)
        return
    }
    if (Task(currentTitle, currentDescription).isEmpty) {
        _snackbarText.value = Event(R.string.empty_task_message)
        return
    }

    val currentTaskId = taskId
    if (isNewTask || currentTaskId == null) {
        val task = Task(currentTitle, currentDescription)
        createTask(task)
        pushShortcut(task)
    } else {
        val task = Task(currentTitle, currentDescription, taskCompleted, currentTaskId)
        updateTask(task)
    }
}

Code testen

Jetzt können wir unseren Code endlich testen. In diesem Schritt senden Sie eine sprachaktivierte dynamische Verknüpfung und sehen sie sich in der Google Assistant App an.

Vorschau erstellen

Wenn Sie eine Vorschau mit dem Google Assistant-Plug‑in erstellen, werden Ihre dynamischen Verknüpfungen in Assistant auf Ihrem Testgerät angezeigt.

Test-Plug-in installieren

Wenn Sie das Google Assistant-Plug-in noch nicht haben, installieren Sie es in Android Studio so:

  1. Klicken Sie auf **Datei > Einstellungen** (unter MacOS: **Android Studio > Einstellungen**).
  2. Gehen Sie im Bereich Plug-ins zu Marketplace und suchen Sie nach „Google Assistant“.
  3. Installieren Sie das Tool und starten Sie Android Studio neu.

Vorschau erstellen

So erstellen Sie eine Vorschau in Android Studio:

  1. Klicken Sie auf Tools > Google Assistant > App Actions Test Tool (App Actions-Testtool).
  2. Geben Sie im Feld App-Name einen Namen wie „Todo-Liste“ ein.
  3. Klicken Sie auf Vorschau erstellen. Lesen und akzeptieren Sie die Richtlinien und Nutzungsbedingungen für App Actions, wenn Sie dazu aufgefordert werden.

Bereich zum Erstellen von Vorschauen im App Actions Test Tool.

Abbildung 3: Der Bereich zum Erstellen von Vorschauen im App Actions Test Tool.

Während des Tests werden dynamische Verknüpfungen, die Sie an Assistant senden, in Assistant nach dem App-Namen organisiert, den Sie für die Vorschau angegeben haben.

Verknüpfung übertragen und prüfen

Starten Sie die Beispiel-App auf Ihrem Testgerät neu und führen Sie die folgenden Schritte aus :

  1. Erstelle eine neue Aufgabe mit dem Titel „Codelab starten“.
  2. Öffnen Sie die Google Assistant App und sagen oder tippen Sie „Meine Verknüpfungen“.
  3. Tippen Sie auf den Tab Entdecken. Die Beispielkurzbefehle sollten angezeigt werden.
  4. Tippen Sie auf die Verknüpfung, um sie aufzurufen. Die App sollte mit dem Namen der Tastenkombination im Filterfeld gestartet werden. So lässt sich das gewünschte Element leicht finden.

6. Optional: Verknüpfung aktualisieren und löschen

Ihre App kann nicht nur zur Laufzeit neue dynamische Verknüpfungen bereitstellen, sondern auch vorhandene Verknüpfungen aktualisieren, um den aktuellen Status der Nutzerinhalte und ‑einstellungen widerzuspiegeln. Es empfiehlt sich, vorhandene Verknüpfungen zu aktualisieren, wenn ein Nutzer das Zielobjekt ändert, z. B. eine Aufgabe in unserer Beispiel-App umbenennt. Sie sollten auch eine entsprechende Verknüpfung löschen, wenn die Zielressource entfernt wird, um zu vermeiden, dass Nutzern fehlerhafte Verknüpfungen angezeigt werden.

Verknüpfung aktualisieren

Ändern Sie AddEditTaskViewModel, um eine dynamische Verknüpfung zu aktualisieren, wenn ein Nutzer die Details eines Aufgabenpostens ändert. Aktualisieren Sie zuerst den Hauptteil der Klasse mit dem folgenden Code, um eine Aktualisierungsfunktion hinzuzufügen, die unsere Repository-Klasse verwendet:

AddEditTaskViewModel.kt

private fun updateShortcut(newTask: Task) = viewModelScope.launch {
   shortcutsRepository.updateShortcuts(listOf(newTask))
}

Als Nächstes müssen Sie die Funktion saveTask() so ändern, dass unsere neue Methode immer dann aufgerufen wird, wenn eine vorhandene Aufgabe aktualisiert wird.

AddEditTaskViewModel.kt

// Called when clicking on fab.
fun saveTask() {
   // ...
   // Note: the shortcuts are created/updated in a worker thread.
   if (isNewTask || currentTaskId == null) {
       //...
   } else {
       //...
       updateShortcut(task)
   }
}

Testen Sie Ihren Code, indem Sie die App neu starten und die folgenden Schritte ausführen:

  1. Benennen Sie den Titel des vorhandenen Aufgabenpostens in „Codelab abschließen“ um.
  2. Öffnen Sie Google Assistant, indem Sie „Hey Google, meine Verknüpfungen“ sagen.
  3. Tippen Sie auf den Tab Entdecken. Sie sollten ein aktualisiertes Kurzlabel für Ihren Test-Shortcut sehen.

Verknüpfung entfernen

Die Beispiel-App-Verknüpfungen sollten entfernt werden, wenn ein Nutzer eine Aufgabe löscht. In der Beispiel-App befindet sich die Logik zum Löschen von Aufgaben in der Klasse TaskDetailViewModel. Bevor wir diese Klasse aktualisieren können, müssen wir ViewModelFactory noch einmal aktualisieren, um shortcutsRepository in TaskDetailViewModel zu übergeben.

Öffnen Sie ViewModelFactory und ersetzen Sie den Inhalt der zugehörigen Konstruktormethode durch den folgenden Code:

//...
class ViewModelFactory constructor(
       private val tasksRepository: TasksRepository,
       private val shortcutsRepository: ShortcutsRepository,
       owner: SavedStateRegistryOwner,
       defaultArgs: Bundle? = null
) : AbstractSavedStateViewModelFactory(owner, defaultArgs) {

   override fun <T : ViewModel> create(
           key: String,
           modelClass: Class<T>,
           handle: SavedStateHandle
   ) = with(modelClass) {
       when {
           isAssignableFrom(StatisticsViewModel::class.java) ->
               StatisticsViewModel(tasksRepository)
           isAssignableFrom(TaskDetailViewModel::class.java) ->
               TaskDetailViewModel(tasksRepository, shortcutsRepository)
           isAssignableFrom(AddEditTaskViewModel::class.java) ->
               AddEditTaskViewModel(tasksRepository, shortcutsRepository)
           isAssignableFrom(TasksViewModel::class.java) ->
               TasksViewModel(tasksRepository, handle)
           else ->
               throw IllegalArgumentException("Unknown ViewModel class: ${modelClass.name}")
       }
   } as T
}

Öffnen Sie als Nächstes TaskDetailViewModel. Importieren Sie das ShortcutsRepository-Modul und deklarieren Sie mit dem folgenden Code eine Instanzvariable dafür:

TaskDetailViewModel.kt

package com.example.android.architecture.blueprints.todoapp.taskdetail

...
import com.example.android.architecture.blueprints.todoapp.data.source.ShortcutsRepository


/**
* ViewModel for the Details screen.
*/
class TaskDetailViewModel(
       //...
       private val shortcutsRepository: ShortcutsRepository
   ) : ViewModel() {
...
}

Ändern Sie schließlich die Funktion deleteTask() so, dass shortcutsRepository aufgerufen wird, um eine Verknüpfung anhand ihrer ID zu entfernen, wenn eine Aufgabe mit einem entsprechenden taskId gelöscht wird:

TaskDetailViewModel.kt

fun deleteTask() = viewModelScope.launch {
   _taskId.value?.let {
       //...
       shortcutsRepository.removeShortcutsById(listOf(it))
   }
}

So testen Sie Ihren Code: Starten Sie die App neu und gehen Sie so vor:

  1. Löschen Sie die Testaufgabe.
  2. Benennen Sie den Titel des vorhandenen Aufgabenpostens in „Codelab abschließen“ um.
  3. Öffnen Sie Google Assistant, indem Sie „Hey Google, meine Verknüpfungen“ sagen.
  4. Tippen Sie auf den Tab Entdecken. Prüfen Sie, ob die Testverknüpfung nicht mehr angezeigt wird.

7. Nächste Schritte

Das wars! Dank dir können Nutzer unserer Beispiel-App ganz einfach zu den Notizen zurückkehren, die sie erstellt haben, indem sie Assistant z. B. fragen: Hey Google, öffne meine Einkaufsliste in Beispiel-App. Verknüpfungen fördern eine stärkere Nutzerinteraktion, da Nutzer häufig verwendete Aktionen in Ihrer App ganz einfach wiederholen können.

Behandelte Themen

In diesem Codelab haben Sie Folgendes gelernt:

  • Anwendungsfälle für das Pushen dynamischer Verknüpfungen in einer App identifizieren
  • Reduzieren Sie die Codekomplexität mithilfe von Repository-, Dependency Injection- und Service Locator-Designmustern.
  • Sprachaktivierte dynamische Verknüpfungen zu von Nutzern erstellten App-Inhalten pushen
  • Vorhandene Verknüpfungen aktualisieren und entfernen

Nächste Schritte

Von hier aus können Sie weitere Verbesserungen an Ihrer Aufgabenlisten-App vornehmen. Das fertige Projekt finden Sie auf GitHub im Repository –codelab-complete branch.

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 zum Schluss bitte diese Umfrage aus, um Feedback zu diesem Codelab zu geben.