Integrar widgets do Android com o Google Assistente

1. Visão geral

No primeiro codelab das Ações no app, você aprendeu a estender o Google Assistente para um exemplo de app fitness implementando intents integradas (BII, na sigla em inglês) da categoria BII de saúde e condicionamento físico.

Com as Ações no app, os usuários podem iniciar recursos específicos do app diretamente no Google Assistente. Basta pedir algo como "Ok Google, executar no ExampleApp". Além de iniciar apps, o Google Assistente pode exibir um widget interativo do Android para o usuário atender a solicitações de BIIs qualificadas.

$Uma tela mostrando o Google Assistente retornando um widget em resposta a uma\nconsulta do usuário para acionar um recurso de BII do app GET_EXERCISE_OBSERVATION.$

O que você criará

Neste codelab, você aprenderá a retornar widgets do Android para atender a solicitações de usuários do Google Assistente. Você também aprenderá a:

usar parâmetros de BII do usuário para personalizar widgets;
introduzir a conversão de texto em voz (TTS, na sigla em inglês) para seus widgets no Google Assistente;
usar a referência de intents integradas para determinar quais BIIs são compatíveis com o fulfillment de widgets.

Pré-requisitos

Antes de continuar, verifique se o ambiente está pronto para o desenvolvimento de Ações no app. Ele precisa ter o seguinte:

Um terminal para executar comandos de shell com git instalado
A versão estável mais recente do Android Studio
Um dispositivo Android físico ou virtual com acesso à Internet
Uma Conta do Google conectada ao Android Studio, ao Google app e ao app Google Assistente

Se você estiver usando um dispositivo físico, conecte-o à sua máquina de desenvolvimento local.

2. Entenda como funciona

O Google Assistente usa processamento de linguagem natural (PLN, na sigla em inglês) para ler a solicitação do usuário e fazer a correspondência com uma intent integrada do Google Assistente (BII). Em seguida, o Google Assistente mapeia a intent para o recurso (que implementa a BII) que você registra para essa intent no app. Por fim, para atender à solicitação, o Google Assistente exibe o widget do Android que o app gera usando os detalhes encontrados no recurso.

Neste codelab, você definirá um recurso que registra a compatibilidade com a BII do GET_EXERCISE_OBSERVATION. Nesse recurso, você instrui o Google Assistente a gerar uma intent do Android à classe de widgets FitActions para atender às solicitações dessa BII. Depois, atualiza essa classe para gerar um widget personalizado, que o Google Assistente mostrará ao usuário, e uma introdução do TTS para anunciar.

O diagrama a seguir demonstra esse fluxo:

O app de exemplo FitActions contém um widget de informações de treino que os usuários podem adicionar à tela inicial. Esse widget atende a consultas dos usuários que acionam a BII do GET_EXERCISE_OBSERVATION.

Quando um usuário adiciona um widget à tela inicial, ele recebe um ping no dispositivo Broadcast Receiver. Esse serviço recupera informações sobre o widget a partir da definição de receptor do widget no recurso AndroidManifest.xml do app. Ele usa essas informações para gerar um objeto RemoteViews, que representa o widget.

O app de exemplo define o receptor widgets.StatsWidgetProvider, que corresponde à 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>

A classe do StatsWidgetProvider, StatsWidgetProvider.kt, gerencia os fluxos de criação de objetos StatsWidget. E tem as seguintes responsabilidades:

Criar instâncias de widget e preenchê-las com dados de exercício do banco de dados do app.
Formatar dados de treino para facilitar a leitura com formatDataAndSetWidget().
Fornecer valores padrão se os dados de treino não estiverem disponíveis, usando setNoActivityDataWidget().

Adicionar compatibilidade com o Google Assistente

Neste codelab, você atualizará o app de exemplo para processar a funcionalidade das Ações no app. Estas alterações incluem:

configurar o recurso BII de GET_EXERCISE_OBSERVATION para retornar uma instância do objeto StatsWidget;
atualizar a classe StatsWidget para usar os recursos do Ações no app, como:
- usar parâmetros de BII, permitindo que os usuários visualizem estatísticas de treino específicas ao pedir algo como "Ok Google, mostre minhas estatísticas de corrida no ExampleApp";
- fornecer strings de introdução a TTS;
- gerenciar casos especiais, como quando a consulta do usuário não inclui um parâmetro de tipo de treino.

3. Preparar ambiente para desenvolvedores

Fazer o download dos arquivos de base

Execute este comando para clonar o repositório do GitHub do app de exemplo:

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

Depois, siga as etapas abaixo para abri-lo no Android Studio:

Na caixa de diálogo Boas-vindas ao Android Studio, clique em Importar projeto.
Selecione a pasta em que você clonou o repositório.

