Integracja widżetów na Androida z Asystentem Google

1. Omówienie

W pierwszym ćwiczeniu z programowania App Actions pokazaliśmy Ci, jak rozszerzyć Asystenta Google o przykładową aplikację fitness przez wdrożenie intencji wbudowanych (BII) z kategorii Zdrowie i fitness BII.

Akcje w aplikacji umożliwiają użytkownikom uruchamianie określonych funkcji bezpośrednio w aplikacji za pomocą Asystenta. Mogą na przykład powiedzieć „OK Google, uruchom uruchomienie w aplikacji PrzykładowaAplikacja”. Oprócz uruchamiania aplikacji Asystent może wyświetlać użytkownikowi interaktywny widżet Androida, aby realizować prośby o odpowiednie wskaźniki BII.

Ekran pokazujący, jak Asystent zwraca widżet w odpowiedzi na zapytanie użytkownika, które uruchomiło funkcję GET_EXERCISE_OBSERVATION BII.

Co utworzysz

Z tego ćwiczenia w Codelabs dowiesz się, jak zwracać widżety Androida, aby spełniać prośby użytkowników Asystenta. Nauczysz się również:

  • Parametry BII użytkownika w celu spersonalizowania widżetów.
  • Włącz funkcję zamiany tekstu na mowę w Asystencie w przypadku widżetów.
  • Skorzystaj z dokumentu dotyczącego intencji wbudowanej, aby określić, które interfejsy BII 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 git.
  • Najnowsza stabilna wersja Android Studio.
  • Fizyczne lub wirtualne urządzenie z Androidem z dostępem do internetu.
  • konto Google zalogowane w Android Studio oraz w aplikacji Google i Asystent Google.

Jeśli używasz urządzenia fizycznego, podłącz je do komputera lokalnego.

2. Jak to działa

Asystent Google wykorzystuje rozumienie języka naturalnego (NLU), aby odczytać prośbę użytkownika i dopasować ją do wbudowanej w Asystenta intencji (BII). Asystent mapuje intencję na funkcję (która implementuje BII), którą rejestrujesz dla tej intencji w aplikacji. Na koniec Asystent wykonuje prośbę użytkownika, wyświetlając widżet Androida generowany przez aplikację, wykorzystując informacje o tej funkcji.

W tym ćwiczeniu w Codelabs definiujesz funkcję, która rejestruje obsługę GET_EXERCISE_OBSERVATION BII. W ramach tej funkcji otrzymujesz od Asystenta instrukcje generowania intencji Androida do klasy widżetu FitActions w celu realizacji żądań tego BII. Aktualizujesz te zajęcia, aby wygenerować spersonalizowany widżet, który Asystent będzie mógł wyświetlać użytkownikowi, oraz wprowadzenie do odczytywania tekstu przez Asystenta.

Ten schemat przedstawia proces:

Schemat procesu ilustrują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 doskonale nadaje się do realizowania zapytań użytkowników, które aktywują GET_EXERCISE_OBSERVATION BII.

Jak działa widżet

Gdy użytkownik doda widżet do ekranu głównego, widżet pinguje urządzenie Odbiornik transmisji. 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 obiektów StatsWidget. Zajmuje się tymi obowiązkami:

  • Tworzenie instancji widżetów i wypełnianie ich danymi ćwiczeń z bazy danych aplikacji.
  • Formatowanie danych treningowych w celu zapewnienia ich czytelności. Opcja formatDataAndSetWidget().
  • Jeśli dane treningowe są niedostępne, poda wartości domyślne za pomocą funkcji setNoActivityDataWidget().

Dodaj pomoc Asystenta

W ramach tego ćwiczenia w Codelabs dowiesz się, jak zaktualizować przykładową aplikację, aby obsługiwała akcje w aplikacji. Są to między innymi:

  1. Konfiguruję możliwość zwrócenia instancji obiektu StatsWidget w GET_EXERCISE_OBSERVATION BII.
  2. zaktualizowanie klasy StatsWidget, aby umożliwić korzystanie z funkcji akcji w aplikacji, takich jak:
    • Użycie parametrów BII, które umożliwiają użytkownikom wyświetlanie konkretnych statystyk treningowych i pytanie „OK Google, pokaż moje statystyki biegowe w Przypadku aplikacji”.
    • Podanie tekstu wprowadzenia do zamiany tekstu na mowę.
    • Zarządzanie szczególnymi przypadkami, np. gdy zapytanie użytkownika nie zawiera parametru typu treningu.

3. Przygotowywanie środowiska programistycznego

