Integracja widżetów na Androida z Asystentem Google

1. Przegląd

W pierwszym ćwiczeniu dotyczącym akcji w aplikacji dowiedzieliśmy się, jak rozszerzyć Asystenta Google o przykładową aplikację treningową, wdrażając wbudowane intencje (BII) z kategorii BII dotyczących Zdrowia i fitnessu.

Akcje w aplikacji umożliwiają użytkownikom bezpośrednie uruchamianie konkretnych funkcji aplikacji z poziomu Asystenta, np. poprzez wypowiedzenie polecenia „OK Google, rozpocznij bieg w aplikacji ExampleApp”. Oprócz uruchamiania aplikacji Asystent może wyświetlać użytkownikowi interaktywny widżet Androida, aby realizować prośby dotyczące kwalifikujących się wbudowanych intencji.

Ekran przedstawiający Asystenta zwracającego widżet w odpowiedzi na zapytanie użytkownika, które wywołało funkcję GET_EXERCISE_OBSERVATION BII aplikacji.

Co utworzysz

Z tych ćwiczeń z programowania dowiesz się, jak zwracać widżety Androida w odpowiedzi na prośby użytkowników Asystenta. Dowiesz się też, jak:

  • Używaj parametrów BII użytkownika do personalizowania widżetów.
  • Zapewnij w Asystencie wprowadzenia w formie zamiany tekstu na mowę dla swoich widżetów.
  • Skorzystaj z dokumentacji wbudowanych intencji, aby sprawdzić, które wbudowane intencje obsługują realizację widżetów.

Wymagania wstępne

Zanim przejdziesz dalej, upewnij się, że Twoje środowisko programistyczne jest gotowe do tworzenia akcji w aplikacji. Powinien zawierać:

  • terminal do uruchamiania poleceń powłoki z zainstalowanym narzędziem git;
  • Najnowsza stabilna wersja Android Studio.
  • fizyczne lub wirtualne urządzenie z Androidem z dostępem do internetu;
  • konto Google zalogowane w Android Studio, aplikacji Google i aplikacji Asystent Google;

Jeśli używasz urządzenia fizycznego, połącz je z lokalnym komputerem używanym do programowania.

2. Jak to działa

Asystent Google wykorzystuje rozumienie języka naturalnego (NLU), aby odczytać prośbę użytkownika i dopasować ją do wbudowanej intencji Asystenta (BII). Asystent mapuje zamiar na funkcję (która implementuje BII) zarejestrowaną w aplikacji dla tego zamiaru. Na koniec Asystent spełnia żądanie użytkownika, wyświetlając widżet Androida wygenerowany przez aplikację na podstawie szczegółów znalezionych w funkcji.

W tym laboratorium kodowania zdefiniujesz funkcję, która rejestruje obsługę intencji wbudowanej GET_EXERCISE_OBSERVATION. W tej funkcji instruujesz Asystenta, aby generował intencję Androida dla klasy widżetu FitActions w celu realizacji żądań dotyczących tego BII. Aktualizujesz tę klasę, aby wygenerować spersonalizowany widżet, który Asystent może wyświetlać użytkownikowi, oraz wprowadzenie TTS, które Asystent może odczytywać.

Ten przepływ przedstawia poniższy diagram:

Schemat blokowy przedstawiający realizację widżetu Asystenta.

Widżet FitActions

Przykładowa aplikacja FitActions zawiera widżet z informacjami o treningu, który użytkownicy mogą dodać do ekranu głównego. Ten widżet świetnie nadaje się do odpowiadania na zapytania użytkowników, które uruchamiają interfejs BII GET_EXERCISE_OBSERVATION.

Jak działa widżet

Gdy użytkownik doda widżet do ekranu głównego, widżet wysyła ping do odbiornika transmisji na urządzeniu. Ta usługa pobiera informacje o widżecie z definicji odbiornika widżetu w zasobie AndroidManifest.xml aplikacji. Na podstawie tych informacji generuje obiekt RemoteViews reprezentujący widżet.

