Atualizações diárias (Dialogflow)

Um usuário que se inscreve para receber atualizações diárias de uma ação no smartphone

Se a Ação agregar valor aos usuários todos os dias, lembre-os de que usá-lo configurando atualizações diárias. Quando um usuário faz uma assinatura diária atualizações para sua Ação, eles vão receber uma notificação push toque para invocar uma das intents da sua ação.

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

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

Por padrão, a solicitação de registro de atualização diária aparece como um ícone de sugestão quando o usuário sai da ação. Você também pode adicionar uma conversa solicitação de registro 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ária para uma ação:

  • Certifique-se de que as atualizações diárias resultarão em visualizações diferentes e úteis informações todos os dias. Se tocar em uma atualização diária resultar na mesma solicitação o usuário provavelmente 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 sua intent da atualização diária. O usuário não começará necessariamente do início da conversa, então não se espera que elas tenham muito contexto.
  • Mostre ao usuário os benefícios da sua ação antes de solicitar o registro para receber atualizações diárias. Seu usuário deve pensar "Quero este conteúdo todos os dia" quando têm a opção de assinar.
  • Não sobrecarregue o usuário com várias sugestões de registro. Ofereça um a assinatura de atualização diária logo depois de mostrar ao usuário o que ele deveria e evite repetir a oferta em outros contextos.
  • Mantenha a conversa curta depois que a intent de atualização for acionada. Mais diário as atualizações devem consistir em uma única resposta e fechar sem exigindo entradas do usuário.
.

Configurar atualizações diárias

Explorar no Dialogflow

Clique em Continue para importar a amostra de atualizações diárias para o Dialogflow. Depois, siga as etapas abaixo para implantar e testar a amostra:

  1. Digite um nome de agente e crie um novo agente do Dialogflow para a amostra.
  2. Depois que a importação do agente terminar, clique em Go to agent.
  3. No menu de navegação principal, acesse Fulfillment.
  4. Ative o Editor in-line e clique em Implantar. O editor contém a amostra o código-fonte.
  5. No menu de navegação principal, acesse Integrações e clique em Google Google Assistente.
  6. Na janela modal exibida, ative a opção Mudanças na visualização automática e clique em Testar. para abrir o simulador do Actions.
  7. No simulador, insira Talk to my test app para testar a amostra.
Continuar

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

1. Preparar uma intent de atualização

Configure uma das intents da sua ação como uma intent de acionamento. Essa intent permite que uma atualização diária seja enviada aos usuários; quando um usuário abre a atualização diária. notificação, 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 Assistant, clique em Integration Settings.
  3. Em Descoberta > Invocação implícita, clique em Adicionar intent e selecione a intent de acionamento, caso ainda não esteja lá.
  4. Ative as mudanças da Visualização automática, caso ainda não esteja ativada.
  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 acionamento e como o Assistente do Dialogflow está definida para visualizar as alterações automaticamente.
  3. Role para baixo até a seção Engajamento do usuário e ative Quer oferecer atualizações diárias aos usuários?
  4. Digite um Título do conteúdo.
  5. Clique em Salvar.

Você configurou sua Ação para oferecer assinaturas de atualização diária por um intenção. Agora é possível 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 da atualização diária processada pelo Google Assistente fluxo de registro, inscreva usuários em atualizações diárias com seu prompt de registro e diálogo.

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

Para adicionar um aviso diário personalizado de registro de atualização à 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 um comando que os usuários se inscrevam em atualizações diárias. Oferecer esses comandos após a interação do usuário com a intenção de atualização para que eles entendam o conteúdo das suas atualizações.

O código de exemplo a seguir solicita que um usuário se inscreva em atualizações diárias que oferecer a temperatura mais baixa esperada todos os dias:

Node.js
.
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'));
});
Java
.
@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();
}
JSON do Dialogflow

O JSON abaixo descreve uma resposta do webhook.

{
  "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"
          }
        ]
      }
    }
  }
}
JSON do SDK do Actions

O JSON abaixo descreve uma resposta do webhook.

{
  "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ções

Configurar uma nova intent que será acionada quando o usuário seguir seu registro prompt de comando. No fulfillment dessa nova intent, acione o actions_intent_CONFIGURE_UPDATES. intent integrada com o parâmetros a seguir:

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

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

Dialogflow Node.js
.
app.intent('Subscribe to Daily Updates', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'Daily Lowest Temperature',
    frequency: 'DAILY',
  }));
});
SDK do Actions em Node.js
.
conv.ask(new RegisterUpdate({
  intent: 'Daily Lowest Temperature',
  frequency: 'DAILY',
}));
Dialogflow Java
.
@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();
}
SDK do Actions Java
.
ResponseBuilder responseBuilder = getResponseBuilder(request);
return responseBuilder.add(new RegisterUpdate()
    .setIntent("Daily Lowest Temperature")
    .setFrequency("DAILY"))
    .build();