Para ver uma versão do app que representa o codelab concluído, clone o repositório do app de exemplo usando a sinalização --branch master.

Alterar o ID do app Android

Mais adiante neste codelab, você usará o plug-in do Google Assistente para testar suas ações em um dispositivo físico ou virtual. Para executar a ferramenta de teste, primeiro é preciso fazer o upload do app para um projeto no Google Play Console. Para evitar o erro "Nome do pacote duplicado" ao fazer upload do app para o Play Console, use algo exclusivo como o applicationId do app de exemplo. O Google Play não permite o upload de dois apps com o mesmo applicationId.

No app/build.gradle, atualize o valor de applicationId, PUT_YOUR_APPLICATION_ID_HERE, para um ID exclusivo, como com.codelabs.myname. Para saber mais sobre IDs de aplicativos Android, consulte Definir o ID do aplicativo.
Abra app/src/res/xml/shortcuts.xml e atualize as duas (2) instâncias de android:targetPackage para seu applicationId exclusivo.

Fazer upload para o Play Console

É preciso fazer upload do app para um projeto no Google Play Console para usar o plug-in do Google Assistente no Android Studio. Crie o app no Android Studio e faça upload no Play Console como rascunho de versão interna.

Para criar seu app no Android Studio:

Acesse Criar > Gerar pacote assinado/APK.
Selecione Android App Bundle e clique em Próxima.
Insira as informações para assinar seu app e clique em Próxima. Preste atenção ao caminho em que o pacote é gerado na seção Pasta de destino.
Selecione a variante de build prodRelease ou release e clique em Concluir.

No Play Console, faça upload do pacote de apps criado como um novo app:

Na página Todos os apps, clique em Criar app.
Na caixa Nome do app, insira qualquer nome, como "Codelab do widget".
Em App ou jogo, selecione App.
Em Pago ou sem custos financeiros, escolha Sem custos financeiros.
Aceite as Declarações.
Clique em Criar app.
No menu lateral do Play Console, acesse Testes e procure a página Teste interno.
Nessa página, clique em Criar nova versão.
Se solicitado, clique em Continuar para concordar com a Assinatura de apps do Google Play.
No painel Pacotes de apps e APKs, faça upload do arquivo AAB gerado na etapa anterior. Esse arquivo provavelmente estará no diretório app/prod/release ou app/release do projeto. Clique em Salvar.

Instalar o plug-in de teste

O plug-in do Google Assistente permite que você teste as Ações no app em um dispositivo. Ele envia informações para o Google Assistente pelo Google app no seu dispositivo Android. Se você ainda não tiver o plug-in, siga estas etapas para instalar:

Acesse Arquivo > Configurações (Android Studio > Preferências no MacOS).
Na seção "Plug-ins", acesse Marketplace e pesquise "Google Assistente". Também é possível fazer o download manualmente e instalar a ferramenta de teste.
Instale a ferramenta e reinicie o Android Studio.

Testar o app no seu dispositivo

Antes de fazer mais alterações, é recomendável ver o que o app de exemplo pode fazer.

Execute o app no dispositivo de teste:

No Android Studio, selecione seu dispositivo físico ou virtual e clique em Executar > Executar app ou Executar na barra de ferramentas.
Toque e mantenha pressionado o botão home para configurar o Google Assistente e verificar se ele está funcionando. Faça login no Google Assistente usando seu dispositivo, caso ainda não tenha feito isso.

Para mais informações sobre dispositivos virtuais Android, consulte Criar e gerenciar dispositivos virtuais.

Explore o app rapidamente para ver o que ele pode fazer. O app preenche automaticamente dez atividades de exercício e exibe essas informações na primeira visualização.

Toque no botão Home para acessar a tela inicial do dispositivo de teste.
Toque e mantenha pressionado um espaço vazio na tela inicial e selecione Widgets.
Role a lista de widgets para baixo até FitActions.
Toque e mantenha pressionado o ícone do FitActions e posicione o widget na tela inicial.

4. Adicionar a ação do app

Nesta etapa, você adicionará o recurso de BII de GET_EXERCISE_OBSERVATION. Para fazer isso, adicione um novo elemento capability no shortcuts.xml. Esse recurso especifica como ele é acionado, como os parâmetros de BII são usados e quais intents do Android precisam ser invocadas para atender à solicitação.

Adicione um novo elemento capability ao recurso shortcuts.xml do projeto de amostra com esta configuração:

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

Substitua o valor de android:targetPackage, PUT_YOUR_APPLICATION_ID_HERE, pelo applicationId exclusivo.

Esse recurso mapeia a BII de GET_EXERCISE_OBSERVATION para a intent app-widget. Assim, quando a BII é acionada, o widget é instanciado e exibido para o usuário.