Pobieranie plików podstawowych

Uruchom to polecenie, aby sklonować repozytorium GitHub przykładowej aplikacji:

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 Importuj projekt.
  2. Znajdź i wybierz folder, do którego sklonowano repozytorium.

Aby zobaczyć wersję aplikacji reprezentującą ukończone ćwiczenia z programowania, skopiuj przykładowe repozytorium aplikacji za pomocą flagi --branch master.

Aktualizowanie identyfikatora aplikacji na Androida

Aktualizowanie identyfikatora aplikacji jednoznacznie identyfikuje aplikację na urządzeniu testowym i unika „zduplikowanej nazwy pakietu”. występuje wtedy, gdy aplikacja została 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.

Instalowanie wtyczki testowej

Wtyczka Asystent Google umożliwia testowanie akcji w aplikacji na urządzeniu testowym. Wysyłane informacje do Asystenta w aplikacji Google na urządzeniu z Androidem. Jeśli nie masz jeszcze tej wtyczki, zainstaluj ją, wykonując te czynności:

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

Testowanie aplikacji na urządzeniu

Przed wprowadzeniem kolejnych zmian w aplikacji warto zorientować się, jakie są jej możliwości.

Uruchom aplikację na urządzeniu testowym:

  1. W Android Studio wybierz urządzenie fizyczne lub wirtualne, a następnie kliknij Uruchom > Uruchom aplikację lub kliknij UruchomIkona aplikacji Uruchom w Android Studio. na pasku narzędzi.
  2. Przytrzymaj przycisk ekranu głównego, aby skonfigurować Asystenta i sprawdzić, czy działa. Musisz zalogować się w Asystencie na swoim urządzeniu (chyba że masz to już za sobą).

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

Omów krótko aplikację, aby poznać jej możliwości. Aplikacja wstępnie wprowadza 10 ćwiczeń i wyświetla te informacje przy pierwszym widoku.

Wypróbuj istniejący widżet

  1. Kliknij przycisk Strona główna, by wyświetlić ekran główny urządzenia testowego.
  2. Przytrzymaj puste miejsce na ekranie głównym i wybierz Widżety.
  3. Przewiń w dół listę widżetów do sekcji FitActions.
  4. Naciśnij i przytrzymaj ikonę FitActions i umieść widżet na ekranie głównym.

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

4. Dodaj działanie w aplikacji

W tym kroku dodajesz możliwość GET_EXERCISE_OBSERVATION BII. Aby to zrobić, dodaj nowy element capability w tagu shortcuts.xml. Ta funkcja określa, jak dana funkcja jest aktywowana, jak wykorzystywane są parametry BII i jakie intencje Androida mają wywoływać w celu realizacji żądania.

  1. Dodaj nowy element capability do zasobu przykładowego projektu shortcuts.xml 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 PUT_YOUR_APPLICATION_ID_HERE, unikalnym identyfikatorem applicationId.

Ta funkcja mapuje obiekt BII GET_EXERCISE_OBSERVATION na intencję app-widget, dzięki czemu po aktywowaniu funkcji BII widżet tworzy instancję i wyświetla się użytkownikowi.

Przed uruchomieniem widżetu Asystent wyodrębnia z zapytania użytkownika obsługiwane parametry BII. To ćwiczenie w Codelabs wymaga parametru BII exerciseObservation.aboutExercise.name, który reprezentuje typ ćwiczenia wybrany przez użytkownika. Aplikacja obsługuje trzy rodzaje ćwiczeń: bieganie, spacerowanie i jazda na rowerze. Dostarczasz wbudowany asortyment, aby poinformować Asystenta o tych obsługiwanych wartościach.

  1. Określ te elementy zasobów reklamowych, dodając tę konfigurację nad możliwością 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 zastępcze obsługują sytuacje, w których nie można zrealizować zapytania użytkownika, ponieważ w zapytaniu brakuje parametrów wymaganych przez tę funkcję. Funkcja GET_EXERCISE_OBSERVATION wymaga parametru exerciseObservation.aboutExercise.name określonego w atrybucie android:required="true". W takich sytuacjach Asystent wymaga zdefiniowania intencji zastępczej, aby żądanie zostało zrealizowane, nawet jeśli w zapytaniu nie ma żadnych parametrów.

  1. W elemencie shortcuts.xml dodaj intencję zastępczą do możliwości GET_EXERCISE_OBSERVATION, używając 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 realizację zastępczą jest intencja Androida bez parametrów w danych Extra.

5. Włącz widżet Asystenta

