Atualizações diárias (Dialogflow)

Se a Ação agregar valor aos usuários todos os dias, ofereça um lembrete para usá-la configurando atualizações diárias. Quando um usuário se inscrever para receber atualizações diárias da sua ação, ele vai receber uma notificação push e poderá tocar em uma notificação para invocar uma das intents.

A experiência de um usuário com essas atualizações é a seguinte:

1. O usuário invoca uma das intents da sua Ação que você configurou como uma atualização diária.
2. O usuário segue uma solicitação para se inscrever nas atualizações diárias. Essa solicitação é apresentada no meio da conversa ou como um ícone de sugestão quando a conversa termina.
3. O usuário programa um horário em que gostaria de receber a atualização diária, registrando a atualização no Google Assistente.
4. No horário programado todos os dias, o usuário recebe uma notificação do Google Assistente no dispositivo móvel.
5. Quando o usuário abre essa notificação, ele invoca a intent que você configurou como uma atualização diária e interage com sua ação.

Por padrão, a solicitação de registro de atualização diária aparece como um chip de sugestão quando o usuário sai da ação. Também é possível adicionar um comando de registro no meio da conversa ou personalizar as atualizações do usuário.

Casos de uso

As atualizações diárias podem ser uma ferramenta de engajamento útil, mas não devem ser incorporadas em todas as ações. Considere estas dicas ao decidir se quer adicionar assinaturas de atualização diárias a uma ação:

• Garanta que as atualizações diárias façam o usuário receber informações diferentes e úteis todos os dias. Se tocar em uma atualização diária resultar na mesma solicitação todas as vezes, o usuário provavelmente vai cancelar a inscrição depois de alguns dias.
• Verifique se a caixa de diálogo faz sentido para o usuário caso ele vá direto para a intent da atualização diária. O usuário não vai necessariamente começar desde o início da conversa. Portanto, não se espera que ele tenha muito contexto.
• Mostre ao usuário o benefício da ação antes de solicitar que ele se registre para receber atualizações diárias. Seu usuário deve estar pensando "Quero este conteúdo todos os dias" quando tem a opção de se inscrever.
• Não sobrecarregue o usuário com sugestões repetidas de registro. Ofereça uma assinatura de atualização diária logo depois de mostrar ao usuário o plano e evite repetir a oferta em outros contextos.
• Mantenha a conversa breve depois que a intent de atualização for acionada. A maioria das atualizações diárias precisa consistir em apenas uma única resposta e, em seguida, fechar sem exigir entrada do usuário.

Configurar atualizações diárias

Se quiser configurar uma das intents da sua Ação para atualizações diárias, siga estas instruções:

1. Preparar uma intent de atualização

Configure uma das intents da sua Ação como uma intent de gatilho. Essa intent permite que uma atualização diária seja enviada aos usuários. Quando um usuário abre a notificação de atualização diária, a intent é acionada e a conversa continua a partir daí.

Para definir uma intent de acionamento no Dialogflow, faça o seguinte:

1. No Console do Dialogflow, clique em Integrações.
2. Na seção Google Assistente, clique em Integration Settings.
3. Em Descoberta > Invocação implícita, clique em Adicionar intent e selecione sua intent de acionamento, se ainda não estiver lá.
4. Ative a opção Visualização automática das mudanças, caso ainda não tenha feito isso.
5. Clique em Fechar.

No SDK do Actions, defina a intent de atualização como uma intent de acionamento no pacote de ações.

2. Ativar atualizações

Para ativar as atualizações diárias da intent de acionamento, faça o seguinte:

1. No Console do Actions, acesse Desenvolver > Ações.
2. Selecione a intent de acionamento. Se a intent não aparecer na lista, verifique se ela está configurada como uma intent de gatilho e se a integração do Google Assistente está definida para visualizar alterações automaticamente.
3. Role para baixo até a seção Engajamento do usuário e ative a opção Quer oferecer atualizações diárias aos usuários.
4. Insira um Título do conteúdo.
5. Clique em Salvar.

