Tägliche Updates (Dialogflow)

Wenn deine Aktion Nutzern jeden Tag einen Mehrwert bietet, konfiguriere tägliche Updates, um sie daran zu erinnern, sie zu verwenden. Wenn ein Nutzer tägliche Updates für deine Aktion abonniert, erhält er eine Push-Benachrichtigung, auf die er tippen kann, um einen der Intents deiner Aktion aufzurufen.

Für den Nutzer sieht die Aktualisierung so aus:

1. Der Nutzer ruft einen der Intents deiner Aktion auf, die du als tägliches Update konfiguriert hast.
2. Der Nutzer folgt einer Aufforderung, die täglichen Updates zu abonnieren. Diese Aufforderung wird während der Unterhaltung oder als Vorschlags-Chip am Ende der Unterhaltung angezeigt.
3. Der Nutzer legt fest, zu welcher Tageszeit er Ihr tägliches Update erhalten möchte, und registriert es bei Google Assistant.
4. Der Nutzer erhält jeden Tag zur geplanten Uhrzeit eine Assistant-Benachrichtigung auf seinem Mobilgerät.
5. Wenn der Nutzer diese Benachrichtigung öffnet, ruft er den Intent auf, den du als tägliche Aktualisierung konfiguriert hast, und interagiert mit deiner Aktion.

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

Anwendungsfälle

Tägliche Updates können ein nützliches Interaktionstool sein, sollten aber nicht in jede Aktion einbezogen werden. Beachten Sie die folgenden Tipps, wenn Sie entscheiden, ob Sie einer Aktion Abos für tägliche Updates hinzufügen möchten:

• Achten Sie darauf, dass Nutzer durch die täglichen Aktualisierungen jeden Tag andere, nützliche Informationen sehen. Wenn das Tippen auf ein tägliches Update immer wieder dieselbe Aufforderung anzeigt, wird sich der Nutzer wahrscheinlich nach ein paar Tagen abmelden.
• Achte darauf, dass dein Dialog für Nutzer sinnvoll ist, wenn sie direkt zu deinem täglichen Update kommen. Nutzer beginnen nicht unbedingt am Anfang der Unterhaltung, daher sollte nicht von ihnen erwartet werden, dass sie viel Kontext haben.
• Zeige deinen Nutzern die Vorteile deiner Aktion, bevor du sie aufforderst, sich für tägliche Updates zu registrieren. Nutzer sollten denken: „Ich möchte diese Inhalte jeden Tag haben“, wenn sie ein Abo abschließen können.
• Überfordern Sie den Nutzer nicht mit wiederholten Aufforderungen zur Registrierung. Biete dem Nutzer ein Abo für tägliche Updates an, nachdem du ihm gezeigt hast, was er abonnieren würde. Wiederhole das Angebot nicht in anderen Kontexten.
• Halten Sie die Unterhaltung kurz, nachdem der Update-Intent ausgelöst wurde. Die meisten täglichen Aktualisierungen sollten nur aus einer einzigen Antwort bestehen und dann geschlossen werden, ohne dass Nutzereingaben erforderlich sind.

Tägliche Updates einrichten

So konfigurieren Sie einen Intent Ihrer Aktion für tägliche Updates:

1. Update-Intent vorbereiten

Konfigurieren Sie einen der Aktions-Intents als auslösenden Intent. Mit diesem Intent wird ein tägliches Update an Nutzer gesendet. Wenn ein Nutzer seine tägliche Aktualisierungsbenachrichtigung öffnet, wird der Intent ausgelöst und die Unterhaltung wird von dort 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 Integration Settings (Integrationseinstellungen).
3. Klicken Sie unter Erkennung > Impliziter Aufruf auf Intent hinzufügen und wählen Sie den auslösenden Intent aus, falls er noch nicht vorhanden ist.
4. Aktivieren Sie die Option Automatische Vorschau von Änderungen, falls sie noch nicht aktiviert ist.
5. Klicken Sie auf Schließen.

Definieren Sie im Actions SDK den Update-Intent als auslösenden Intent im Action-Paket.

2. Updates aktivieren

So aktivieren Sie tägliche Updates für den auslösenden Intent:

1. Rufen Sie in der Aktionskonsole Entwickeln > Aktionen auf.
2. Wählen Sie den auslösenden Intent aus. Wenn der Intent nicht in der Liste angezeigt wird, muss er als auslösender Intent konfiguriert und für die Assistant-Integration von Dialogflow muss die automatische Vorschau von Änderungen aktiviert sein.
3. Scrollen Sie nach unten zum Abschnitt Nutzerinteraktion und aktivieren Sie Möchtest du den Nutzern tägliche Updates anbieten.
4. Geben Sie einen Inhaltstitel ein.
5. Klicken Sie auf Speichern.

Sie haben Ihre Aktion jetzt so konfiguriert, dass Abos für tägliche Updates für einen Intent angeboten werden. 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 kannst du den Nutzern tägliche Updates mit deinem eigenen Dialogfeld und deiner eigenen Registrierungsaufforderung abonnieren.

Ein vollständiges Beispiel für eine Aktion, die optionale tägliche Updatefunktionen verarbeitet, findest du in den Actions on Google-Beispielen für Nutzerinteraktionen (Node.js und Java).

Folgen Sie dieser Anleitung, um Ihrer Unterhaltung eine benutzerdefinierte Registrierungsaufforderung für ein tägliches Update hinzuzufügen:

1. Registrierungsaufforderung hinzufügen

Fügen Sie der Unterhaltung einen Dialog und einen Vorschlags-Chip hinzu, wenn Sie Nutzer auffordern möchten, tägliche Updates zu abonnieren. Bieten Sie diese Aufforderungen an, nachdem der Nutzer mit Ihrem Update-Intent interagiert hat, damit er den Inhalt Ihrer täglichen Updates versteht.

Mit dem folgenden Beispielcode wird der Nutzer aufgefordert, tägliche Updates zu abonnieren, die die niedrigste erwartete Temperatur pro Tag bieten:

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. Registrierung von Updates verarbeiten

Richten Sie einen neuen Intent ein, der ausgelöst wird, wenn der Nutzer Ihrer Registrierungsaufforderung folgt. Lösen Sie in der Auftragsausführung für diesen neuen Intent den integrierten Intent actions_intent_CONFIGURE_UPDATES mit den folgenden Parametern aus:

• intent: Legen Sie den Update-Intent fest, den Sie konfiguriert haben.
• frequency: auf DAILY setzen.

Mit dem folgenden Code werden tägliche Aktualisierungen für den Intent „Tägliche niedrigste Temperatur“ registriert:

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 Ihre Unterhaltung und führt den Nutzer durch die übrigen 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, ob Sie 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 Nutzer tägliche Updates registrieren, um den Update-Intent zu personalisieren. Wenn Sie den Update-Intent erfüllen, können Sie auf diese Parameter verweisen, um das tägliche Update für diesen Nutzer anzupassen.

Die Anleitungen für diese Funktion unterscheiden sich je nachdem, 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 das tägliche Update aufruft, schließt der Update-Intent jetzt Argumente ein, die die vom Nutzer bei der Registrierung angegebenen Werte enthalten. Verwenden Sie diese Werte, um das Update für jeden Nutzer zu personalisieren.

Tägliche Updates testen

Teste deine täglichen Updates auf einem Mobilgerät mit Google Assistant. Verwende dazu dasselbe Google-Konto, mit dem du deine Aktion erstellt hast. Rufe deine Aktion auf und abonniere tägliche Updates. Prüfe dann die Benachrichtigungen deines Geräts um den Aktualisierungszeitpunkt.