Questa pagina è stata tradotta dall'API Cloud Translation.

Integrare i widget Android con l'Assistente Google

1. Panoramica

Nel primo codelab sulle Azioni app hai imparato come estendere l'Assistente Google a un'app per il fitness di esempio implementando gli intent integrati (BII) della categoria degli intent integrati per salute e fitness.

Le Azioni app consentono agli utenti di avviare direttamente funzionalità dell'app specifiche dall'assistente chiedendo, ad esempio, "Hey Google, inizia una corsa su ExampleApp". Oltre ad avviare le app, l'assistente può mostrare all'utente un widget Android interattivo per soddisfare le richieste di intent integrati idonei.

$Schermata che mostra l'assistente che restituisce un widget in risposta a una\nquery dell'utente che ha attivato una funzionalità GET_EXERCISE_OBSERVATION BII dell'app.$

Cosa creerai

In questo codelab, imparerai a restituire widget Android per soddisfare le richieste degli utenti con l'assistente. Imparerai anche a:

Parametri degli intent integrati utente per personalizzare i widget.
Fornisci introduzioni di sintesi vocale nell'assistente per i tuoi widget.
Utilizza il riferimento per intent integrato per determinare quali intent integrati supportano il completamento del widget.

Prerequisiti

Prima di continuare, assicurati che il tuo ambiente di sviluppo sia pronto per lo sviluppo delle Azioni app. Dovrebbe avere:

Un terminale per eseguire i comandi della shell, con git installato.
L'ultima release stabile di Android Studio.
Un dispositivo Android fisico o virtuale con accesso a internet.
Un Account Google su cui è stato eseguito l'accesso ad Android Studio, all'app Google e all'app Assistente Google.

Se utilizzi un dispositivo fisico, collegalo al computer di sviluppo locale.

2. Come funziona