Przykładowa aplikacja definiuje odbiornik widgets.StatsWidgetProvider, który odpowiada klasie StatsWidgetProvider:

<!-- app/src/main/AndroidManifest.xml -->

<receiver
  android:name=".widgets.StatsWidgetProvider"
  android:exported="false">
  <intent-filter>
    <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
  </intent-filter>
  <meta-data
    android:name="android.appwidget.provider"
    android:resource="@xml/stats_widget" />
</receiver>

Klasa StatsWidgetProvider, StatsWidgetProvider.kt, zarządza procesami tworzenia obiektu StatsWidget. Odpowiada za:

  • tworzenie instancji widżetów i wypełnianie ich danymi o ćwiczeniach z bazy danych aplikacji;
  • Formatowanie danych treningu w celu zwiększenia czytelności za pomocą formatDataAndSetWidget().
  • Podawanie wartości domyślnych, jeśli dane o treningu są niedostępne, za pomocą setNoActivityDataWidget().

Dodawanie obsługi Asystenta

W tym ćwiczeniu z programowania zaktualizujesz przykładową aplikację, aby obsługiwała funkcję akcji w aplikacji. Oto co się zmieni:

  1. Konfigurowanie funkcji GET_EXERCISE_OBSERVATION BII w celu zwracania instancji obiektu StatsWidget.
  2. Aktualizacja klasy StatsWidget, aby korzystać z funkcji akcji w aplikacji, takich jak:
    • Używanie parametrów BII, które umożliwiają użytkownikom wyświetlanie konkretnych statystyk treningu poprzez zadawanie pytań typu „OK Google, pokaż moje statystyki biegu w aplikacji ExampleApp”.
    • Podawanie ciągów wprowadzających do TTS.
    • Zarządzanie przypadkami specjalnymi, np. gdy zapytanie użytkownika nie zawiera parametru typu treningu.

3. Przygotowywanie środowiska programistycznego

Pobieranie plików podstawowych

Aby skopiować repozytorium GitHub przykładowej aplikacji, uruchom to polecenie:

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

Po sklonowaniu repozytorium wykonaj te czynności, aby otworzyć je w Android Studio:

  1. W oknie Witamy w Android Studio kliknij Import project (Importuj projekt).
  2. Znajdź i wybierz folder, do którego sklonowano repozytorium.

Aby zobaczyć wersję aplikacji, która reprezentuje ukończone laboratorium, sklonuj repozytorium przykładowej aplikacji za pomocą flagi --branch master.

Aktualizowanie identyfikatora aplikacji na Androida

Aktualizacja identyfikatora aplikacji jednoznacznie identyfikuje aplikację na urządzeniu testowym i zapobiega wystąpieniu błędu „Zduplikowana nazwa pakietu”, jeśli aplikacja zostanie przesłana do Konsoli Play. Aby zaktualizować identyfikator aplikacji, otwórz app/build.gradle:

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

Zastąp „MYUNIQUENAME” w polu applicationId czymś unikalnym.

Instalowanie wtyczki testowej

Wtyczka Asystenta Google umożliwia testowanie akcji w aplikacji na urządzeniu testowym. Działa on poprzez wysyłanie informacji do Asystenta za pomocą aplikacji Google na urządzeniu z Androidem. Jeśli nie masz jeszcze wtyczki, zainstaluj ją, wykonując te czynności:

  1. Kliknij Plik > Ustawienia (Android Studio > Preferencje na macOS).
  2. W sekcji Wtyczki kliknij Marketplace i wyszukaj „Asystent Google”. Możesz też ręcznie pobrać i zainstalować narzędzie testowe.
  3. Zainstaluj narzędzie i ponownie uruchom Androida Studio.

Testowanie aplikacji na urządzeniu

Zanim wprowadzisz więcej zmian w aplikacji, warto zapoznać się z możliwościami przykładowej aplikacji.

