Mises à jour quotidiennes (Dialogflow)

Un utilisateur s'abonnant aux mises à jour quotidiennes d'une action sur son téléphone

Si votre action apporte une valeur ajoutée aux utilisateurs tous les jours, rappelez-leur l'utiliser en configurant des mises à jour quotidiennes. Lorsqu'un utilisateur s'abonne à des des mises à jour de votre action, il reçoit une notification push appuyez pour appeler l'un des intents de votre action.

Voici l'expérience utilisateur concernant ces mises à jour:

  1. L'utilisateur appelle l'un des intents de votre action que vous avez configurés en tant que chaque jour.
  2. L'utilisateur suit une invite pour s'abonner aux informations quotidiennes. Cette requête est en cours de conversation ou sous forme de chip de suggestion à la fin de la conversation.
  3. L'utilisateur planifie l'heure à laquelle il souhaite recevoir vos mise à jour, enregistrant votre mise à jour auprès de l'Assistant Google.
  4. À l'heure prévue chaque jour, l'utilisateur reçoit un Assistant sur son appareil mobile.
  5. Lorsque l'utilisateur ouvre cette notification, il appelle l'intent que vous configurée comme une mise à jour quotidienne et interagir avec votre action.

Par défaut, l'invite d'enregistrement d'une mise à jour quotidienne s'affiche sous la forme d'un chip de suggestion lorsque l'utilisateur quitte votre action. Vous pouvez aussi ajouter une fenêtre en cours de conversation invite d'inscription ou personnalise les mises à jour de l'utilisateur.

Cas d'utilisation

Les mises à jour quotidiennes peuvent être un outil d'engagement utile, mais ne doivent pas intégrés à chaque action. Tenez compte de ces conseils pour décider d'ajouter ou non abonnements de mises à jour quotidiennes à une action:

  • Assurez-vous que les mises à jour quotidiennes présentent un contenu différent et utile des informations tous les jours. Si appuyer sur une information quotidienne donne lieu à la même invite à chaque fois, il est probable que l'utilisateur se désabonne après quelques jours.
  • Assurez-vous que votre dialogue a du sens pour votre utilisateur s'il passe directement à votre l'intent de mise à jour quotidienne. L'utilisateur ne recommence pas nécessairement du début de la conversation, il ne faut donc pas s'attendre à ce qu'ils aient beaucoup de contexte.
  • Montrez à l'utilisateur les avantages de votre action avant de l'inviter à s'inscrire pour obtenir des informations quotidiennes. L'utilisateur doit se dire : "Je veux ce contenu tous les jour" lorsqu'ils ont la possibilité de s'abonner.
  • Ne submergez pas l'utilisateur de nombreuses suggestions d'inscription. Proposez une d’un abonnement à une mise à jour quotidienne juste après avoir montré à l’utilisateur à quoi il s’abonnerait et évitez de répéter l'offre dans d'autres contextes.
  • Faites en sorte que la conversation soit courte après le déclenchement de l'intent de mise à jour. La plupart du temps les mises à jour doivent se limiter à une seule réponse, puis se fermer sans nécessitant une entrée utilisateur.

Configurer des mises à jour quotidiennes

Explorer dans Dialogflow

Cliquez sur Continue (Continuer) pour importer notre exemple "Mises à jour quotidiennes" dans Dialogflow. Suivez ensuite les procédez comme suit pour déployer et tester l'exemple:

  1. Saisissez un nom d'agent et créez un agent Dialogflow pour l'exemple.
  2. Une fois l'importation de l'agent terminée, cliquez sur Accéder à l'agent.
  3. Dans le menu de navigation principal, accédez à Fulfillment.
  4. Activez l'éditeur intégré, puis cliquez sur Déployer. L'éditeur contient l'exemple du code source.
  5. Dans le menu de navigation principal, accédez à Integrations (Intégrations), puis cliquez sur Google l'Assistant Google.
  6. Dans la fenêtre modale qui s'affiche, activez Auto-preview changes (Prévisualisation automatique des modifications), puis cliquez sur Test (Tester). pour ouvrir le simulateur d'actions.
  7. Dans le simulateur, saisissez Talk to my test app pour tester l'échantillon.
<ph type="x-smartling-placeholder"></ph> Continuer

Pour configurer l'un des intents de votre action afin de recevoir des mises à jour quotidiennes, procédez comme suit : instructions:

1. Préparer un intent de mise à jour

Configurez l'un des intents de votre action en tant qu'intent déclencheur. Cet intent permet d'envoyer une mise à jour quotidienne aux utilisateurs ; Lorsqu'un utilisateur ouvre sa mise à jour quotidienne les déclencheurs d'intent et la conversation continue à partir de là.

