Atualizações diárias (Dialogflow)

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

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:

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çõ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:

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

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

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