Uruchom aplikację na urządzeniu testowym:

  1. W Android Studio wybierz urządzenie fizyczne lub urządzenie wirtualne, a następnie kliknij Uruchom > Uruchom aplikację lub UruchomIkona aplikacji uruchamiania w Android Studio. na pasku narzędzi.
  2. Przytrzymaj przycisk ekranu głównego, aby skonfigurować Asystenta i sprawdzić, czy działa. Jeśli jeszcze tego nie zrobisz, musisz zalogować się w Asystencie na urządzeniu.

Więcej informacji o wirtualnych urządzeniach z Androidem znajdziesz w artykule Tworzenie wirtualnych urządzeń i zarządzanie nimi.

Przejrzyj aplikację, aby zobaczyć, co potrafi. Aplikacja wstępnie wypełnia 10 aktywności związanych z ćwiczeniami i wyświetla te informacje w pierwszym widoku.

Wypróbuj dotychczasowy widżet

  1. Kliknij przycisk Ekran główny, aby otworzyć ekran główny urządzenia testowego.
  2. Naciśnij i przytrzymaj puste miejsce na ekranie głównym, a następnie wybierz Widżety.
  3. Przewiń listę widżetów do pozycji FitActions.
  4. Przytrzymaj ikonę FitActions i umieść widżet na ekranie głównym.

Zrzut ekranu przedstawiający widżet FitActions na ekranie głównym urządzenia.

4. Dodawanie działania w aplikacji

W tym kroku dodasz funkcję GET_EXERCISE_OBSERVATION BII. Aby to zrobić, dodaj nowy element capability w pliku shortcuts.xml. Ta funkcja określa, jak jest wywoływana, jak są używane parametry BII i które intencje Androida należy wywołać, aby zrealizować żądanie.

  1. Dodaj nowy element capability do zasobu shortcuts.xml w projekcie przykładowym z tą konfiguracją:
    <!-- 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>
    Zastąp wartość android:targetPackage, czyli PUT_YOUR_APPLICATION_ID_HERE, unikalnym identyfikatorem applicationId.

Ta funkcja mapuje GET_EXERCISE_OBSERVATION BII na intencję app-widget, dzięki czemu po wywołaniu BII widżet jest tworzony i wyświetlany użytkownikowi.

Przed uruchomieniem widżetu Asystent wyodrębnia z zapytania użytkownika obsługiwane parametry BII. To laboratorium kodu wymaga parametru BII exerciseObservation.aboutExercise.name, który reprezentuje typ ćwiczenia, o który prosi użytkownik. Aplikacja obsługuje 3 rodzaje ćwiczeń: „bieganie”, „spacer” i „jazda na rowerze”. Aby poinformować Asystenta o tych obsługiwanych wartościach, musisz podać spis wbudowanych zasobów.

  1. Zdefiniuj te elementy asortymentu, dodając tę konfigurację powyżej funkcji GET_EXERCISE_OBSERVATION do shortcuts.xml:
    <!-- shortcuts.xml -->

<!-- shortcuts are bound to the GET_EXERCISE_OBSERVATION capability and
     represent the types of exercises supported by the app. -->

<shortcut
  android:shortcutId="running"
  android:shortcutShortLabel="@string/activity_running">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/runningSynonyms"/>
  </capability-binding>
</shortcut>

<shortcut
  android:shortcutId="walking"
  android:shortcutShortLabel="@string/activity_walking">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/walkingSynonyms"/>
  </capability-binding>
</shortcut>

<shortcut
  android:shortcutId="cycling"
  android:shortcutShortLabel="@string/activity_cycling">
  <capability-binding android:key="actions.intent.GET_EXERCISE_OBSERVATION">
    <parameter-binding
      android:key="exerciseObservation.aboutExercise.name"
      android:value="@array/cyclingSynonyms"/>
  </capability-binding>
</shortcut>

<capability android:name="actions.intent.GET_EXERCISE_OBSERVATION">
  <!-- ... -->
</capability>

Dodawanie intencji zastępczej