L'Assistente Google utilizza la comprensione del linguaggio naturale (NLU) per leggere la richiesta di un utente e associarla a un intent integrato dell'assistente. L'assistente quindi mappa l'intent alla funzionalità (che implementa l'intent integrato), che registri per quell'intent nella tua app. Infine, l'assistente soddisfa la richiesta dell'utente mostrando il widget Android generato dall'app utilizzando i dettagli presenti nella funzionalità.

In questo codelab, definirai una funzionalità che registra il supporto per l'intent integrato GET_EXERCISE_OBSERVATION. In questa funzionalità, chiedi all'assistente di generare un intent Android nella classe del widget FitActions per soddisfare le richieste per questo intent integrato. Aggiorni questo corso per generare un widget personalizzato che l'assistente può mostrare all'utente e un'introduzione alla sintesi vocale che l'assistente può annunciare.

Il seguente diagramma illustra questo flusso:

L'app di esempio Fit Actions contiene un widget con i dati sull'allenamento che gli utenti possono aggiungere alla propria schermata Home. Questo widget è un ottimo candidato per soddisfare le query degli utenti che attivano l'intent integrato GET_EXERCISE_OBSERVATION.

Quando un utente aggiunge un widget alla schermata Home, il widget invia un ping al ricevitore di trasmissione del dispositivo. Questo servizio recupera le informazioni sul widget dalla definizione di ricevitore del widget nella risorsa AndroidManifest.xml dell'app. Utilizza queste informazioni per generare un oggetto RemoteViews che rappresenta il widget.

L'app di esempio definisce il ricevitore widgets.StatsWidgetProvider, che corrisponde alla classe 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>

La classe StatsWidgetProvider, StatsWidgetProvider.kt, gestisce i flussi di creazione degli oggetti StatsWidget. Gestisce queste responsabilità:

Creazione di istanze di widget e compilazione di dati di allenamento dal database dell'app.
Formattazione dei dati dell'allenamento per la leggibilità, con formatDataAndSetWidget().
Forniscono valori predefiniti se i dati dell'allenamento non sono disponibili, utilizzando setNoActivityDataWidget().

Aggiungi il supporto dell'assistente

In questo codelab, aggiorni l'app di esempio per gestire la funzionalità delle Azioni app. Queste modifiche includono:

Configurazione della funzionalità intent integrato GET_EXERCISE_OBSERVATION per restituire un'istanza dell'oggetto StatsWidget.
È in corso l'aggiornamento della classe StatsWidget per l'utilizzo di funzionalità di Azioni app come:
- Utilizzo dei parametri dell'intent integrato per consentire agli utenti di visualizzare statistiche specifiche sull'allenamento chiedendo, ad esempio, "Hey Google, mostra le mie statistiche di corsa su ExampleApp".
- Fornire stringhe introduttive per la sintesi vocale.
- Gestire casi speciali, ad esempio quando la query dell'utente non include un parametro per il tipo di esercizio.

3. Prepara l'ambiente di sviluppo

Scarica i tuoi file di base

Esegui questo comando per clonare il repository GitHub dell'app di esempio:

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

Una volta clonato il repository, segui questi passaggi per aprirlo in Android Studio:

Nella finestra di dialogo Ti diamo il benvenuto in Android Studio, fai clic su Importa progetto.
Trova e seleziona la cartella in cui hai clonato il repository.

Per visualizzare una versione dell'app che rappresenta il codelab completato, clona il repository dell'app di esempio utilizzando il flag --branch master.

Aggiornare l'ID app per Android

L'aggiornamento dell'ID applicazione dell'app identifica in modo univoco l'app sul dispositivo di test ed evita un "Nome pacchetto duplicato" se l'app viene caricata su Play Console. Per aggiornare l'ID applicazione, apri app/build.gradle:

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

Sostituisci "MYUNIQUENAME" nel campo applicationId a qualcosa di tuo.

Installa il plug-in di prova

Il plug-in dell'Assistente Google ti consente di testare le Azioni app su un dispositivo di test. Funziona inviando informazioni all'assistente tramite l'app Google sul tuo dispositivo Android. Se non disponi già del plug-in, installalo seguendo questa procedura:

Vai su File > Impostazioni (Android Studio > Preferenze su MacOS).
Nella sezione Plug-in, vai a Marketplace e cerca "Assistente Google". Puoi anche scaricare e installare manualmente lo strumento di test.
Installa lo strumento e riavvia Android Studio.

Testa l'app sul tuo dispositivo

Prima di apportare altre modifiche all'app, è utile avere un'idea di cosa può fare l'app di esempio.

Esegui l'app sul dispositivo di test:

In Android Studio, seleziona il tuo dispositivo fisico o virtuale e seleziona Esegui > Esegui app o fai clic su Esegui nella barra degli strumenti.
Tieni premuto a lungo il pulsante Home per configurare l'assistente e verificare che funzioni. Dovrai accedere all'assistente sul tuo dispositivo, se non l'hai ancora fatto.

Per saperne di più sui dispositivi virtuali Android, vedi Creare e gestire dispositivi virtuali.

Esplora brevemente l'app per vedere cosa sa fare. L'app precompila 10 attività di allenamento e mostra queste informazioni sulla prima visualizzazione.

Tocca il pulsante Home per andare alla schermata Home del dispositivo di test.
Tieni premuto a lungo uno spazio vuoto sulla schermata Home e seleziona Widget.
Scorri verso il basso nell'elenco dei widget fino a FitActions.
Premi a lungo l'icona FitAzioni e posiziona il relativo widget sulla schermata Home.

4. Aggiungi l'Azione app

In questo passaggio, aggiungerai la funzionalità degli intent integrati di GET_EXERCISE_OBSERVATION. Per farlo, aggiungi un nuovo elemento capability in shortcuts.xml. Questa funzionalità specifica come viene attivata la funzionalità, come vengono utilizzati i parametri dell'intent integrato e quali intent Android richiamare per soddisfare la richiesta.

Aggiungi un nuovo elemento capability alla risorsa del progetto di esempio shortcuts.xml con questa configurazione:

<!-- 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>

Sostituisci il valore android:targetPackage, PUT_YOUR_APPLICATION_ID_HERE, con il valore applicationId univoco.

Questa funzionalità mappa l'intent integrato GET_EXERCISE_OBSERVATION all'intent app-widget in modo che, quando viene attivato, il widget crei un'istanza e lo visualizzi all'utente.

Prima di attivare il widget, l'assistente estrae i parametri dell'intent integrato supportati dalla query dell'utente. Questo codelab richiede il parametro dell'intent integrato exerciseObservation.aboutExercise.name, che rappresenta il tipo di esercizio richiesto dall'utente. L'app supporta tre tipi di allenamento: "corsa", "camminata" e "ciclismo". Fornisci un inventario in linea per informare l'assistente di questi valori supportati.

Definisci questi elementi dell'inventario aggiungendo questa configurazione, sopra la funzionalità GET_EXERCISE_OBSERVATION, a 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>

Aggiungi un intent di riserva

Gli intent di riserva gestiscono le situazioni in cui non è possibile completare una query dell'utente perché nella query mancano i parametri richiesti dalla funzionalità. La funzionalità GET_EXERCISE_OBSERVATION richiede il parametro exerciseObservation.aboutExercise.name, specificato dall'attributo android:required="true". In queste situazioni, l'assistente richiede di definire un intent di riserva per consentire la riuscita della richiesta, anche se nella query non vengono forniti parametri.

In shortcuts.xml, aggiungi un intent di riserva alla funzionalità GET_EXERCISE_OBSERVATION utilizzando questa configurazione:

<!-- shortcuts.xml -->

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

  <app-widget>
    <!-- ... -->
  </app-widget>

  <!-- Fallback intent with no parameters needed to successfully execute.-->
  <intent
    android:identifier="GET_EXERCISE_OBSERVATION_FALLBACK"
    android:action="android.intent.action.VIEW"
    android:targetClass="com.devrel.android.fitactions.widgets.StatsWidgetProvider">
  </intent>
</capability>

In questa configurazione di esempio, il completamento di riserva è un intent Android senza parametri nei dati Extra.

5. Attiva il widget per l'assistente

Una volta stabilita la funzionalità GET_EXERCISE_OBSERVATION, aggiorna la classe del widget per supportare le chiamate vocali delle Azioni app.

Aggiungere la libreria dell'estensione Widgets

La raccolta di estensioni widget di Azioni app migliora i tuoi widget per offrirti esperienze con l'assistente con l'aiuto della voce. In particolare, ti consente di fornire un'introduzione di sintesi vocale personalizzata per i tuoi widget.

Aggiungi la dipendenza dalla libreria dell'estensione Widgets alla risorsa /app/build.gradle di esempio dell'app:
```
// app/build.gradle

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
```
Fai clic su Sincronizza ora nella casella di avviso visualizzata in Android Studio. La sincronizzazione dopo ogni modifica di build.gradle ti consente di evitare errori durante la creazione dell'app.

Un servizio è un componente dell'applicazione che può eseguire operazioni a lunga esecuzione in background. La tua app deve fornire un servizio per elaborare le richieste dei widget.

Aggiungi un servizio alla risorsa AndroidManifest.xml dell'app di esempio con questa configurazione:

<!-- 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>

Durante una query vocale che attiva il completamento del widget, l'assistente usa questo servizio per inviare richieste all'app. Il servizio riceve la richiesta insieme ai dati degli intent integrati. Il servizio utilizza questi dati per generare un oggetto widget RemoteView da visualizzare all'interno dell'assistente.

L'app è ora configurata per instradare le richieste di funzionalità di GET_EXERCISE_OBSERVATION alla classe del widget. A questo punto, aggiorna la classe StatsWidget.kt per generare un'istanza del widget personalizzata in base alla richiesta dell'utente, utilizzando i valori parametro dell'intent integrato.

Apri la classe StatsWidget.kt e importa la libreria dell'estensione widget Azioni app:

// StatsWidget.kt

// ... Other import statements
import com.google.assistant.appactions.widgets.AppActionsWidgetExtension

Aggiungi queste variabili private, che utilizzerai per determinare le informazioni da inserire nel widget:

// StatsWidget.kt

private val hasBii: Boolean
private val isFallbackIntent: Boolean
private val aboutExerciseName: String
private val exerciseType: FitActivity.Type

Aggiungi la funzione init per consentire alla classe di utilizzare i dati delle opzioni del widget trasmessi dall'assistente:

// 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)
}