Pour définir un intent de déclenchement dans Dialogflow, procédez comme suit:

  1. Dans la console Dialogflow, cliquez sur Intégrations :
  2. Dans la section Google Assistant (Assistant Google), cliquez sur Integration Settings (Paramètres d'intégration).
  3. Sous Découverte > Appel implicite, cliquez sur Ajouter un intent. et sélectionnez votre intent de déclenchement, s'il n'est pas déjà présent.
  4. Activez les modifications apportées à l'aperçu automatique si ce n'est pas déjà fait.
  5. Cliquez sur Fermer.

Dans le SDK Actions, définissez votre intent de mise à jour en tant qu'intent déclencheur dans Package d'actions.

2. Activer les mises à jour

Pour activer les mises à jour quotidiennes pour votre intent de déclenchement, procédez comme suit:

  1. Dans la console Actions : accédez à Développer > les actions.
  2. Sélectionnez l'intent de déclenchement. Si votre intent n'apparaît pas dans la liste, assurez-vous qu'il est configuré en tant qu'intent de déclenchement et en tant qu'Assistant de Dialogflow est configurée pour prévisualiser automatiquement les modifications.
  3. Faites défiler la page jusqu'à la section Engagement utilisateur, puis activez Souhaitez-vous proposer des mises à jour quotidiennes aux utilisateurs ?
  4. Saisissez le titre du contenu.
  5. Cliquez sur Enregistrer.

Vous avez configuré votre action pour proposer des abonnements aux mises à jour quotidiennes pour une l'intention. Vous pouvez désormais tester vos mises à jour quotidiennes sur votre propre appareil mobile.

Personnaliser l'enregistrement des mises à jour (facultatif)

En plus du chip de suggestion et des informations quotidiennes gérées par l'Assistant flux d'inscription, abonner les utilisateurs aux mises à jour quotidiennes avec votre sa propre boîte de dialogue et une invite d'inscription.

Pour obtenir un exemple complet d'une action qui gère des fonctionnalités facultatives de mise à jour quotidienne, voir les exemples d'engagement utilisateur dans Actions on Google (Node.js et Java).

Pour ajouter une invite d'inscription quotidienne personnalisée à votre conversation, suivez suivez ces instructions:

1. Ajouter une invite d'inscription

Ajoutez un dialogue et un chip de suggestion à la conversation lorsque vous souhaitez y être invité aux utilisateurs de s'abonner aux mises à jour quotidiennes. Proposer ces invites après que l'utilisateur a interagi avec votre intent de mise à jour, pour qu'ils comprennent le contenu mises à jour.

L'exemple de code suivant invite un utilisateur à s'abonner aux mises à jour quotidiennes qui proposent la température attendue la plus basse chaque jour:

<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
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'));
});
index.js
<ph type="x-smartling-placeholder">
</ph>
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();
}
UpdatesApp.java
<ph type="x-smartling-placeholder">
</ph>
JSON Dialogflow

Notez que le code JSON ci-dessous décrit une réponse 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"
          }
        ]
      }
    }
  }
}
<ph type="x-smartling-placeholder">
</ph>
JSON SDK Actions

Notez que le code JSON ci-dessous décrit une réponse 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. Gérer l'enregistrement d'une mise à jour

Configurer un nouvel intent qui se déclenche lorsque l'utilisateur suit votre inscription requête. Dans le traitement de ce nouvel intent, déclenchez actions_intent_CONFIGURE_UPDATES. un intent intégré avec les paramètres suivants:

  • intent : définie sur l'intent de mise à jour que vous avez configuré.
  • frequency : définie sur DAILY.

Le code suivant enregistre des mises à jour quotidiennes de la "température la plus basse quotidienne" intent:

<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
Dialogflow Node.js
app.intent('Subscribe to Daily Updates', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'Daily Lowest Temperature',
    frequency: 'DAILY',
  }));
});
index.js
<ph type="x-smartling-placeholder">
</ph>
SDK Actions Node.js
conv.ask(new RegisterUpdate({
  intent: 'Daily Lowest Temperature',
  frequency: 'DAILY',
}));
index.js
<ph type="x-smartling-placeholder">
</ph>
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();
}
UpdatesApp.java
<ph type="x-smartling-placeholder">
</ph>
SDK Actions Java
ResponseBuilder responseBuilder = getResponseBuilder(request);
return responseBuilder.add(new RegisterUpdate()
    .setIntent("Daily Lowest Temperature")
    .setFrequency("DAILY"))
    .build();