Intencje rezerwowe obsługują sytuacje, w których zapytanie użytkownika nie może zostać zrealizowane, ponieważ brakuje w nim parametrów wymaganych przez funkcję. Funkcja GET_EXERCISE_OBSERVATION wymaga parametru exerciseObservation.aboutExercise.name określonego przez atrybut android:required="true". W takich sytuacjach Asystent wymaga zdefiniowania intencji rezerwowej, aby żądanie zostało zrealizowane, nawet jeśli w zapytaniu nie podano żadnych parametrów.

  1. W shortcuts.xml dodaj intencję rezerwową do funkcji GET_EXERCISE_OBSERVATION, korzystając z tej konfiguracji:
    <!-- 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>

W tej przykładowej konfiguracji realizacja zastępcza to intencja Androida bez parametrów w danych Extra.

5. Włączanie widżetu Asystenta

Po ustaleniu możliwości GET_EXERCISE_OBSERVATION zaktualizuj klasę widżetu, aby obsługiwała wywoływanie głosowe akcji w aplikacji.

Dodawanie biblioteki rozszerzeń widżetów

Biblioteka rozszerzeń widżetów akcji w aplikacji ulepsza widżety pod kątem funkcji głosowych Asystenta. Umożliwia on w szczególności dostarczanie niestandardowego wprowadzenia TTS dla widżetów.

  1. Dodaj zależność biblioteki rozszerzenia widżetów do zasobu przykładowej aplikacji /app/build.gradle:
    // app/build.gradle

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
    W wyświetlonym w Android Studio polu ostrzeżenia kliknij Synchronizuj teraz. Synchronizacja po każdej build.gradle zmianie pomaga uniknąć błędów podczas tworzenia aplikacji.

Dodawanie usługi widżetu

Usługa to komponent aplikacji, który może wykonywać długotrwałe operacje w tle. Aplikacja musi udostępniać usługę do przetwarzania żądań widżetów.

  1. Dodaj usługę do zasobu AndroidManifest.xml przykładowej aplikacji z tą konfiguracją:
    <!-- 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>

Podczas zapytania głosowego, które wywołuje realizację widżetu, Asystent używa tej usługi do wysyłania żądań do aplikacji. Usługa otrzymuje żądanie wraz z danymi BII. Usługa używa tych danych do wygenerowania RemoteView obiektu widżetu, który będzie renderowany w Asystencie.

Aktualizowanie klasy widżetu

Aplikacja jest teraz skonfigurowana tak, aby kierować żądania funkcji GET_EXERCISE_OBSERVATION do klasy widżetu. Następnie zaktualizuj klasę StatsWidget.kt, aby wygenerować instancję widżetu spersonalizowaną pod kątem żądania użytkownika przy użyciu wartości parametru BII.

  1. Otwórz klasę StatsWidget.kt i zaimportuj bibliotekę rozszerzenia widżetu akcji w aplikacji:
    // StatsWidget.kt

// ... Other import statements
import com.google.assistant.appactions.widgets.AppActionsWidgetExtension
  2. Dodaj te zmienne prywatne, których używasz do określania informacji, które mają być wyświetlane w widżecie:
    // StatsWidget.kt

private val hasBii: Boolean
private val isFallbackIntent: Boolean
private val aboutExerciseName: String
private val exerciseType: FitActivity.Type
  3. Dodaj funkcję init, aby klasa mogła korzystać z danych opcji widżetu przekazywanych przez Asystenta:
    // 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)
}