Vediamo in che modo questi aggiornamenti consentono alla classe StatsWidget.kt di rispondere agli intent Android generati dalla funzionalità GET_EXERCISE_OBSERVATION:

optionsBundle = Set
- I pacchetti sono oggetti destinati a essere utilizzati oltre i confini dei processi, tra attività con intent e per archiviare lo stato temporaneo nelle modifiche alla configurazione. L'assistente usa gli oggetti Bundle per trasmettere i dati di configurazione al widget.
bii = actions.intent.GET_EXERCISE_OBSERVATION
- Il nome dell'intent integrato è disponibile nel bundle utilizzando l'attributo AppActionsWidgetExtension.
hasBii = true
- Controlla se è presente un intent integrato.
params = Bundle[{aboutExerciseName=running}]
- Un bundle speciale, generato da Azioni app, è nidificato all'interno delle opzioni del widget Bundle. Contiene le coppie chiave/valore dell'intent integrato. In questo caso, il valore running è stato estratto dalla query di esempio "Hey Google, mostra le mie statistiche di corsa su ExampleApp".
isFallbackIntent = false
- Controlla la presenza di parametri degli intent integrati obbligatori nell'intent Extras.
aboutExerciseName = running
- Ottiene il valore dell'intent Extras per aboutExerciseName.
exerciseType = RUNNING
- Utilizza aboutExerciseName per cercare l'oggetto del tipo di database corrispondente.