JSON do Dialogflow
.
{
  "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"
            }
          }
        }
      }
    }
  }
}
JSON do SDK do Actions
{
  "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. Gerenciar o resultado

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

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

Dialogflow

Siga estas etapas para criar um intent que gerencie o resultado do registro:

  1. No console do Dialogflow, faça o seguinte: criar uma nova intent.
  2. Adicione o evento actions_intent_REGISTER_UPDATE.
  3. Ative o fulfillment do webhook para a intent.
  4. Clique em Salvar.
. No fulfillment da intent, verifique o registered para o resultado e dinamize a conversa de acordo com ele.
Dialogflow Node.js
.
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.`);
  }
});
Dialogflow Java
.
@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();
}
JSON do Dialogflow
.
{
  "payload": {
    "google": {
      "expectUserResponse": false,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "Ok, I'll start giving you daily updates."
            }
          }
        ]
      }
    }
  }
}
SDK do Actions

No código de fulfillment, adicione um processamento para o actions.intent.REGISTER.UPDATE em uma intent integrada. Verifique o parâmetro registered para o resultado. e direcionar a conversa de acordo com isso.

SDK do Actions em Node.js
.
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.`);
  }
});
SDK do Actions Java
.
@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();
}
JSON do SDK do Actions
{
  "expectUserResponse": false,
  "finalResponse": {
    "richResponse": {
      "items": [
        {
          "simpleResponse": {
            "textToSpeech": "Ok, I'll start giving you daily updates."
          }
        }
      ]
    }
  }
}

Personalizar as atualizações (opcional)

Para personalizar sua intent de atualização, adicione parâmetros personalizados quando os usuários se registrarem e atualizações diárias. Ao atender à intent de atualização, faça referência a esses parâmetros para personalizar a atualização diária para esse usuário.

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

Dialogflow

Defina uma entidade do Dialogflow para manipular parâmetros personalizados na atualização e transferir o valor do parâmetro como um argumento para a intent de atualização. Para configurar atualizações personalizadas no Dialogflow, siga estas etapas:

  1. No console do Dialogflow, crie uma nova entidade.
  2. Adicione algumas entradas e sinônimos relevantes para o parâmetro.
  3. Clique em Save e abra a intent de atualização.
  4. Na seção Ações e parâmetros, defina actions.intent.CONFIGURE_UPDATES. como o evento. Na mesma seção, adicione um parâmetro com o mesmo tipo da nova entidade.
  5. Abra o registro de atualização que processa a intent integrada CONFIGURE_UPDATES.
  6. Na seção Ações e parâmetros, adicione um parâmetro obrigatório e defina o tipo dele como a entidade criada anteriormente.
  7. Atualize o código de fulfillment da intent de registro para incluir um objeto arguments com o seguinte conteúdo:
    • name: o nome do parâmetro, conforme configurado no Dialogflow.
    • textValue: o valor do parâmetro.

O código a seguir lê e usa o valor do parâmetro. na solicitação de registro de atualização:

Dialogflow Node.js
.
app.intent('setup_update', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'update_of_the_day',
    arguments: [
      {
        name: 'category',
        textValue: 'Daily_lowest_temperature',
      },
    ],
    frequency: 'DAILY',
  }));
});
Dialogflow Java
.
@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();
}
JSON do Dialogflow
.
{
  "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": "{}"
      }
    }
  ]
}
SDK do Actions

Solicite mais informações ao usuário no fulfillment da intent. e, em seguida, entregue as informações como um argumento para a intent de atualização. Para configurar atualizações personalizadas no SDK do Actions, siga estas etapas:

  1. Solicite ao usuário as informações que você quer usar personalização.
  2. No código de fulfillment da "atualização do registro" que processa CONFIGURE UPDATES inclui um objeto arguments com o seguinte conteúdo:
    • name: um nome para o argumento.
    • textValue: informações do usuário a serem transmitidas como um argumento.

O código a seguir envia um argumento com a solicitação de registro de atualização:

SDK do Actions em Node.js
.
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',
    }));
  }
});
SDK do Actions Java
.
@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();
}
JSON do SDK do Actions
{
  "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 sua atualização diária, sua intent de atualização agora inclui argumentos contendo os valores fornecidos pelo usuário durante o registro. Use estas valores para personalizar a atualização para cada usuário.

Testar atualizações diárias

Teste suas atualizações diárias usando um dispositivo móvel com o Google Assistente usando a mesma Conta do Google que você usou para criar sua ação. Invocar sua ação e inscreva-se para receber atualizações diárias, depois confira as notificações do seu dispositivo o horário de atualização.