Tägliche Updates (Dialogflow)

Wenn deine Aktion Nutzern jeden Tag einen Mehrwert bietet, solltest du sie daran erinnern, tägliche Aktualisierungen konfigurieren. Wenn ein Nutzer täglich ein Abo abschließt für deine Aktion gibt, erhält sie eine Push-Benachrichtigung, Tippe, um einen der Intents deiner Aktion aufzurufen.

Für die Nutzer sind diese Aktualisierungen wie folgt:

1. Der Nutzer ruft einen der Intents deiner Aktion auf, die du als tägliches Update.
2. Der Nutzer folgt der Aufforderung, tägliche Updates zu abonnieren. Dieser Prompt ist oder als Vorschlags-Chip am Ende der Unterhaltung angezeigt werden.
3. Der Nutzer wählt eine Tageszeit aus, zu der er Ihre täglichen Benachrichtigungen erhalten möchte. durch die Registrierung deines Updates bei Google Assistant.
4. Der Nutzer erhält jeden Tag zur geplanten Zeit einen Assistenten. auf ihrem Mobilgerät.
5. Wenn der Nutzer diese Benachrichtigung öffnet, ruft er den Intent auf, täglich aktualisiert werden und mit deiner Aktion interagieren.

Standardmäßig wird die Registrierungsaufforderung für tägliche Updates als Vorschlags-Chip angezeigt Der Nutzer beendet deine Aktion erfolgreich. Sie können auch eine Person während der Unterhaltung hinzufügen, oder die Aktualisierungen des Nutzers personalisieren.

Anwendungsfälle

Tägliche Updates können ein nützliches Tool zur Interaktion sein, sollten es aber nicht die in jeder Aktion enthalten sind. Beachten Sie die folgenden Tipps, wenn Sie entscheiden, Tägliche Update-Abonnements für eine Aktion:

• Stellen Sie sicher, dass die täglichen Updates dazu führen, dass der Nutzer andere, nützliche Informationen zu erhalten. Wenn auf ein tägliches Update getippt wird, wird die gleiche Aufforderung angezeigt wird er das Abo wahrscheinlich nach ein paar Tagen kündigen.
• Achten Sie darauf, dass Ihr Dialog für die Nutzenden Sinn ergibt, wenn sie direkt zu Ihrem die Absicht des täglichen Updates aus. Die Nutzenden beginnen nicht unbedingt von vorn. des Gesprächs, daher sollte nicht erwartet werden, dass sie viel Kontext haben.
• Zeige den Nutzern die Vorteile deiner Aktion, bevor du sie zur Registrierung auffordert für tägliche Updates. Ihre Nutzer sollten denken: „Ich möchte diese Inhalte Tag“ wenn Nutzer ein Abo abschließen können.
• Überfordern Sie den Nutzer nicht mit wiederholten Registrierungsvorschlägen. Bieten Sie eine Abo für tägliche Updates, nachdem dem Nutzer gezeigt wird, was er abonnieren würde und vermeiden, das Angebot in anderen Kontexten zu wiederholen.
• Halten Sie die Unterhaltung kurz, nachdem der Update-Intent ausgelöst wurde. Meistens täglich Aktualisierungen sollten nur aus einer einzigen Antwort bestehen und dann ohne die eine Nutzereingabe erfordern.

Tägliche Updates einrichten

So konfigurierst du einen Intent deiner Aktion für tägliche Updates: Anweisungen:

1. Update-Intent vorbereiten

Konfiguriere einen der Intents deiner Aktion als auslösenden Intent. Dieser Intent Ermöglicht es, ein tägliches Update an die Nutzer zu senden; Ein Nutzer öffnet sein tägliches Update. der Intent-Trigger und der Unterhaltung wird von dort aus fortgesetzt.

So definieren Sie einen auslösenden Intent in Dialogflow:

1. Klicken Sie in der Dialogflow-Konsole auf Integrations (Integrationen).
2. Klicken Sie im Abschnitt Google Assistant auf Integrationseinstellungen.
3. Wählen Sie unter Discovery > Impliziter Aufruf: Klicken Sie auf Intent hinzufügen. und wählen Sie den auslösenden Intent aus, sofern er noch nicht vorhanden ist.
4. Aktivieren Sie Automatische Vorschau, falls die Funktion noch nicht aktiviert ist.
5. Klicken Sie auf Schließen.

Definieren Sie im Actions SDK den Update-Intent als auslösenden Intent in der Aktionspaket