Ora che la classe StatsWidget è in grado di elaborare i dati sugli intent di Android di Azioni app in arrivo, aggiorna la logica del flusso di creazione del widget per verificare se il widget è stato attivato da un'azione app.

In StatsWidget.kt, sostituisci la funzione updateAppWidget() con questo codice:

// 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()
}

Il codice precedente fa riferimento a una nuova funzione, observeAndUpdateRequestedExercise. Questa funzione genera i dati del widget utilizzando i dati del parametro exerciseType trasmessi dall'intent Android di Azioni app.

Aggiungi la funzione observeAndUpdateRequestedExercise con questo codice:

// 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()
       }
   }
}

Nel codice precedente, utilizza una classe repository esistente trovata nell'app per recuperare i dati relativi all'attività fisica dal database locale dell'app. Questa lezione fornisce un'API che semplifica l'accesso al database. Il repository funziona esponendo un oggetto LiveData durante l'esecuzione di query sul database. Nel tuo codice, osservi questo LiveData per recuperare l'ultima attività fisica.

Attiva sintesi vocale

Puoi fornire una stringa di sintesi vocale che l'assistente annuncia quando visualizzi il widget. Ti consigliamo di includere questa informazione per fornire un contesto udibile con i tuoi widget. Questa funzionalità è offerta dalla raccolta dell'estensione Widget Azioni app, che ti consente di impostare testo e introduzioni della sintesi vocale che accompagnano i tuoi widget nell'assistente.

Un buon posto per fornire la tua sintesi vocale è la funzione formatDataAndSetWidget, che formatta i dati dell'attività restituiti dal database dell'app.

In StatsWidget.kt, aggiungi questo codice alla funzione 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)
      }
}

Il codice precedente fa riferimento a due risorse stringa: una per il parlato e l'altra per il testo. Dai un'occhiata alla sezione relativa ai consigli sullo stile di sintesi vocale del nostro video sui widget per consigli sulla sintesi vocale. L'esempio fa anche riferimento a setTts, una nuova funzione che fornisce le informazioni di sintesi vocale all'istanza del widget.