Você configurou a Ação para oferecer assinaturas de atualização diária para uma intent. Agora você pode testar as atualizações diárias no seu dispositivo móvel.

Personalizar o registro de atualização (opcional)

Além do chip de sugestão e do fluxo de registro de atualização diária processado pelo Google Assistente, inscreva os usuários para receber atualizações diárias com sua própria caixa de diálogo e solicitação de registro.

Para ver um exemplo completo de uma ação que processa recursos opcionais de atualização diária, consulte os exemplos de engajamento de usuários do Actions on Google (Node.js e Java).

Para adicionar uma solicitação personalizada de registro de atualização diária à sua conversa, siga estas instruções:

1. Adicionar solicitação de registro

Adicione uma caixa de diálogo e um ícone de sugestão à conversa quando quiser solicitar que os usuários se inscrevam para receber atualizações diárias. Ofereça essas solicitações depois que o usuário interagir com a intent de atualização para que ele entenda o conteúdo das atualizações diárias.

O código de exemplo abaixo solicita que o usuário se inscreva para receber atualizações diárias que oferecem a temperatura mais baixa esperada todos os dias:

app.intent('Daily Lowest Temperature', (conv, params) => {
  const today = DAYS[new Date().getDay()];
  const lowestTemperature = lowestTemperatures[today];
  conv.ask(`The lowest temperature for today is ${lowestTemperature}`);
  conv.ask('I can send you daily updates with the lowest temperature' +
    ' of the day. Would you like that?');
  conv.ask(new Suggestions('Send daily updates'));
});
index.js

@ForIntent("Daily Lowest Temperature")
public ActionResponse dailyLowestTemperature(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  Integer lowestTemperature =
      LOWEST_TEMPERATURES.get(LocalDate.now().getDayOfWeek());
  responseBuilder
      .add("The lowest temperature for today is " +  lowestTemperature + " degrees Fahrenheit.")
      .add("I can send you daily updates with the lowest temperature of " +
          "the day. Would you like that?")
      .addSuggestions(new String[] {
          "Send daily updates"
      });
  return responseBuilder.build();
}
UpdatesApp.java

{
  "payload": {
    "google": {
      "expectUserResponse": true,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "The lowest temperature for today is 75 degrees Fahrenheit"
            }
          },
          {
            "simpleResponse": {
              "textToSpeech": "I can send you daily updates with the lowest temperature of the day. Would you like that?"
            }
          }
        ],
        "suggestions": [
          {
            "title": "Send daily updates"
          }
        ]
      }
    }
  }
}

{
  "expectUserResponse": true,
  "expectedInputs": [
    {
      "possibleIntents": [
        {
          "intent": "actions.intent.TEXT"
        }
      ],
      "inputPrompt": {
        "richInitialPrompt": {
          "items": [
            {
              "simpleResponse": {
                "textToSpeech": "The lowest temperature for today is 75 degrees Fahrenheit"
              }
            },
            {
              "simpleResponse": {
                "textToSpeech": "I can send you daily updates with the lowest temperature of the day. Would you like that?"
              }
            }
          ],
          "suggestions": [
            {
              "title": "Send daily updates"
            }
          ]
        }
      }
    }
  ]
}

2. Processar o registro de atualização

Configure uma nova intent que será acionada quando o usuário seguir a solicitação de registro. No fulfillment dessa nova intent, acione a intent integrada actions_intent_CONFIGURE_UPDATES com os seguintes parâmetros:

• intent: defina como a intent de atualização que você configurou.
• frequency: definido como "DAILY".

O código a seguir registra atualizações diárias para a intent "Temperatura mais baixa por dia":

app.intent('Subscribe to Daily Updates', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'Daily Lowest Temperature',
    frequency: 'DAILY',
  }));
});
index.js

conv.ask(new RegisterUpdate({
  intent: 'Daily Lowest Temperature',
  frequency: 'DAILY',
}));
index.js

@ForIntent("Subscribe to Daily Updates")
public ActionResponse subscribeToDailyUpdates(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  return responseBuilder.add(new RegisterUpdate()
      .setIntent("Daily Lowest Temperature")
      .setFrequency("DAILY"))
      .build();
}
UpdatesApp.java