Antes de acionar o widget, o Google Assistente extrai os parâmetros de BII compatíveis com a consulta do usuário. Este codelab requer o parâmetro de BII de exerciseObservation.aboutExercise.name, que representa o tipo de exercício solicitado pelo usuário. O app é compatível com três tipos de exercício: "corrida", "caminhada" e "treino de bicicleta". Você fornece um inventário in-line para informar o Google Assistente sobre os valores compatíveis.

Para definir esses elementos de inventário, adicione a seguinte configuração acima do recurso 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>

Adicionar uma intent de fallback

As intents de fallback lidam com situações em que não é possível atender a uma consulta do usuário porque faltam parâmetros obrigatórios no recurso. O recurso GET_EXERCISE_OBSERVATION exige o parâmetro exerciseObservation.aboutExercise.name, especificado pelo atributo android:required="true". Nessas situações, o Google Assistente exige que você defina uma intent de fallback para a solicitação, mesmo que nenhum parâmetro seja fornecido na consulta.

Em shortcuts.xml, adicione uma intent de fallback ao recurso GET_EXERCISE_OBSERVATION usando esta configuração:

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

Na configuração de exemplo, o fulfillment de fallback é uma intent do Android sem parâmetros nos dados Extra.

5. Ativar o widget do Google Assistente

Após criar o recurso GET_EXERCISE_OBSERVATION, atualize a classe do widget para oferecer compatibilidade com a invocação por voz das Ações no app.

Adicionar a biblioteca de extensões de widgets

A biblioteca de extensões de widget do Ações no app melhora os widgets para experiências do Google Assistente que usam a voz. Mais especificamente, ele permite oferecer uma introdução ao TTS personalizada para seus widgets.

Adicione a dependência da biblioteca de extensões de widget ao recurso do app de exemplo /app/build.gradle:
```
// app/build.gradle

dependencies {
  //...
  implementation "com.google.assistant.appactions:widgets:0.0.1"
}
```
Na caixa de aviso do Android Studio, clique em Sincronizar agora. Sincronizar após cada mudança do build.gradle ajuda a evitar erros na criação do app.

Um serviço é um componente de aplicativo que pode executar operações de longa duração em segundo plano. Seu app precisa fornecer um serviço para processar solicitações de widgets.

Adicione um serviço ao recurso AndroidManifest.xml do app de exemplo com esta configuração:

<!-- 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 uma consulta por voz que acione o fulfillment do widget, o Google Assistente usa esse serviço para enviar solicitações ao app. O serviço recebe a solicitação com os dados de BII. Em seguida, ele gera um objeto de widget RemoteView usando esses dados para renderizar no Google Assistente.

Seu app está configurado para encaminhar solicitações de recursos do GET_EXERCISE_OBSERVATION para sua classe de widgets. Em seguida, atualize a classe StatsWidget.kt para gerar uma instância de widget personalizada para a solicitação do usuário, usando valores de parâmetros BII.

Abra a classe StatsWidget.kt e importe a biblioteca de extensões de widgets do Ações no app:

// StatsWidget.kt

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

Adicione as variáveis particulares usadas ao determinar as informações para preencher o widget:

// StatsWidget.kt

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

Adicione a função init para permitir que a classe use os dados de opções do widget transmitidos pelo Google 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)
}

Veja como essas atualizações permitem que a classe StatsWidget.kt responda a intents do Android geradas pelo recurso GET_EXERCISE_OBSERVATION:

optionsBundle = Pacote
- Os pacotes são objetos usados para ultrapassar os limites do processo, entre atividades com intents, e para armazenar o estado temporário nas mudanças de configuração. O Google Assistente usa objetos Bundle para transmitir dados de configuração para o widget.
bii = actions.intent.GET_EXERCISE_OBSERVATION
- O nome da BII está disponível no pacote usando o AppActionsWidgetExtension.
hasBii = true
- Verifica se há uma BII.
params = Bundle[{aboutExerciseName=running}]
- Um pacote especial, gerado pelas Ações no app, é aninhado nas opções do widget Bundle. Ele contém os pares de chave-valor da BII. Nesse caso, o valor running foi extraído da consulta de exemplo "Ok Google, mostre minhas estatísticas de corrida no ExampleApp".
isFallbackIntent = false
- Verifica a presença de parâmetros de BII necessários na intent Extras.
aboutExerciseName = running
- Recebe o valor da intent Extras para aboutExerciseName.
exerciseType = RUNNING
- Usa aboutExerciseName para procurar o objeto de banco de dados correspondente.

Agora que a classe StatsWidget pode processar dados de intent de ações do app Android, atualize a lógica do fluxo de criação de widgets para verificar se o widget foi acionado por uma ação do app.

No StatsWidget.kt, substitua a função updateAppWidget() por este código:

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