Zobaczmy, jak te aktualizacje umożliwiają klasie StatsWidget.kt odpowiadanie na intencje Androida generowane przez funkcję GET_EXERCISE_OBSERVATION:

  • optionsBundle = Pakiet
    • Pakiety to obiekty, które są przeznaczone do używania w różnych procesach, między aktywnościami z intencjami oraz do przechowywania stanu przejściowego w przypadku zmian konfiguracji. Asystent używa obiektów Bundle do przekazywania danych konfiguracyjnych do widżetu.
  • bii = actions.intent.GET_EXERCISE_OBSERVATION
    • Nazwa BII jest dostępna w pakiecie za pomocą AppActionsWidgetExtension.
  • hasBii = true
    • Sprawdza, czy występuje BII.
  • params = Bundle[{aboutExerciseName=running}]
    • Specjalny pakiet wygenerowany przez akcje w aplikacji jest zagnieżdżony w opcjach widżetu Bundle. Zawiera pary klucz-wartość BII. W tym przypadku wartość running została wyodrębniona z przykładowego zapytania „OK Google, pokaż moje statystyki biegania w aplikacji ExampleApp”.
  • isFallbackIntent = false
    • Sprawdza, czy w intencji Extras znajdują się wymagane parametry BII.
  • aboutExerciseName = running
    • Pobiera wartość intencji Extras dla aboutExerciseName.
  • exerciseType = RUNNING
    • Używa aboutExerciseName do wyszukiwania odpowiedniego obiektu typu bazy danych.

Teraz, gdy klasa StatsWidget może przetwarzać przychodzące dane intencji Androida dotyczące działań w aplikacji, zaktualizuj logikę procesu tworzenia widżetu, aby sprawdzić, czy został on wywołany przez działanie w aplikacji.

  1. W pliku StatsWidget.kt zastąp funkcję updateAppWidget() tym kodem:
    // 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()
}

Powyższy kod odwołuje się do nowej funkcji observeAndUpdateRequestedExercise. Ta funkcja generuje dane widżetu za pomocą danych parametru exerciseType przekazywanych przez intencję Androida dotyczącą akcji w aplikacji.

  1. Dodaj funkcję observeAndUpdateRequestedExercise za pomocą tego kodu:
    // 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()
       }
   }
}

W powyższym kodzie użyj istniejącej klasy repository w aplikacji, aby pobrać dane o aktywności fizycznej z lokalnej bazy danych aplikacji. Ta klasa udostępnia interfejs API, który upraszcza dostęp do bazy danych. Repozytorium udostępnia obiekt LiveData podczas wykonywania zapytań do bazy danych. W kodzie widzisz ten element LiveData, który służy do pobierania najnowszej aktywności związanej z fitness.

Włączanie funkcji TTS

Możesz podać ciąg znaków TTS, który Asystent odczyta na głos podczas wyświetlania widżetu. Zalecamy dodanie tej funkcji, aby zapewnić kontekst dźwiękowy widżetów. Ta funkcja jest dostępna w bibliotece rozszerzenia widżetów działań w aplikacji, która umożliwia ustawianie tekstu i wstępów TTS towarzyszących widżetom w Asystencie.

Dobrym miejscem na wprowadzenie TTS jest funkcja formatDataAndSetWidget, która formatuje dane o aktywności zwracane z bazy danych aplikacji.

  1. W pliku StatsWidget.kt dodaj ten kod do funkcji formatDataAndSetWidget:
    // StatsWidget.kt

private fun formatDataAndSetWidget(
  activityStat: FitActivity,
) {
      // ...

      // Add conditional for hasBii for widget with data
      if (hasBii) {
         // Formats TTS speech and display text for Assistant
         val speechText = context.getString(
             R.string.widget_activity_speech,
             activityExerciseTypeFormatted,
             formattedDate,
             durationInMin,
             distanceInKm
         )
         val displayText = context.getString(
             R.string.widget_activity_text,
             activityExerciseTypeFormatted,
             formattedDate
         )
         setTts(speechText, displayText)
      }
}

Powyższy kod odwołuje się do 2 zasobów ciągów tekstowych: jednego dla mowy, a drugiego dla tekstu. W filmie o widgetach znajdziesz rekomendacje dotyczące stylu zamiany tekstu na mowę. W przykładzie znajduje się też odwołanie do setTts, nowej funkcji, która przekazuje informacje TTS do instancji widżetu.

  1. Dodaj tę nową funkcję setTts do StatsWidget.kt za pomocą tego kodu:
    // 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)
}

Na koniec uzupełnij logikę TTS, ustawiając informacje TTS, gdy baza danych ćwiczeń zwraca puste dane dla żądanego typu treningu.

  1. Zaktualizuj funkcję setNoActivityDataWidget() w pliku StatsWidget.kt za pomocą tego kodu:
    // 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. Testowanie działania w aplikacji