ResponseBuilder responseBuilder = getResponseBuilder(request);
return responseBuilder.add(new RegisterUpdate()
    .setIntent("Daily Lowest Temperature")
    .setFrequency("DAILY"))
    .build();
UpdatesApp.java

{
  "payload": {
    "google": {
      "expectUserResponse": true,
      "systemIntent": {
        "intent": "actions.intent.REGISTER_UPDATE",
        "data": {
          "@type": "type.googleapis.com/google.actions.v2.RegisterUpdateValueSpec",
          "intent": "Daily Lowest Temperature",
          "triggerContext": {
            "timeContext": {
              "frequency": "DAILY"
            }
          }
        }
      }
    }
  }
}

{
  "expectUserResponse": true,
  "expectedInputs": [
    {
      "possibleIntents": [
        {
          "intent": "actions.intent.REGISTER_UPDATE",
          "inputValueData": {
            "@type": "type.googleapis.com/google.actions.v2.RegisterUpdateValueSpec",
            "intent": "Daily Lowest Temperature",
            "triggerContext": {
              "timeContext": {
                "frequency": "DAILY"
              }
            }
          }
        }
      ]
    }
  ]
}

3. Processar o resultado

O Google Assistente assume a conversa e orienta o usuário pelo restante da configuração de atualizações diárias. Quando o registro for concluído, o Google Assistente vai acionar uma intent com um parâmetro indicando se o registro foi bem-sucedido ou não.

As instruções para esta etapa são diferentes dependendo se você usa o Dialogflow ou o SDK do Actions para desenvolvimento.

app.intent('Confirm Daily Updates Subscription', (conv, params, registered) => {
  if (registered && registered.status === 'OK') {
    conv.close(`Ok, I'll start giving you daily updates.`);
  } else {
    conv.close(`Ok, I won't give you daily updates.`);
  }
});
index.js

@ForIntent("Confirm Daily Updates Subscription")
public ActionResponse confirmDailyUpdatesSubscription(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  if (request.isUpdateRegistered()) {
    responseBuilder.add("Ok, I'll start giving you daily updates.");
  } else {
    responseBuilder.add("Ok, I won't give you daily updates.");
  }
  return responseBuilder.endConversation().build();
}
UpdatesApp.java

{
  "payload": {
    "google": {
      "expectUserResponse": false,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "Ok, I'll start giving you daily updates."
            }
          }
        ]
      }
    }
  }
}

app.intent('actions.intent.REGISTER_UPDATE', (conv, params, registered) => {
  if (registered && registered.status === 'OK') {
    conv.close(`Ok, I'll start giving you daily updates.`);
  } else {
    conv.close(`Ok, I won't give you daily updates.`);
  }
});
index.js

@ForIntent("actions.intent.REGISTER_UPDATE")
public ActionResponse confirmDailyUpdatesSubscription(ActionRequest request) {
  ResponseBuilder responseBuilder = getResponseBuilder(request);
  if (request.isUpdateRegistered()) {
    responseBuilder.add("Ok, I'll start giving you daily updates.");
  } else {
    responseBuilder.add("Ok, I won't give you daily updates.");
  }
  return responseBuilder.endConversation().build();
}
UpdatesApp.java

{
  "expectUserResponse": false,
  "finalResponse": {
    "richResponse": {
      "items": [
        {
          "simpleResponse": {
            "textToSpeech": "Ok, I'll start giving you daily updates."
          }
        }
      ]
    }
  }
}

Personalizar atualizações (opcional)

Para personalizar a intent de atualização, adicione parâmetros personalizados quando os usuários registrarem atualizações diárias. Ao atender à intent de atualização, consulte esses parâmetros para personalizar a atualização diária do usuário.

As instruções para esse recurso serão diferentes se você usar o Dialogflow ou o SDK do Actions para desenvolvimento.