O código anterior se refere a uma nova função, observeAndUpdateRequestedExercise. Essa função gera dados do widget usando os dados do parâmetro exerciseType transmitidos pela intent do Android das Ações no app.

Adicione a função observeAndUpdateRequestedExercise com este código:

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

No código anterior, use uma classe de repositório do app para recuperar dados de condicionamento físico do banco de dados local do app. Essa classe fornece uma API que simplifica o acesso ao banco de dados. O repositório expõe um objeto LiveData ao realizar consultas no banco de dados. No seu código, LiveData recupera a atividade de condicionamento físico mais recente.

Ativar TTS

Você pode fornecer uma string TTS para o Google Assistente anunciar ao exibir seu widget. Recomendamos que você inclua essa informação para contextualizar os widgets. Essa funcionalidade é fornecida pela biblioteca de extensões de widgets do Ações no app, que permite definir o texto e as introduções de TTS que acompanham os widgets no Google Assistente.

Recomendamos fazer a introdução do TTS na função formatDataAndSetWidget, que formata os dados de atividade retornados do banco de dados do app.

No StatsWidget.kt, adicione este código à função 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)
      }
}

O código anterior se refere a dois recursos de string: um de fala e outro de texto. Confira as recomendações de TTS na seção Recomendação de estilo da conversão de texto em voz do vídeo dos nossos widgets. O exemplo também se refere a setTts, uma nova função que fornece as informações de TTS para a instância do widget.

Para adicionar a função setTts a StatsWidget.kt, use este código:

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

Por fim, para concluir a lógica de TTS, defina informações de TTS quando o banco de dados de exercícios retornar dados vazios para o tipo de treino solicitado.

Atualize a função setNoActivityDataWidget() no StatsWidget.kt com este código:

// 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. Testar a ação do app

Durante o desenvolvimento, use o plug-in do Google Assistente para visualizar as Ações no app em um dispositivo de teste. É possível ajustar os parâmetros de intent de uma ação no app para testar como ela processa as várias formas possíveis para um usuário pedir algo ao Google Assistente.

Criar uma visualização

Para testar a ação do app com o plug-in:

Acesse Ferramentas > Google Assistente > Ferramenta de teste do Ações no app. Talvez seja necessário fazer login no Android Studio. Nesse caso, use a mesma conta do login no Google Play Console.
Clique em Criar visualização.

Testar um tipo de exercício esperado

Para retornar um widget que exiba as informações da última execução concluída no app, siga estas etapas na ferramenta de teste:

Na primeira etapa, a ferramenta pede para você selecionar e configurar uma BII. Selecione actions.intent.GET_EXERCISE_OBSERVATION.
Na caixa exerciseObservação, troque o nome padrão do exercício de climbing por run.
Clique em Executar ação do app.

Testar um tipo de exercício inesperado

Para testar um tipo de exercício inesperado na ferramenta de teste:

Na caixa exerciseObservação, troque o valor name de Run por Climbing.
Clique em Executar ação do app.

O Google Assistente retornará um widget com a informação "Nenhuma atividade encontrada".

Testar a intent de fallback

As consultas que acionam a intent de fallback precisam retornar um widget que exiba informações sobre a última atividade registrada de qualquer tipo de exercício.

Para testar a intent de fallback, siga estas etapas:

Na caixa exerciseObservação, exclua o objeto aboutExercise.
Clique em Executar ação do app.

O Google Assistente retornará um widget com informações sobre o último exercício concluído.

7. Próximas etapas

Parabéns!

Agora você pode atender às consultas dos usuários com um widget do Android com o Google Assistente.

O que vimos

Neste codelab, você aprendeu a:

adicionar um widget de app a uma BII;
modificar um widget para acessar parâmetros de Extras do Android.

Próxima etapa

Agora, tente refinar ainda mais o app fitness. Para fazer referência ao projeto finalizado, consulte o repositório principal no GitHub.

Veja algumas sugestões para saber mais sobre como estender o app com o Ações no app:

Acesse a referência de intents integradas do Ações no app para descobrir mais maneiras de estender seus apps ao Google Assistente.

Para continuar sua jornada no Actions on Google, veja estes recursos:

developers.google.com/assistant/app: site de documentação oficial do Ações no app do Google Assistente
Índice de exemplos de Ações no app: apps de exemplo e códigos para explorar os recursos das Ações no app.
Repositório do Actions on Google do GitHub: exemplos de códigos e bibliotecas.
r/GoogleAssistantDev: comunidade oficial do Reddit para desenvolvedores que trabalham com o Google Assistente.

Siga nosso perfil do Twitter @ActionsOnGoogle para ficar por dentro dos nossos comunicados mais recentes e envie um tuíte para #appactions contando o que você criou.

Pesquisa de feedback

Por fim, preencha esta pesquisa para dar feedback sobre sua experiência com este codelab.