Informationen zu diesem Codelab
1. Übersicht
Im vorherigen Codelab haben Sie mithilfe von statischen Tastenkürzeln häufig verwendete vordefinierte Intents (BII) in einer Beispiel-App implementiert. Android-Entwickler verwenden App-Aktionen, um die App-Funktionen auf Google Assistant auszuweiten.
Statische Verknüpfungen sind mit einer App gebündelt und können nur aktualisiert werden, wenn neue Versionen der App veröffentlicht werden. Sprachfunktionen für dynamische Elemente wie von Nutzern erstellte Inhalte in einer App können über dynamische Verknüpfungen aktiviert werden. Apps senden dynamische Verknüpfungen, nachdem Nutzer relevante Aktionen ausgeführt haben, z. B. das Erstellen einer neuen Notiz in einer Aufgabenverfolgungs-App. Mit App Actions kannst du diese Verknüpfungen für Sprachbefehle aktivieren, indem du sie mit einem BII verknüpfst. So können Nutzer beispielsweise auf ihre Inhalte über Assistant zugreifen, indem sie sagen: „Hey Google, öffne meine Einkaufsliste in ExampleApp.“
Abbildung 1. Drei progressive Bildschirme mit einer vom Nutzer erstellten Aufgabe und Google Assistant, der eine dynamische Verknüpfung zu diesem Aufgabenelement startet.
Aufgaben
In diesem Codelab aktivieren Sie dynamische Verknüpfungen für die Spracheingabe in einer Beispiel-To-do-Liste-App für Android. So können Nutzer Assistant bitten, die in der App erstellten Aufgabenlistenelemente zu öffnen. Dazu verwenden Sie Android-Architekturmuster, insbesondere die Muster Repository, Service Locator und ViewModel.
Vorbereitung
Dieses Codelab basiert auf den App Actions-Konzepten, die im vorherigen Codelab behandelt wurden, insbesondere auf BIIs und statischen Tastenkombinationen. Wenn du noch nicht mit App Actions vertraut bist, empfehlen wir dir, dieses Codelab durchzuarbeiten, bevor du fortfährst.
Außerdem muss Ihre Entwicklungsumgebung die folgende Konfiguration haben, bevor Sie fortfahren:
- Ein Terminal zum Ausführen von Shell-Befehlen mit installiertem Git.
- 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.
2. Funktionsweise
So aktivieren Sie eine dynamische Verknüpfung für den Sprachzugriff:
- Dynamische Verknüpfung mit einem geeigneten BII verknüpfen
- Assistant erlauben, die Verknüpfungen durch Hinzufügen der Google Shortcuts Integration Library aufzunehmen.
- Pushen Sie einen Verknüpfungs-Messwert, wenn ein Nutzer die entsprechende In-App-Aufgabe abgeschlossen hat.
Tastenkürzel für die Verknüpfung
Damit ein dynamischer Shortcut über Assistant aufgerufen werden kann, muss er mit einer relevanten BII verknüpft sein. Wenn eine BII mit einer Verknüpfung ausgelöst wird, gleicht Assistant die Parameter in der Nutzeranfrage mit den im verknüpften Shortcut definierten Keywords ab. Beispiel:
- Mit einem Shortcut, der an den BII
GET_THINGgebunden ist, können Nutzer bestimmte In-App-Inhalte direkt über Assistant anfordern. * „Hey Google, öffne meine Einkaufsliste in ExampleApp.“ - Über eine Verknüpfung, die mit dem BII
START_EXERCISEverknüpft ist, können Nutzer ihre Trainingseinheiten sehen. * „Hey Google, bitte BeispielApp, meine übliche Übung zu starten.“
Eine vollständige kategorisierte Liste der vordefinierten Intents finden Sie in der Referenz zu vordefinierten Intents.
Verknüpfungen für Assistant bereitstellen
Nachdem Sie Ihre Verknüpfungen an eine BII gebunden haben, müssen Sie Assistant erlauben, diese Verknüpfungen zu verarbeiten. Fügen Sie dazu Ihrem Projekt die Bibliothek „Google Shortcuts Integration“ hinzu. Wenn diese Bibliothek vorhanden ist, erkennt Assistant jede von deiner App ausgelöste Verknüpfung. So können Nutzer diese über den entsprechenden Trigger in Assistant starten.
3. Bereiten Sie Ihre Entwicklungsumgebung vor
In diesem Codelab wird eine für Android entwickelte Beispiel-App für To-do-Listen verwendet. Mit dieser App können Nutzer Listen Elemente hinzufügen, nach Kategorie nach Aufgabenlistenelementen suchen und Aufgaben nach Abschlussstatus filtern. Laden Sie die Beispiel-App herunter und bereiten Sie sie vor. Füllen Sie dazu diesen Abschnitt aus.
Basisdateien herunterladen
Führen Sie den folgenden Befehl aus, um das GitHub-Repository der Beispielanwendung zu klonen:
git clone https://github.com/actions-on-google/app-actions-dynamic-shortcuts.git
Nachdem Sie das Repository geklont haben, können Sie es in Android Studio öffnen. Gehen Sie dazu so vor:
- Klicken Sie im Dialogfeld Willkommen bei Android Studio auf Projekt importieren.
- Wählen Sie den Ordner aus, in dem Sie das Repository geklont haben.
Alternativ können Sie eine Version der Beispiel-App aufrufen, die das abgeschlossene Codelab darstellt. Klonen Sie dazu den codelab-complete-Zweig des GitHub-Repositorys:
git clone https://github.com/actions-on-google/app-actions-dynamic-shortcuts.git --branch codelab-complete
Android-App-ID aktualisieren
Wenn Sie die Anwendungs-ID der App aktualisieren, wird die App auf Ihrem Testgerät eindeutig identifiziert und der Fehler „Paketname doppelt“ wird vermieden, wenn die App in die Play Console hochgeladen wird. So aktualisieren Sie die App-ID:
android {
...
defaultConfig {
applicationId "com.MYUNIQUENAME.android.fitactions"
...
}
}
Ersetzen Sie „MYUNIQUENAME“ im Feld applicationId durch einen eindeutigen Namen.
Shortcuts API-Abhängigkeiten 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 ein Bild davon machen, was die Beispiel-App leisten kann. So führen Sie die App in Ihrem Emulator aus:
- Wählen Sie in Android Studio „Ausführen“ > „App ausführen“ aus oder klicken Sie in der Symbolleiste auf Ausführen
. - Wählen Sie im Dialogfeld Bereitstellungsziel auswählen ein Gerät aus und klicken Sie auf OK. Wir empfehlen Android 10 (API-Level 30) oder höher. App Actions funktioniert jedoch auch auf Geräten ab Android 5 (API-Level 21).
- Drücken Sie lange auf die Startbildschirmtaste, 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 erfahren, was sie kann. Durch Tippen auf das Plussymbol wird ein neues Aufgabenelement erstellt. Über die Menüpunkte oben rechts können Sie nach Aufgabenelementen suchen und sie nach Abschlussstatus filtern.
4. Verknüpfungs-Repository-Klasse erstellen
Mehrere Klassen in unserer Beispiel-App rufen die ShortcutManagerCompat API auf, um dynamische Verknüpfungen zu übertragen und zu verwalten. Um Coderedundanz zu reduzieren, implementieren Sie ein Repository, mit dem Ihre Projektklassen dynamische Verknüpfungen ganz einfach verwalten können.
Das Repository-Designmuster bietet eine einfache API zum Verwalten von Verknüpfungen. Ein Repository hat den Vorteil, dass die Details der zugrunde liegenden API einheitlich hinter einer minimalen API abstrahiert werden. So implementieren Sie das Repository:
- Erstellen Sie eine
ShortcutsRepository-Klasse, um dieShortcutManagerCompatAPI zu abstrahieren. - Fügen Sie dem Diensteanbieter der App
ShortcutsRepository-Methoden hinzu. - Registrieren Sie den
ShortcutRepository-Dienst 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. Dieses Paket finden Sie im Ordner app/src/main/java. Mit dieser Klasse implementieren Sie eine Schnittstelle, die eine minimale Reihe von Methoden bietet, die unseren Codelab-Anwendungsfall abdecken.
Abbildung 2: Android Studio-Fenster „Projektdateien“ mit dem Speicherort der ShortcutsRepository-Klasse.
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 Klasse ShortcutsRepository 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 wurde appContext an die API übergeben. Dies ist eine Klasseneigenschaft, die einen Anwendungskontext enthält. Es ist wichtig, einen Anwendungskontext und nicht einen Aktivitätskontext zu verwenden, um Speicherlecks zu vermeiden, da der Kontext möglicherweise länger aufbewahrt wird als der Lebenszyklus der Hostaktivität.
Außerdem müssen wir gemäß der API ein ShortcutInfoCompat-Objekt für das Aufgabenobjekt übergeben. 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 Stub createShortcutCompat 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()
}
Bei den verbleibenden Funktions-Stubs in dieser Klasse geht es um das Aktualisieren und Löschen dynamischer Tastenkombinationen. 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 zu Service Locator hinzufügen
Nachdem die Klasse ShortcutsRepository erstellt wurde, besteht der nächste Schritt darin, instanziierte Objekte dieser Klasse für den Rest der App verfügbar zu machen. Diese Anwendung verwaltet Klassenabhängigkeiten, indem sie das Muster Service Locator implementiert. Öffnen Sie die Service Locator-Klasse mit dem Klassenbrowser in Android Studio. Klicken Sie dazu auf Navigation > Class (Klasse) 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 von ShortcutRepository hinzu, indem Sie den folgenden Code in den Body 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 den neuen ShortcutsRepository-Dienst bei der Anwendung. Öffnen Sie in Android Studio TodoApplication.kt und kopieren Sie den folgenden Code oben in 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 als Nächstes den Dienst, indem Sie dem Body der Klasse den folgenden Code hinzufü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. Neuen Kurzbefehl per Push übertragen
Nachdem Sie den Shortcut-Dienst erstellt haben, können Sie Verknüpfungen erstellen. Da Nutzer in dieser App Inhalte (Aufgabenelemente) erstellen und davon ausgehen, dass sie später darauf zugreifen können, wird der Zugriff auf diese Inhalte per Sprachbefehl aktiviert. Dazu wird jedes Mal, wenn ein Nutzer eine neue Aufgabe erstellt, ein dynamischer Shortcut gesendet, der an den BII GET_THING gebunden ist. So kann Assistant Nutzer direkt zur gewünschten Aufgabe weiterleiten, wenn sie den BII auslösen, indem sie beispielsweise Folgendes fragen: „Hey Google, öffne meine Einkaufsliste in SampleApp.“
So aktivieren Sie diese Funktion in der Beispiel-App:
- Importieren Sie den
ShortcutsRepository-Dienst in dieAddEditTaskViewModel-Klasse, die für die Verwaltung von Aufgabenlistenobjekten verantwortlich ist. - Einen dynamischen Verknüpfungs-Push senden, wenn der Nutzer eine neue Aufgabe erstellt.
ShortcutsRepository importieren
Zuerst muss der ShortcutsRepository-Dienst für AddEditTaskViewModel verfügbar gemacht werden. Importieren Sie dazu den Dienst in ViewModelFactory, die Factory-Klasse, mit der die App ViewModel-Objekte instanziiert, einschließlich AddEditTaskViewModel.
Öffnen Sie den Klassenbrowser in Android Studio. Klicken Sie dazu auf Navigieren > Klasse 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 Text 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 Änderungen an ViewModelFactory ab, indem Sie eine Ebene nach oben gehen und ShortcutsRepository an den Konstruktor der Fabrik übergeben. Öffnen Sie den Dateibrowser von Android Studio. Wählen Sie dazu Navigieren > Datei 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 Body 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)
}
Tastenkombination drücken
Wenn die Abstraktionsklasse ShortcutsRepository für die ViewModel-Klassen der Beispiel-App verfügbar ist, aktualisieren Sie die Klasse AddEditTaskViewModel, die für das Erstellen von Notizen verantwortlich ist, so, dass jedes Mal, wenn ein Nutzer eine neue Notiz erstellt, eine dynamische Verknüpfung gesendet wird.ViewModel
Ö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 dieser Klasse zuerst das ShortcutsRepository-Paket mit der folgenden Importanweisung 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 das Klassenattribut 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() {
//...
Erstellen Sie mit der hinzugefügten Klasse ShortcutsRepository die 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 Verknüpfungshinweis, 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
Endlich können wir unseren Code testen. In diesem Schritt senden Sie eine dynamische Verknüpfung mit Sprachsteuerung und prüfen sie mit der Google Assistant App.
Vorschau erstellen
Wenn Sie mit dem Google Assistant-Plug-in eine Vorschau 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. Gehen Sie dazu so vor:
- Gehen Sie zu **Datei > Einstellungen (Android Studio > Einstellungen unter macOS).
- Rufen Sie im Abschnitt Plug-ins den Marketplace auf und suchen Sie nach „Google Assistant“.
- Wenn Sie das Plug-in nicht im Marketplace finden, laden Sie es manuell herunter und folgen Sie der Anleitung unter Plug-in von der Festplatte installieren.
- Installieren Sie das Tool und starten Sie Android Studio neu.
Vorschau erstellen
So erstellen Sie in Android Studio eine Vorschau:
- Klicken Sie auf Tools > Google Assistant > App Actions Test Tool.
- Geben Sie im Feld App-Name einen Namen wie „To-do-Liste“ ein.
- Klicken Sie auf Vorschau erstellen. Wenn du dazu aufgefordert wirst, lies und akzeptiere die Richtlinien und Nutzungsbedingungen für App Actions.
Abbildung 3: Der Bereich zum Erstellen der Vorschau im App Actions-Testtool
Während des Tests werden dynamische Verknüpfungen, die Sie an Assistant senden, in Assistant nach dem App-Namen sortiert angezeigt, den Sie für die Vorschau angegeben haben.
Verknüpfung senden und prüfen
Starten Sie die Beispiel-App auf Ihrem Testgerät neu und führen Sie die folgenden Schritte aus:
- Erstelle eine neue Aufgabe mit dem Titel „Codelab starten“
- Öffne die Google Assistant App und sag „Meine Verknüpfungen“ oder gib es ein.
- Tippe auf den Tab Entdecken. Sie sollten die Beispielverknüpfung sehen.
- Tippen Sie auf die Verknüpfung, um sie aufzurufen. Beim Starten der App sollte der Name der Verknüpfung bereits im Filterfeld eingetragen sein, damit Sie die gewünschte Aufgabe einfach finden können.
6. Optional: Verknüpfung aktualisieren und löschen
Ihre App kann nicht nur neue dynamische Verknüpfungen zur Laufzeit senden, sondern sie auch aktualisieren, um den aktuellen Status der Nutzerinhalte und -einstellungen widerzuspiegeln. Es empfiehlt sich, vorhandene Verknüpfungen jedes Mal zu aktualisieren, wenn ein Nutzer das Zielelement ändert, z. B. eine Aufgabe in unserer Beispiel-App umbenennen. Sie sollten auch eine entsprechende Verknüpfung löschen, wenn die Zielressource entfernt wird, damit dem Nutzer keine fehlerhaften Verknüpfungen angezeigt werden.
Verknüpfung aktualisieren
Ändern Sie AddEditTaskViewModel, um einen dynamischen Verknüpfungs-Shortcut zu aktualisieren, wenn ein Nutzer die Details eines Aufgabenelements ä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))
}
Ändern Sie als Nächstes die Funktion saveTask() so, dass unsere neue Methode jedes Mal 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 folgende Schritte ausführen:
- Benennen Sie den Titel des vorhandenen Aufgabenelements in „Codelab beenden“ um.
- Öffnen Sie Google Assistant, indem Sie „Hey Google, meine Verknüpfungen“ sagen.
- Tippe auf den Tab Entdecken. Sie sollten ein aktualisiertes Kurzlabel für Ihre Testverknüpfung sehen.
Verknüpfung entfernen
Unsere Beispiel-App-Verknüpfungen sollten entfernt werden, wenn ein Nutzer eine Aufgabe löscht. In der Beispiel-App befindet sich die Logik für das Löschen von Aufgaben in der Klasse TaskDetailViewModel. Bevor wir diesen Kurs aktualisieren, müssen wir ViewModelFactory noch einmal aktualisieren, um shortcutsRepository an 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 abschließend die Funktion deleteTask() so, dass shortcutsRepository aufgerufen wird, um einen Verknüpfung basierend auf ihrer ID zu entfernen, wenn eine Aufgabe mit einer entsprechenden taskId gelöscht wird:
TaskDetailViewModel.kt
fun deleteTask() = viewModelScope.launch {
_taskId.value?.let {
//...
shortcutsRepository.removeShortcutsById(listOf(it))
}
}
Wenn Sie Ihren Code testen möchten, starten Sie die App neu und führen Sie die folgenden Schritte aus:
- Löschen Sie die Testaufgabe.
- Benennen Sie den Titel des vorhandenen Aufgabenelements in „Codelab fertigstellen“ um.
- Öffnen Sie Google Assistant, indem Sie „Hey Google, meine Verknüpfungen“ sagen.
- Tippe auf den Tab Entdecken. Vergewissern Sie sich, dass die Testverknüpfung nicht mehr angezeigt wird.
7. Nächste Schritte
Glückwunsch! Dank Ihnen können Nutzer unserer Beispiel-App ganz einfach zu ihren Notizen zurückkehren, indem sie Assistant Dinge wie „Hey Google, öffne meine Einkaufsliste in ExampleApp“ sagen. Verknüpfungen fördern die Nutzerinteraktion, da Nutzer häufig verwendete Aktionen in Ihrer App ganz einfach wiederholen können.
Behandelte Themen
In diesem Codelab haben Sie Folgendes gelernt:
- Identifizieren Sie Anwendungsfälle für die Übermittlung dynamischer Verknüpfungen in einer App.
- Reduzieren Sie die Codekomplexität mithilfe von Repository, Abhängigkeitsinjektion und Designmustern für die Dienstsuche.
- Sende sprachgesteuerte dynamische Verknüpfungen zu von Nutzern erstellten App-Inhalten.
- Vorhandene Verknüpfungen aktualisieren und entfernen.
Nächste Schritte
Sie können jetzt versuchen, Ihre Aufgabenliste weiter zu optimieren. Das fertige Projekt finden Sie im Repository –codelab-complete branch auf GitHub.
Hier finden Sie einige Vorschläge, wie Sie diese App mit App Actions erweitern können:
- Sehen Sie sich das Beispiel für eine Aufgabenliste mit Google Analytics for Firebase an, um zu erfahren, wie Sie die Leistung Ihrer App Actions erfassen.
- Weitere Möglichkeiten zur Erweiterung deiner Apps auf Assistant findest du in der Referenz zu integrierten Intents für App Actions.
Hier finden Sie weitere Informationen zu Actions on Google:
- actions.google.com: Offizielle Dokumentationswebsite für Actions on Google
- App Actions-Beispielindex: Beispiel-Apps und Code zum Testen der Funktionen von App Actions.
- Actions on Google GitHub-Repository: Beispielcode und Bibliotheken
- r/GoogleAssistantDev: Offizielle Reddit-Community für Entwickler, die mit Google Assistant arbeiten.
Folge uns auf Twitter unter @ActionsOnGoogle, um dich über unsere neuesten Ankündigungen zu informieren, und twittere unter #appActions, um deine Arbeit mit anderen zu teilen.
Feedback-Umfrage
Bitte nimm abschließend an dieser Umfrage teil, um uns Feedback zu deinen Erfahrungen mit diesem Codelab zu geben.