Podczas programowania używaj wtyczki Asystenta Google, aby wyświetlać podgląd akcji w aplikacji Asystenta na urządzeniu testowym. Za pomocą tego narzędzia możesz dostosowywać parametry intencji w przypadku działania aplikacji, aby sprawdzić, jak działa ono w różnych sytuacjach, w których użytkownik może poprosić Asystenta o jego uruchomienie.

Tworzenie wersji przedpremierowej

Aby przetestować działanie aplikacji za pomocą wtyczki:

  1. Kliknij Narzędzia > Asystent Google > Narzędzie do testowania akcji w aplikacji. Może pojawić się prośba o zalogowanie się w Android Studio przy użyciu konta Google.
  2. Kliknij Utwórz podgląd. Jeśli pojawi się taka prośba, zapoznaj się z zasadami dotyczącymi akcji w aplikacji i warunkami korzystania z usługi i je zaakceptuj.

Testowanie oczekiwanego typu ćwiczenia

Aby zwrócić widżet z informacjami o ostatnim ukończonym biegu w aplikacji, wykonaj te czynności w narzędziu testowym:

  1. W pierwszym kroku, w którym narzędzie prosi o wybranie i skonfigurowanie BII, kliknij actions.intent.GET_EXERCISE_OBSERVATION.
  2. W polu exerciseObservation zmień domyślną nazwę ćwiczenia z climbing na run.
  3. Kliknij Uruchom działanie aplikacji.

Ekran przedstawiający widżet zwrócony za pomocą wtyczki Asystenta Google.

Testowanie nieoczekiwanego rodzaju ćwiczeń

Aby przetestować w narzędziu testowym nieoczekiwany typ ćwiczenia:

  1. W polu exerciseObservation zmień wartość name z Run na Climbing.
  2. Kliknij Uruchom działanie aplikacji.

Asystent powinien zwrócić widżet z informacją „Nie znaleziono aktywności”.

Ekran przedstawiający widżet bez informacji o ćwiczeniach zwróconych za pomocą wtyczki Asystenta Google.

Testowanie intencji rezerwowej

Zapytania wywołujące intencję rezerwową powinny zwracać widżet z informacjami o ostatniej zarejestrowanej aktywności dowolnego typu ćwiczeń.

Aby przetestować intencję rezerwową:

  1. W polu exerciseObservation usuń obiekt aboutExercise.
  2. Kliknij Uruchom działanie aplikacji.

Asystent powinien zwrócić widżet z informacjami o ostatnim ukończonym ćwiczeniu.

Ekran z widżetem wyświetlającym ostatnią zarejestrowaną aktywność za pomocą wtyczki Asystenta Google.

7. Dalsze kroki

Gratulacje!

Możesz teraz odpowiadać na zapytania użytkowników za pomocą widżetu na Androida z Asystentem.

Omówione zagadnienia

Z tego modułu dowiedzieliśmy się, jak:

  • Dodawanie widżetu aplikacji do skrótu BII
  • Zmodyfikuj widżet, aby uzyskać dostęp do parametrów z Android Extras.

Co dalej?

Możesz teraz wprowadzić dalsze ulepszenia aplikacji treningowej. Aby zapoznać się z ukończonym projektem, otwórz główne repozytorium w GitHubie.

Oto kilka sugestii, które pomogą Ci dowiedzieć się więcej o rozszerzaniu tej aplikacji za pomocą akcji w aplikacji:

Aby kontynuować przygodę z Actions on Google, zapoznaj się z tymi materiałami:

Obserwuj nas na Twitterze @ActionsOnGoogle, aby być na bieżąco z najnowszymi ogłoszeniami, i publikuj tweety z hasztagiem #appactions, aby dzielić się swoimi osiągnięciami.

Ankieta do zbierania opinii

Na koniec wypełnij tę ankietę, aby podzielić się opinią na temat tego laboratorium.