UpdatesApp.java
<ph type="x-smartling-placeholder">
</ph>
JSON 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"
            }
          }
        }
      }
    }
  }
}
<ph type="x-smartling-placeholder">
</ph>
SDK Actions (JSON)
{
  "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. Gérer le résultat

L'Assistant prend en charge votre conversation et guide l'utilisateur tout au long le reste de la configuration de ses mises à jour quotidiennes. Une fois l'enregistrement terminé, l'Assistant déclenche un intent avec un paramètre indiquant si l'inscription a réussi ou non.

Les instructions pour cette étape varient selon que vous utilisez Dialogflow ou le SDK Actions pour le développement.

<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
Dialogflow

Pour créer un intent qui gère le résultat de l'enregistrement, procédez comme suit:

  1. Dans la console Dialogflow, créer un intent.
  2. Ajoutez l'événement actions_intent_REGISTER_UPDATE.
  3. Activez le fulfillment du webhook pour l'intent.
  4. Cliquez sur Enregistrer.
Dans le traitement de l'intent, vérifiez le registered. du résultat et faites pivoter la conversation en conséquence. <ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
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.`);
  }
});
index.js
<ph type="x-smartling-placeholder">
</ph>
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();
}
UpdatesApp.java
<ph type="x-smartling-placeholder">
</ph>
JSON Dialogflow
{
  "payload": {
    "google": {
      "expectUserResponse": false,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "Ok, I'll start giving you daily updates."
            }
          }
        ]
      }
    }
  }
}
<ph type="x-smartling-placeholder">
</ph>
SDK Actions

Dans votre code fulfillment, ajoutez la gestion pour actions.intent.REGISTER.UPDATE. un intent intégré. Vérifiez le paramètre registered pour le résultat. et faire pivoter la conversation en conséquence.

<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
SDK Actions 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.`);
  }
});
index.js
<ph type="x-smartling-placeholder">
</ph>
SDK 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();
}
UpdatesApp.java
<ph type="x-smartling-placeholder">
</ph>
SDK Actions (JSON)
{
  "expectUserResponse": false,
  "finalResponse": {
    "richResponse": {
      "items": [
        {
          "simpleResponse": {
            "textToSpeech": "Ok, I'll start giving you daily updates."
          }
        }
      ]
    }
  }
}

Personnaliser les notifications (facultatif)

Pour personnaliser votre intent de mise à jour, ajoutez des paramètres personnalisés lorsque les utilisateurs s'inscrivent des mises à jour quotidiennes. Lorsque vous traitez l'intent de mise à jour, référencez ces paramètres pour personnaliser la mise à jour quotidienne pour cet utilisateur.

Les instructions relatives à cette fonctionnalité varient selon que vous utilisez Dialogflow ou le SDK Actions pour le développement.

<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
Dialogflow

définir une entité Dialogflow pour gérer les paramètres personnalisés de la mise à jour, puis transmettez la valeur du paramètre en tant qu'argument à votre intent de mise à jour. Pour configurer des mises à jour personnalisées dans Dialogflow, procédez comme suit:

  1. Dans la console Dialogflow, créez une entité.
  2. Ajoutez des entrées et des synonymes pertinents pour votre paramètre.
  3. Cliquez sur Save (Enregistrer), puis ouvrez votre intent de mise à jour.
  4. Dans la section Actions and parameters (Actions et paramètres), définissez actions.intent.CONFIGURE_UPDATES. que l'événement. Dans la même section, ajoutez un paramètre du même type que la nouvelle entité.
  5. Ouvrez le dossier "Mettre à jour l'enregistrement" qui gère l'intent intégré CONFIGURE_UPDATES.
  6. Dans la section Actions and parameters (Actions et paramètres), ajoutez un paramètre obligatoire et définissez son type sur l'entité créée précédemment.
  7. Mettez à jour le code de traitement de votre intent d'enregistrement pour inclure un objet arguments avec le contenu suivant: <ph type="x-smartling-placeholder">
      </ph>
    • name : indiquez le nom du paramètre tel qu'il est configuré dans Dialogflow.
    • textValue : valeur de votre paramètre.

Le code suivant lit la valeur du paramètre et l'utilise dans la requête de mise à jour de l'enregistrement:

<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
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',
  }));
});
<ph type="x-smartling-placeholder">
</ph>
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();
}
<ph type="x-smartling-placeholder">
</ph>
JSON 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": "{}"
      }
    }
  ]
}
<ph type="x-smartling-placeholder">
</ph>
SDK Actions

Demander des informations supplémentaires à l'utilisateur dans le traitement de votre intent puis transmettez ces informations en tant qu'argument à votre intent de mise à jour. Pour configurer des mises à jour personnalisées dans le SDK Actions, procédez comme suit:

  1. Demander à l'utilisateur les informations que vous souhaitez utiliser la personnalisation.
  2. Dans votre code de traitement pour votre "mise à jour de l'enregistrement" que gère l'CONFIGURE UPDATES inclure un objet arguments avec le contenu suivant: <ph type="x-smartling-placeholder">
      </ph>
    • name : nom de votre argument.
    • textValue : informations fournies par l'utilisateur, à transmettre en tant qu'argument.

Le code suivant envoie un argument avec la requête d'enregistrement de mise à jour:

<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph>
SDK Actions 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',
    }));
  }
});
<ph type="x-smartling-placeholder">
</ph>
SDK 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();
}
<ph type="x-smartling-placeholder">
</ph>
SDK Actions (JSON)
{
  "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\":{}}"
}

Lorsque l'utilisateur appelle votre mise à jour quotidienne, votre intent de mise à jour inclut désormais arguments contenant les valeurs fournies par l'utilisateur lors de l'inscription. Utilisez ces pour personnaliser la mise à jour pour chaque utilisateur.

Tester les mises à jour quotidiennes

Testez vos mises à jour quotidiennes sur un appareil mobile doté de l'Assistant Google en utilisant le même compte Google que celui utilisé pour créer votre action. Appeler votre action et vous abonner aux mises à jour quotidiennes, puis consultez les notifications l'heure de mise à jour.