Codzienne aktualizacje (Dialogflow)

Jeśli akcja każdego dnia jest wartościowa dla użytkowników, przedstaw im przypomnienie, z niego, konfigurując aktualizacje dzienne. Gdy użytkownik zasubskrybuje kanał codziennie informacje dotyczące Twojej akcji, otrzymają powiadomienie push, kliknij, aby wywołać jeden z intencji akcji.

Jak wyglądają te zmiany dla użytkowników:

1. Użytkownik wywołuje jedną z intencji akcji skonfigurowanych jako Codzienna aktualizacja.
2. Użytkownik postępuje zgodnie z prośbą o zasubskrybowanie codziennych aktualizacji. Ten prompt to w trakcie rozmowy lub jako element z sugestią po zakończeniu rozmowy.
3. Użytkownik ustawia godzinę, o której chce otrzymywać codziennie aktualizację i rejestrowanie aktualizacji w Asystencie Google.
4. Codziennie o zaplanowanej godzinie użytkownik otrzymuje Asystenta powiadomienie na urządzeniu mobilnym.
5. Gdy użytkownik otworzy to powiadomienie, wywoła intencję jest skonfigurowana jako codzienna aktualizacja i wchodzi w interakcję z akcją.

Domyślnie prośba o rejestrację aktualizacji dziennych jest wyświetlana jako element z sugestią. gdy użytkownik pomyślnie opuści akcję. Możesz też dodać w trakcie rozmowy lub personalizować aktualizacje użytkownika.

Przypadki użycia

Codzienne aktualizacje mogą być przydatnym narzędziem do zwiększania zaangażowania, ale nie powinny stanowiącej część każdej Akcji. Zanim zdecydujesz się na dodanie witryny, weź pod uwagę te wskazówki dzienne subskrypcje aktualizacji akcji:

• Upewnij się, że dzięki codziennym aktualizacjom użytkownicy widzą różne, przydatne informacji każdego dnia. Jeśli po kliknięciu codziennej aktualizacji pojawia się ten sam komunikat za każdym razem użytkownik prawdopodobnie anuluje subskrypcję po kilku dniach.
• Zadbaj o to, by Twoje dialogi były zrozumiałe dla użytkownika, jeśli przechodzi bezpośrednio codzienną aktualizację. Twój użytkownik nie musi zaczynać od początku w ramach rozmowy, więc nie należy oczekiwać, że mają one zbyt obszerny kontekst.
• Pokaż użytkownikowi korzyści płynące z akcji, zanim zachęcisz go do rejestracji aby otrzymywać codzienne aktualizacje. Użytkownik powinien myśleć: „Chcę, aby te treści dzień” gdy pojawi się możliwość subskrypcji.
• Nie przytłaczaj użytkownika powtarzających się sugestii dotyczących rejestracji. Zaoferuj Codzienna subskrypcja aktualizacji zaraz po wyświetleniu użytkownikowi treści, które byłaby zasubskrybowana i unikaj powtarzania oferty w innych kontekstach.
• Po wywołaniu intencji aktualizacji niech rozmowa musi być krótka. Najczęściej codziennie aktualizacje powinny się składać tylko z jednej odpowiedzi, a następnie zamykać bez wymagają danych użytkownika.

Skonfiguruj codzienne aktualizacje

Aby skonfigurować codzienne aktualizacje jednej z intencji akcji, postępuj zgodnie z tymi instrukcjami instrukcje:

1. Przygotowywanie intencji aktualizacji

Skonfiguruj jedną z intencji akcji jako intencję wyzwalającą. Ta intencja umożliwia wysyłanie do użytkowników codziennej aktualizacji; gdy użytkownik uruchomi swoją codzienną aktualizację. intencja, powiadomienie, intencja co dalej.

Aby zdefiniować intencję wyzwalającą w Dialogflow, wykonaj te czynności:

1. W konsoli Dialogflow kliknij Integracje.
2. W sekcji Asystent Google kliknij Ustawienia integracji.
3. W sekcji Odkrywanie > Wywołanie niejawne – kliknij Dodaj intencję. i wybierz intencję wywołującą, jeśli jeszcze jej nie masz.
4. Włącz opcję Automatyczny podgląd zmian, jeśli nie jest jeszcze włączona.
5. Kliknij Zamknij.

