Codzienne aktualizacje (Dialogflow)

Użytkownik subskrybujący codzienne aktualizacje akcji na telefonie

Jeśli akcja przynosi użytkownikom codziennie wartość, ustaw codzienne aktualizacje, aby przypominać im o jej użyciu. Gdy użytkownik zasubskrybuje codzienne aktualizacje akcji, otrzyma powiadomienie push, które będzie mógł kliknąć, aby wywołać jeden z intencji akcji.

Użytkownik odczuwa te zmiany w następujący sposób:

  1. Użytkownik wywołuje jedną z intencji akcji, które zostały skonfigurowane jako codzienna aktualizacja.
  2. Użytkownik przechodzi do prośby o subskrypcję codziennych aktualizacji. Jest on podawany w trakcie rozmowy lub jako element sugestii po jej zakończeniu.
  3. Użytkownik ustawił godzinę, o której chce otrzymywać codzienne aktualności, rejestrując Twoją aktualizację w Asystencie Google.
  4. Każdego dnia o zaplanowanej godzinie użytkownik otrzymuje powiadomienie Asystenta na urządzeniu mobilnym.
  5. Gdy użytkownik otwiera to powiadomienie, wywołuje intencję skonfigurowaną jako codzienną aktualizację i wchodzi w interakcję z akcją.

Domyślnie komunikat o rejestracji codziennych aktualizacji pojawia się jako element sugestii, gdy użytkownik zamknie akcję. Możesz też dodać prośbę o rejestrację w trakcie rozmowy lub spersonalizować powiadomienia użytkownika.

Przypadki użycia

Codzienne aktualizacje mogą być przydatnym narzędziem do zwiększania zaangażowania, ale nie należy ich dodawać do każdej akcji. Decydując, czy dodać do akcji subskrypcje codziennych aktualizacji, weź pod uwagę te wskazówki:

  • Zadbaj o to, aby codzienne aktualizacje zawierały inne, przydatne informacje każdego dnia. Jeśli kliknięcie codziennej aktualizacji za każdym razem spowoduje wyświetlenie tego samego komunikatu, użytkownik prawdopodobnie zrezygnuje z subskrypcji po kilku dniach.
  • Zadbaj o to, aby okno było zrozumiałe dla użytkownika, jeśli nawiązuje bezpośrednio do intencji Twojej codziennej aktualizacji. Niekoniecznie zacznie on od początku, więc nie należy oczekiwać szczegółowego kontekstu.
  • Pokaż użytkownikowi korzyści płynące z działania, zanim poprosisz go o zarejestrowanie się w codziennych aktualizacjach. Kiedy użytkownik ma możliwość subskrypcji, powinien pomyśleć „Chcę dostawać takie treści codziennie”.
  • Nie przytłaczaj użytkowników kolejnymi sugestiami dotyczącymi rejestracji. Zaoferuj użytkownikowi codzienną subskrypcję aktualizacji zaraz po tym, gdy pokażesz mu, co chce zasubskrybować. Unikaj powtarzania oferty w innych kontekstach.
  • Po wywołaniu intencji aktualizacji rozmowa powinna być krótka. Większość dziennych aktualizacji powinna składać się z 1 odpowiedzi i zamykać ją bez konieczności wprowadzania danych wejściowych użytkownika.

Ustaw codzienne aktualizacje

Przeglądaj w Dialogflow

Kliknij Dalej, aby zaimportować próbkę codziennych aktualizacji w Dialogflow. Następnie wykonaj poniższe czynności, aby wdrożyć i przetestować przykład:

  1. Wpisz nazwę agenta i utwórz nowego agenta Dialogflow na potrzeby przykładu.
  2. Po zakończeniu importowania agenta kliknij Otwórz agenta.
  3. W głównym menu nawigacyjnym kliknij Fulfillment (Realizacja).
  4. Włącz Edytor wbudowany, a potem kliknij Wdróż. Edytor zawiera przykładowy kod.
  5. W głównym menu nawigacyjnym kliknij Integracje, a następnie Asystent Google.
  6. W wyświetlonym oknie modalnym włącz Automatyczny podgląd zmian i kliknij Przetestuj, aby otworzyć symulator Actions.
  7. W symulatorze wpisz Talk to my test app, aby przetestować próbkę.