2. Updates aktivieren

So aktivieren Sie tägliche Updates für Ihren Trigger-Intent:

1. Führen Sie in der Actions Console folgende Schritte aus: Gehen Sie zu Entwickeln > Aktionen:
2. Wählen Sie den auslösenden Intent aus. Wenn Ihr Intent nicht in der Liste angezeigt wird, Prüfen Sie, ob er als auslösender Intent und als Assistant von Dialogflow konfiguriert ist ist auf die automatische Vorschau von Änderungen eingestellt.
3. Scrollen Sie nach unten zum Abschnitt Nutzer-Engagement und aktivieren Sie die Option. Möchten Sie Nutzern tägliche Updates anbieten?
4. Geben Sie einen Titel für den Inhalt ein.
5. Klicken Sie auf Speichern.

Du hast deine Aktion jetzt so konfiguriert, dass tägliche Update-Abonnements für eine die Nutzerabsicht verstehen. Du kannst deine täglichen Updates jetzt auf deinem eigenen Mobilgerät testen.

Registrierung für Updates anpassen (optional)

Zusätzlich zum Vorschlags-Chip und dem von Assistant verarbeiteten täglichen Update Registrierungsvorgang für Nutzer, Abonnements für tägliche Updates eigenen Dialogfeld und Registrierungsaufforderung.

Ein vollständiges Beispiel für eine Aktion, die optionale Funktionen für tägliche Updates verarbeitet, Beispiele für das Nutzer-Engagement in Actions on Google (Node.js und Java).

Wenn du deiner Unterhaltung eine benutzerdefinierte Aufforderung zur Registrierung für tägliche Updates hinzufügen möchtest, folge dieser Anleitung:

1. Registrierungsaufforderung hinzufügen

Du kannst der Unterhaltung Dialoge und einen Vorschlags-Chip hinzufügen, wenn du dich auffordern möchtest um tägliche Updates zu abonnieren. Biete diese Aufforderungen an, nachdem der Nutzer interagiert hat aktualisiert werden, damit sie den Inhalt des Aktualisierungen.

Der folgende Beispielcode fordert einen Nutzer auf, tägliche Updates zu abonnieren, bieten jeden Tag die niedrigste erwartete Temperatur an:

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

Richten Sie einen neuen Intent ein, der ausgelöst wird, wenn der Nutzer Ihrer Registrierung folgt . Lösen Sie in der Auftragsausführung für diesen neuen Intent actions_intent_CONFIGURE_UPDATES aus. integrierten Intent mit dem folgende Parameter:

• intent: Legen Sie den von Ihnen konfigurierten Update-Intent fest.
• frequency: auf DAILY gesetzt.

Mit dem folgenden Code werden tägliche Aktualisierungen für die „Niedrigste tägliche Temperatur“ registriert. 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. Ergebnis verarbeiten

Assistant übernimmt die Unterhaltung und führt den Nutzer durch die für die restlichen täglichen Updates. Wenn die Registrierung abgeschlossen ist, löst Assistant einen Intent mit einem Parameter aus, der angibt, ob die Registrierung erfolgreich war oder nicht.

Die Anweisungen für diesen Schritt unterscheiden sich je nachdem, Dialogflow oder das Actions SDK für die Entwicklung verwenden.

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."
          }
        }
      ]
    }
  }
}

Updates personalisieren (optional)

Fügen Sie benutzerdefinierte Parameter hinzu, wenn sich Nutzer registrieren, um den Update-Intent zu personalisieren tägliche Updates. Wenn Sie den Update-Intent erfüllen, verweisen Sie auf diese Parameter um das tägliche Update für diesen Nutzer anzupassen.

Die Anleitung für diese Funktion hängt davon ab, ob Sie Dialogflow oder das Actions SDK für die Entwicklung verwenden.

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\":{}}"
}

Wenn der Nutzer Ihr tägliches Update aufruft, enthält Ihr Update-Intent jetzt Folgendes: Argumente mit den Werten, die der Nutzer bei der Registrierung angegeben hat Diese , um das Update für jeden Nutzer zu personalisieren.

Tägliche Updates testen

Testen Sie Ihre täglichen Updates auf einem Mobilgerät mit Google Assistant unter mit dem du deine Aktion erstellt hast. Aktion aufrufen und tägliche Updates abonnieren und die Benachrichtigungen auf deinem Gerät zum Zeitpunkt der Aktualisierung.