Aggiungi questa nuova funzione setTts a StatsWidget.kt utilizzando questo codice:

// 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)
}

Infine, completa la logica della sintesi vocale impostando le informazioni relative alla sintesi vocale quando il database degli allenamenti restituisce dati vuoti per un tipo di esercizio richiesto.

Aggiorna la funzione setNoActivityDataWidget() in StatsWidget.kt con questo codice:

// 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. Testa l'azione app

Durante lo sviluppo, usa il plug-in dell'Assistente Google per visualizzare l'anteprima delle Azioni app dell'assistente su un dispositivo di test. Puoi regolare i parametri di intent per un'Azione app con lo strumento per verificare in che modo l'azione gestisce i vari modi in cui un utente potrebbe chiedere all'assistente di eseguirla.

Creare un'anteprima

Per testare l'Azione app con il plug-in:

Vai a Strumenti > Assistente Google > Strumento di test delle Azioni app. Ti potrebbe essere chiesto di accedere ad Android Studio con il tuo Account Google.
Fai clic su Crea anteprima. Se richiesto, leggi e accetta le norme e i termini di servizio di Azioni app.

Testa un tipo di allenamento previsto

Per restituire un widget che mostra informazioni sull'ultima esecuzione completata nell'app, segui questi passaggi nello strumento di test:

Nel primo passaggio in cui lo strumento ti chiede di selezionare e configurare un intent integrato, seleziona actions.intent.GET_EXERCISE_OBSERVATION.
Nella casella exerciseObservation, aggiorna il nome predefinito dell'allenamento da climbing a run.
Fai clic su Run App Action (Esegui azione app).

Testa un tipo di allenamento imprevisto

Per testare un tipo di esercizio imprevisto nello strumento di test:

Nella casella exerciseObservation, aggiorna il valore name da Run a Climbing.
Fai clic su Run App Action (Esegui azione app).

L'assistente dovrebbe restituire un widget con il messaggio "Nessuna attività trovata" informazioni.

Testare l'intent di riserva

Le query che attivano l'intent di riserva dovrebbero restituire un widget che mostra informazioni sull'ultima attività registrata di qualsiasi tipo di esercizio.

Per testare l'intent di riserva:

Nella casella exerciseObservation, elimina l'oggetto aboutExercise.
Fai clic su Run App Action (Esegui azione app).

L'assistente dovrebbe restituire un widget che mostra informazioni per l'ultimo allenamento completato.

7. Passaggi successivi

Complimenti!

Ora hai la possibilità di soddisfare le esigenze usando un widget Android con l'assistente.

Argomenti trattati

In questo codelab, hai imparato a:

Aggiungi un widget dell'app a un intent integrato.
Modifica un widget per accedere ai parametri di Android Extras.

Passaggi successivi

Da qui, puoi provare a perfezionare ulteriormente la tua app per l'attività fisica. Per fare riferimento al progetto finito, consulta il repo principale su GitHub.

Ecco alcuni suggerimenti per ulteriori informazioni su come estendere questa app con Azioni app:

Consulta la documentazione di riferimento sugli intent integrati di Azioni app per scoprire altri modi per estendere le tue app all'assistente.

Per continuare il tuo percorso con Actions on Google, esplora queste risorse:

developers.google.com/assistant/app: sito di documentazione ufficiale per le Azioni app dell'Assistente Google.
Indice di esempio di Azioni app: app di esempio e codice per esplorare le funzionalità delle Azioni app.
Repository GitHub di Actions on Google: codice e librerie di esempio.
r/GoogleAssistantDev: community ufficiale di Reddit per gli sviluppatori che lavorano con l'Assistente Google.

Seguici su Twitter @ActionsOnGoogle per non perderti i nostri ultimi annunci e twitta a #appactions per condividere ciò che hai realizzato.

Sondaggio di feedback

Infine, compila questo sondaggio per fornire un feedback sulla tua esperienza con questo codelab.