Dalej

Aby skonfigurować jedną z intencji codziennej aktualizacji w akcji, wykonaj te czynności:

1. Przygotowywanie intencji aktualizacji

Skonfiguruj jedną z intencji akcji jako intencję aktywującą. Dzięki temu użytkownicy mogą otrzymywać codzienną aktualizację. Gdy użytkownik otworzy codzienne powiadomienie o aktualizacji, intencja zostanie aktywowana i kontynuacja będzie kontynuowana.

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

  1. W konsoli Dialogflow kliknij Integrations (Integracje).
  2. W sekcji Asystent Google kliknij Ustawienia integracji.
  3. W sekcji Odkrywanie > Wywołanie niejawne kliknij Dodaj intencję i wybierz intencję aktywującą, jeśli jeszcze jej nie ma.
  4. Włącz funkcję Auto-podgląd, jeśli nie jest jeszcze włączona.
  5. Kliknij Zamknij.

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

2. Włącz aktualizacje

Aby włączyć codzienne aktualizacje intencji aktywującej:

  1. W konsoli Actions wybierz Programowanie > Działania.
  2. Wybierz intencję aktywującą. Jeśli intencji nie ma na liście, sprawdź, czy jest ona skonfigurowana jako intencja wyzwalająca, a integracja Asystenta Dialogflow jest ustawiona na automatyczny podgląd zmian.
  3. Przewiń w dół do sekcji Zaangażowanie użytkowników i włącz opcję Czy chcesz oferować użytkownikom codzienne aktualizacje.
  4. Wpisz tytuł treści.
  5. Kliknij Zapisz.

Akcja jest teraz skonfigurowana tak, aby oferować codzienne aktualizacje w ramach określonego zamiaru. Teraz możesz testować codzienne aktualizacje na swoim urządzeniu mobilnym.

Dostosuj rejestrację aktualizacji (opcjonalnie)

Oprócz elementu z sugestią i procedury codziennej rejestracji przeprowadzanej przez Asystenta możesz subskrybować codzienne aktualizacje za pomocą własnego okna i prośby o rejestrację.

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

Aby dodać do rozmowy własną prośbę o rejestrację codzienną, wykonaj te czynności:

1. Dodaj prośbę o rejestrację

Jeśli chcesz zachęcić użytkowników do subskrybowania codziennych aktualności, dodaj do rozmowy okno i element z sugestią. Wyświetlaj te komunikaty, gdy użytkownik wejdzie w interakcję z intencją aktualizacji, aby mógł zrozumieć treść codziennych aktualizacji.

Ten przykładowy kod zachęca użytkownika do zasubskrybowania codziennych aktualności, w których każdego dnia jest niższa oczekiwana temperatura:

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 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 się uruchamiać, gdy użytkownik postąpi zgodnie z Twoim promptem o rejestracji. W realizacji nowej intencji aktywuj intencję wbudowaną actions_intent_CONFIGURE_UPDATES z tymi parametrami:

  • intent – ustawiona zgodnie ze skonfigurowaną intencją aktualizacji.
  • frequency – ustaw na „DAILY”.

Ten kod rejestruje codzienne aktualizacje dla intencji „Dzienna najniższa temperatura”:

Dialogflow Node.js
app.intent('Subscribe to Daily Updates', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'Daily Lowest Temperature',
    frequency: 'DAILY',
  }));
});
index.js
Actions SDK 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
Actions SDK Java
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 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 wyniku

Asystent przejmie rozmowę i podaje użytkownikowi konfigurację wszystkich codziennych aktualizacji. Po zakończeniu rejestracji Asystent aktywuje intencję z parametrem wskazującym, czy rejestracja zakończyła się powodzeniem.