Gdy funkcja GET_EXERCISE_OBSERVATION będzie już dostępna, zaktualizuj klasę widżetu tak, aby obsługiwała głosowe wywołania akcji w aplikacji.

Dodaj bibliotekę rozszerzeń widżetów

Biblioteka rozszerzeń widżetów Akcje w aplikacji ulepsza widżety i ułatwia działanie Asystenta głosowego. Pozwala on przygotować własne wprowadzenie dla funkcji zamiany tekstu na mowę do widżetów.

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

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
    Kliknij Synchronizuj teraz w oknie ostrzeżenia, które pojawi się w Android Studio. Synchronizacja co build.gradle zmiany pomaga uniknąć błędów podczas tworzenia aplikacji.

Dodawanie usługi widżetów

Usługa to komponent aplikacji, który może wykonywać w tle długo trwające operacje. Aplikacja musi mieć 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 wykonywania zapytania głosowego, które aktywuje 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 generowania obiektu widżetu RemoteView do renderowania w Asystencie.

Zaktualizuj klasę widżetu

Aplikacja jest teraz skonfigurowana tak, aby kierować żądania możliwości GET_EXERCISE_OBSERVATION do klasy widżetu. Następnie zaktualizuj klasę StatsWidget.kt, aby wygenerować wystąpienie widżetu spersonalizowane pod kątem żądania użytkownika przy użyciu wartości parametrów BII.

  1. Otwórz zajęcia StatsWidget.kt i zaimportuj bibliotekę rozszerzenia widżetu Działania w aplikacji:
    // StatsWidget.kt

// ... Other import statements
import com.google.assistant.appactions.widgets.AppActionsWidgetExtension
  2. Dodaj te zmienne prywatne, które będą używane do określania informacji, które powinny wypełnić widżet:
    // StatsWidget.kt

private val hasBii: Boolean
private val isFallbackIntent: Boolean
private val aboutExerciseName: String
private val exerciseType: FitActivity.Type
  3. Dodaj funkcję init, aby umożliwić klasie korzystanie 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 reagowanie na intencje Androida generowane przez funkcję GET_EXERCISE_OBSERVATION:

  • optionsBundle = Pakiet
    • Pakiety to obiekty, które służą do przekraczania granic procesów, między działaniami z intencjami oraz do przechowywania stanu przejściowego po zmianach konfiguracji. Asystent używa obiektów Bundle, aby przekazywać do widżetu dane konfiguracyjne.
  • bii = actions.intent.GET_EXERCISE_OBSERVATION
    • Nazwa BII jest dostępna w pakiecie za pomocą AppActionsWidgetExtension.
  • hasBii = true
    • Sprawdza, czy nie występuje BII.
  • params = Bundle[{aboutExerciseName=running}]
    • W opcjach widżetu Bundle jest zagnieżdżony specjalny pakiet wygenerowany przez akcje w aplikacji. Zawiera pary klucz-wartość klucza BII. W tym przypadku wartość running została pobrana z przykładowego zapytania „OK Google, pokaż moje statystyki biegowe w PrzykładowaAplikacja”.
  • isFallbackIntent = false
    • Sprawdza obecność wymaganych parametrów BII w intencji Extras.
  • aboutExerciseName = running
    • Pobiera wartość intencji Extras dla: aboutExerciseName.
  • exerciseType = RUNNING
    • Wykorzystuje aboutExerciseName do wyszukiwania odpowiedniego obiektu typu bazy danych.

Gdy klasa StatsWidget może już przetwarzać przychodzące dane intencji Androida w działaniach aplikacji, zaktualizuj logikę procesu tworzenia widżetu, aby sprawdzić, czy widżet został wywołany przez działanie aplikacji.

  1. W 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()
}

Poprzedni kod odwołuje się do nowej funkcji: observeAndUpdateRequestedExercise. Ta funkcja generuje dane widżetu przy użyciu danych parametru exerciseType przekazanych przez intencję App Actions na Androida.

  1. Dodaj funkcję observeAndUpdateRequestedExercise z tym kodem:
    // 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 poprzednim kodzie użyj istniejącej klasy repozytorium znalezionej w aplikacji, aby pobrać dane fitness z lokalnej bazy danych aplikacji. Ta klasa udostępnia interfejs API upraszczający dostęp do bazy danych. Repozytorium działa przez ujawnianie obiektu LiveData podczas wykonywania zapytań do bazy danych. W swoim kodzie widzisz to miejsce (LiveData), aby pobrać najnowsze informacje o aktywności fizycznej.

Włącz zamianę tekstu na mowę