W pakiecie SDK Actions zdefiniuj intencję aktualizacji jako intencję wyzwalającą Pakiet działań.

2. Włącz aktualizacje

Aby włączyć codzienne aktualizacje dla intencji wywołujących, wykonaj te czynności:

1. W konsoli działań: przejdź do Programowanie > Działania.
2. Wybierz intencję wywołującą. Jeśli intencji nie ma na liście, sprawdź, czy jest skonfigurowana jako intencja wyzwalająca, a w Asystencie Dialogflow jest włączone automatyczne wyświetlanie podglądu zmian.
3. Przewiń w dół do sekcji Zaangażowanie użytkowników i włącz tę opcję. Czy chcesz oferować użytkownikom codzienne aktualności.
4. Wypełnij pole Tytuł treści.
5. Kliknij Zapisz.

Akcja została skonfigurowana tak, aby oferowała subskrypcje codziennych aktualizacji przez intencji. Możesz teraz testować codzienne aktualizacje na własnym urządzeniu mobilnym.

Dostosuj rejestrację w związku z aktualizacją (opcjonalnie)

Oprócz elementu z sugestią i codziennych aktualizacji obsługiwanych przez Asystenta procesu rejestracji, zasubskrybuj dla użytkowników codzienne aktualizacje w ramach własnego okna i promptu rejestracji.

Pełny przykład akcji, która obsługuje opcjonalne funkcje codziennej aktualizacji: zobacz przykłady zaangażowania użytkowników w Actions on Google (Node.js) i Java).

Aby dodać do rozmowy niestandardową prośbę o rejestrację aktualizacji na dany dzień, postępuj zgodnie z instrukcjami te instrukcje:

1. Dodaj prośbę o rejestrację

Dodaj do rozmowy okno i element z sugestią, gdy chcesz prosić o zgodę na subskrybowanie codziennych aktualizacji. Wyświetlaj te prompty po interakcji użytkownika z zamiarem aktualizacji, tak by zrozumieli zawartość Twojego dnia aktualizacje.

Ten przykładowy kod zachęca użytkownika do subskrybowania codziennych aktualizacji, które oferuje najniższą przewidywaną temperaturę każdego dnia:

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. Obsługa rejestracji aktualizacji

Skonfiguruj nową intencję, która będzie aktywowana, gdy użytkownik rozpocznie rejestrację . W ramach realizacji tej nowej intencji aktywuj actions_intent_CONFIGURE_UPDATES intencje wbudowane następujące parametry:

• intent – ustaw skonfigurowany przez Ciebie intencję aktualizacji.
• frequency – ustaw „DAILY”.

Ten kod rejestruje codzienne aktualizacje „najniższej temperatury w ciągu dnia” intencja:

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. Obsługa wyników

Asystent przejmuje Twoją rozmowę i podaje użytkownikowi reszty konfiguracji codziennych aktualizacji. Po zakończeniu rejestracji Asystent wywołuje intencję z parametrem wskazującym, czy czy rejestracja zakończyła się sukcesem.

Instrukcje dotyczące tego kroku różnią się w zależności od tego, Dialogflow lub Actions SDK;

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

Personalizuj aktualizacje (opcjonalnie)

Aby spersonalizować zamiar aktualizacji, dodaj parametry niestandardowe, gdy użytkownicy będą się rejestrować Codzienne aktualizacje. Po realizacji zamiaru aktualizacji odwołaj się do tych parametrów aby dostosować codzienną aktualizację dla danego użytkownika.

Instrukcje dotyczące tej funkcji różnią się w zależności od tego, Dialogflow lub Actions SDK;

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

Gdy użytkownik wywoła Twoją codzienną aktualizację, intencja aktualizacji zawiera teraz: argumenty zawierające wartości podane przez użytkownika podczas rejestracji. Użyj tych aby spersonalizować aktualizację dla każdego użytkownika.

Przetestuj codzienne aktualizacje

Przetestuj codzienne aktualizacje na urządzeniu mobilnym z Asystentem Google za pomocą: na tym samym koncie Google, które posłużyło Ci do utworzenia akcji. Wywoływanie akcji i zasubskrybuj codzienne aktualizacje, a potem sprawdzaj powiadomienia na urządzeniu czas aktualizacji.