Instrukcje dla tego kroku różnią się w zależności od tego, czy do programowania używasz Dialogflow czy Actions SDK.

Dialogflow

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

  1. W konsoli Dialogflow utwórz nową intencję.
  2. Dodaj zdarzenie actions_intent_REGISTER_UPDATE.
  3. Włącz realizację webhooka dla intencji.
  4. Kliknij Zapisz.
W ramach realizacji intencji sprawdź parametr registered wyniku 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."
            }
          }
        ]
      }
    }
  }
}
Actions SDK

W kodzie realizacji dodaj obsługę intencji wbudowanej actions.intent.REGISTER.UPDATE. Sprawdź parametr registered związany z wynikiem i odpowiednio pokieruj wątek.

Pakiet Actions SDK 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
Actions SDK 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
Plik JSON SDK Actions
{
  "expectUserResponse": false,
  "finalResponse": {
    "richResponse": {
      "items": [
        {
          "simpleResponse": {
            "textToSpeech": "Ok, I'll start giving you daily updates."
          }
        }
      ]
    }
  }
}

Personalizuj aktualizacje (opcjonalnie)

Aby spersonalizować intencję aktualizacji, dodaj parametry niestandardowe, gdy użytkownicy rejestrują codzienne aktualizacje. Gdy realizujesz intencję aktualizacji, odwoływanie się do tych parametrów, aby dostosowywać codzienną aktualizację dla danego użytkownika.

Instrukcje dotyczące tej funkcji różnią się w zależności od tego, czy do programowania korzystasz z Dialogflow czy z pakietu SDK Actions.

Dialogflow

Zdefiniuj encję Dialogflow, która będzie obsługiwać parametry niestandardowe na potrzeby aktualizacji, a następnie przekaż wartość parametru jako argument dla intencji aktualizacji. Aby skonfigurować spersonalizowane aktualizacje w Dialogflow, wykonaj te czynności:

  1. W konsoli Dialogflow utwórz nową encję.
  2. Dodaj kilka wpisów i synonimów związanych z parametrem.
  3. Kliknij 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 tego samego typu co nowy element.
  5. Otwórz intencję „Aktualizuj rejestrację”, która obsługuje intencję wbudowaną CONFIGURE_UPDATES.
  6. W sekcji Działania i parametry dodaj wymagany parametr i ustaw jego typ na wcześniej utworzony element.
  7. Zaktualizuj kod realizacji intencji rejestracji, aby zawierał obiekt arguments z tą zawartością:
    • name – nazwa parametru skonfigurowana w Dialogflow.
    • textValue – wartość parametru.

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

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": "{}"
      }
    }
  ]
}
Actions SDK

Poproś użytkownika o dodatkowe informacje w realizacji intencji, a następnie przekaż te informacje jako argument dla intencji aktualizacji. Aby skonfigurować spersonalizowane aktualizacje w pakiecie SDK Actions:

  1. Pytaj użytkownika o informacje, których chcesz użyć do personalizacji.
  2. W kodzie realizacji intencji „update registration” (aktualizacja rejestracji), która obsługuje CONFIGURE UPDATES, umieść obiekt arguments z tą zawartością:
    • name – nazwa argumentu.
    • textValue – informacje od użytkownika do przekazania jako argument.

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

Pakiet Actions SDK 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',
    }));
  }
});
Actions SDK 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();
}
Plik JSON 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ą dzienną aktualizację, intencja aktualizacji będzie teraz zawierać argumenty zawierające wartości podane przez użytkownika podczas rejestracji. Wykorzystaj te wartości, aby spersonalizować aktualizację dla każdego użytkownika.

Testowanie codziennych aktualizacji

Testuj codzienne aktualizacje za pomocą urządzenia mobilnego z Asystentem Google, korzystając z konta Google użytego do utworzenia akcji. Wywołaj akcję i zasubskrybuj codzienne aktualności, a następnie sprawdź powiadomienia na urządzeniu w czasie, gdy aktualizacja nastąpi po aktualizacji.