Możesz podać ciąg tekstowy zamiany tekstu na tekst, który Asystent będzie wypowiadać podczas wyświetlania widżetu. Warto go dodać, żeby widżety miały kontekst dźwiękowy. Ta funkcja jest dostępna w bibliotece rozszerzeń widżetów akcji aplikacji, która umożliwia ustawienie tekstu i wprowadzeń zamiany tekstu na tekst, które pojawią się w Asystencie w Asystencie.

Wprowadzenie do zamiany tekstu na mowę możesz umieścić w funkcji formatDataAndSetWidget, która formatuje dane o aktywności zwracane z bazy danych aplikacji.

  1. W StatsWidget.kt dodaj do funkcji formatDataAndSetWidget ten kod:
    // 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)
      }
}

Poprzedni kod odwołuje się do 2 zasobów ciągu znaków: mowy i tekstowych. Obejrzyj część naszego filmu o zalecaniu stylu zamiany tekstu na mowę, w której znajdziesz zalecenia dotyczące zamiany tekstu na mowę. W przykładzie odnosimy się też do setTts, nowej funkcji, która dostarcza informacje zamiany tekstu na mowę do instancji widżetu.

  1. Dodaj nową funkcję setTts do StatsWidget.kt, używając 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)
}

Zakończ logikę TTS, ustawiając informacje TTS, gdy baza danych ćwiczeń zwróci puste dane dla wybranego typu treningu.

  1. Zaktualizuj funkcję setNoActivityDataWidget() w 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 korzystaj z wtyczki Asystenta Google, aby wyświetlić podgląd akcji Asystenta na urządzeniu testowym. W tym narzędziu możesz dostosowywać parametry intencji dla akcji w aplikacji, aby przetestować różne sposoby, w jakie użytkownik może poprosić Asystenta o jej uruchomienie.

Tworzenie wersji przedpremierowej

Aby przetestować akcję w aplikacji za pomocą wtyczki:

  1. Kliknij Narzędzia > Asystent Google > Narzędzie do testowania działań w aplikacji. Może pojawić się prośba o zalogowanie się w Android Studio przy użyciu Twojego konta Google.
  2. Kliknij Utwórz podgląd. Gdy pojawi się prośba, przeczytaj i zaakceptuj zasady i warunki korzystania z akcji w aplikacji.

Testowanie oczekiwanego typu ćwiczenia

Aby wyświetlić widżet z informacjami o ostatnim uruchomieniu aplikacji, wykonaj te czynności w narzędziu testowym:

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

Ekran z widżetem zwróconym przez wtyczkę Asystenta Google.

Testowanie nieoczekiwanego rodzaju ćwiczenia

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

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

Asystent powinien zwrócić widżet z komunikatem „Nie znaleziono aktywności” i informacjami o nich.

Ekran z widżetem bez informacji o ćwiczeniach zwróconych przez wtyczkę Asystenta Google.

Testowanie intencji zastępczej

Zapytania aktywujące intencję zastępczą powinny zwracać widżet wyświetlający informacje o ostatniej zapisanej aktywności dowolnego typu ćwiczenia.

Aby przetestować intencję zastępczą:

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

Asystent powinien wyświetlić widżet z informacjami o ostatnim ukończonym ćwiczeniu.

Ekran z widżetem pokazującym ostatnią zarejestrowaną aktywność przy użyciu wtyczki Asystenta Google.

7. Dalsze kroki

Gratulacje!

Mogą teraz Państwo wykorzystywać za pomocą widżetu na Androida z Asystentem.

Omówione zagadnienia

Dzięki temu ćwiczeniu w programie omówiliśmy, jak:

  • Dodaj widżet aplikacji do BII.
  • Zmodyfikuj widżet, aby uzyskać dostęp do parametrów w Dodatkich do Androida.

Co dalej?

Tutaj możesz spróbować udoskonalić aplikację fitnessową. Aby odwołać się do zakończonego projektu, otwórz główne repozytorium na GitHubie.

Oto kilka sugestii, dzięki którym możesz dowiedzieć się więcej o rozszerzaniu możliwości korzystania z tej aplikacji za pomocą działań w aplikacji:

Aby dalej korzystać z Actions on Google, zapoznaj się z tymi materiałami:

Obserwuj nas na Twitterze @ActionsOnGoogle, aby być na bieżąco z najnowszymi informacjami. Aby poinformować o swoich dokonaniach, napisz na Twitterze #appactions.

Ankieta dotycząca opinii

Na koniec wypełnij tę ankietę, aby podzielić się wrażeniami na temat tego ćwiczenia z programowania.