app.intent('setup_update', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'update_of_the_day',
    arguments: [
      {
        name: 'category',
        textValue: 'Daily_lowest_temperature',
      },
    ],
    frequency: 'DAILY',
  }));
});

@ForIntent("setup_update")
public ActionResponse setupUpdate2(ActionRequest request) {
  List<Argument> args =
      Arrays.asList(
          new Argument()
              .setName("category")
              .setTextValue(request.getParameter("category").toString()));
  return getResponseBuilder(request)
      .add(new RegisterUpdate().setIntent("intent_name").setArguments(args).setFrequency("DAILY"))
      .build();
}

{
  "payload": {
    "google": {
      "expectUserResponse": true,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "PLACEHOLDER"
            }
          }
        ]
      },
      "userStorage": "{\"data\":{}}",
      "systemIntent": {
        "intent": "actions.intent.REGISTER_UPDATE",
        "data": {
          "@type": "type.googleapis.com/google.actions.v2.RegisterUpdateValueSpec",
          "intent": "update_of_the_day",
          "arguments": [
            {
              "name": "category",
              "textValue": "Daily_lowest_temperature"
            }
          ],
          "triggerContext": {
            "timeContext": {
              "frequency": "DAILY"
            }
          }
        }
      }
    }
  },
  "outputContexts": [
    {
      "name": "/contexts/_actions_on_google",
      "lifespanCount": 99,
      "parameters": {
        "data": "{}"
      }
    }
  ]
}

app.intent('actions.intent.TEXT', (conv) => {
  if (conv.input.raw === 'Send daily') {
    conv.ask(new RegisterUpdate({
      intent: 'update_of_the_day',
      arguments: [
        {
          name: 'category',
          textValue: 'Daily_lowest_temperature',
        },
      ],
      frequency: 'DAILY',
    }));
  }
});

@ForIntent("actions.intent.CONFIGURE_UPDATES")
public ActionResponse configureUpdatesActionsSdk(ActionRequest request) {
  List<Argument> args =
      Arrays.asList(
          new Argument()
              .setName("category")
              .setTextValue(request.getParameter("category").toString()));
  return getResponseBuilder(request)
      .add(new RegisterUpdate().setIntent("intent_name").setArguments(args).setFrequency("DAILY"))
      .build();
}

@ForIntent("actions.intent.TEXT")
public ActionResponse text(ActionRequest request) {
  ResponseBuilder rb = getResponseBuilder(request);
  String input = request.getRawInput().getQuery();
  if (input.equals("DAILY_NOTIFICATION_SUGGESTION")) {
    rb.add("For which category do you want to receive daily updates?");
  } else {
    rb.add("Sorry, I didn't get that. Please try again later").endConversation();
  }
  return rb.build();
}

{
  "expectUserResponse": true,
  "expectedInputs": [
    {
      "inputPrompt": {
        "richInitialPrompt": {
          "items": [
            {
              "simpleResponse": {
                "textToSpeech": "PLACEHOLDER"
              }
            }
          ]
        }
      },
      "possibleIntents": [
        {
          "intent": "actions.intent.REGISTER_UPDATE",
          "inputValueData": {
            "@type": "type.googleapis.com/google.actions.v2.RegisterUpdateValueSpec",
            "intent": "update_of_the_day",
            "arguments": [
              {
                "name": "category",
                "textValue": "Daily_lowest_temperature"
              }
            ],
            "triggerContext": {
              "timeContext": {
                "frequency": "DAILY"
              }
            }
          }
        }
      ]
    }
  ],
  "conversationToken": "{\"data\":{}}",
  "userStorage": "{\"data\":{}}"
}

Quando o usuário invoca a atualização diária, a intent de atualização agora inclui argumentos contendo os valores fornecidos pelo usuário durante o registro. Use esses valores para personalizar a atualização para cada usuário.

Testar atualizações diárias

Teste suas atualizações diárias em um dispositivo móvel com o Google Assistente, usando a mesma Conta do Google usada para criar a ação. Invoque sua ação e inscreva-se para receber atualizações diárias. Depois, confira as notificações do dispositivo no horário da atualização.