Codzienne aktualizacje (Dialogflow)

Użytkownik subskrybujący codzienne aktualizacje akcji na telefonie

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

Przeglądaj w Dialogflow

Kliknij Continue (Dalej), aby zaimportować nasz przykładowy plik danych z codziennymi aktualizacjami w Dialogflow. Następnie postępuj zgodnie z poniższe czynności, aby wdrożyć i przetestować przykład:

  1. Wpisz nazwę agenta i utwórz nowego agenta Dialogflow dla przykładu.
  2. Gdy agent zakończy importowanie, kliknij Przejdź do agenta.
  3. W głównym menu nawigacyjnym kliknij Fulfillment (Realizacja).
  4. Włącz edytor wbudowany, a następnie kliknij Wdróż. Edytor zawiera próbkę w kodzie.
  5. W głównym menu nawigacyjnym kliknij Integrations (Integracje), a następnie kliknij Google (Google). .
  6. W wyświetlonym oknie modalnym włącz Automatyczny podgląd zmian i kliknij Przetestuj aby otworzyć Symulator działań.
  7. W symulatorze wpisz Talk to my test app, aby przetestować próbkę.
Dalej

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:

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
.
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
.
Plik JSON Dialogflow

Pamiętaj, że poniższy kod JSON opisuje odpowiedź webhooka.

{
  "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"
          }
        ]
      }
    }
  }
}
.
Plik JSON z pakietu SDK Actions

Pamiętaj, że poniższy kod JSON opisuje odpowiedź webhooka.

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

Dialogflow Node.js
. 
app.intent('Subscribe to Daily Updates', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'Daily Lowest Temperature',
    frequency: 'DAILY',
  }));
});
index.js
.
Pakiet SDK Actions w Node.js
. 
conv.ask(new RegisterUpdate({
  intent: 'Daily Lowest Temperature',
  frequency: 'DAILY',
}));
index.js
.
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
.
Pakiet SDK Actions w Javie
. 
ResponseBuilder responseBuilder = getResponseBuilder(request);
return responseBuilder.add(new RegisterUpdate()
    .setIntent("Daily Lowest Temperature")
    .setFrequency("DAILY"))
    .build();
UpdatesApp.java
.
Plik 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"
            }
          }
        }
      }
    }
  }
}
.
Plik JSON z pakietu SDK Actions
{
  "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;

Dialogflow

Aby utworzyć intencję, która będzie obsługiwać wynik rejestracji, wykonaj te czynności:

  1. W konsoli Dialogflow: utworzyć nową intencję.
  2. Dodaj zdarzenie actions_intent_REGISTER_UPDATE.
  3. Włącz realizację webhooka dla intencji.
  4. Kliknij Zapisz.
. W ramach realizacji dotyczącej intencji sprawdź registered i odpowiednio dostosuj rozmowę.
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
.
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
.
Plik JSON Dialogflow
. 
{
  "payload": {
    "google": {
      "expectUserResponse": false,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "Ok, I'll start giving you daily updates."
            }
          }
        ]
      }
    }
  }
}
Pakiet SDK Actions

W kodzie realizacji zamówienia dodaj obsługę dla: actions.intent.REGISTER.UPDATE Google Analytics. Sprawdź parametr registered, i odpowiednio ukierunkować rozmowę.

Pakiet SDK Actions w 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
.
Pakiet SDK Actions w Javie
. 
@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
.
Plik JSON z pakietu SDK Actions
{
  "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;

Dialogflow

Zdefiniuj encję Dialogflow do obsługi parametrów niestandardowych na potrzeby aktualizacji, a następnie: przekaż wartość parametru jako argument intencji aktualizacji. Aby skonfigurować spersonalizowane aktualizacje w Dialogflow, wykonaj te czynności:

  1. W konsoli Dialogflow utwórz nową encję.
  2. Dodaj wpisy i synonimy związane z danym parametrem.
  3. Kliknij Save (Zapisz), a potem otwórz intencję aktualizacji.
  4. W sekcji Działania i parametry ustaw actions.intent.CONFIGURE_UPDATES. jako zdarzenie. W tej samej sekcji dodaj parametr o tym samym typie co nowy element.
  5. Otwórz okno „Zaktualizuj rejestrację”. która obsługuje wbudowaną intencję CONFIGURE_UPDATES.
  6. W sekcji Działania i parametry dodaj wymagany parametr i ustaw jego typ na utworzony wcześniej element.
  7. Zaktualizuj kod realizacji intencji rejestracji, aby uwzględnić obiekt arguments z następującą treść:
      .
    • name – nazwa parametru skonfigurowana w Dialogflow.
    • textValue – wartość parametru.

Poniższy kod odczytuje wartość parametru i używa jej w żądaniu aktualizacji:

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',
  }));
});
.
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();
}
.
Plik 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": "{}"
      }
    }
  ]
}
Pakiet SDK Actions

poprosić użytkownika o dodatkowe informacje w ramach realizacji intencji, a następnie przekazać te informacje jako argument dla intencji aktualizacji. Aby skonfigurować spersonalizowane aktualizacje w pakiecie SDK Actions, wykonaj te czynności:

  1. Pytaj użytkownika o informacje, których chcesz używać i personalizacji reklam.
  2. W kodzie realizacji „aktualizacja rejestracji” intencja, która obsługuje CONFIGURE UPDATES dołącz obiekt arguments z następującą treść:
    • name – nazwa argumentu.
    • textValue – informacje od użytkownika do przekazania jako argument.

Ten kod wysyła argument z żądaniem rejestracji aktualizacji:

Pakiet SDK Actions w 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',
    }));
  }
});
.
Pakiet SDK Actions w Javie
. 
@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();
}
.
Plik JSON z pakietu SDK Actions
{
  "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.