Aggiornamenti giornalieri (Dialogflow)

Un utente che si iscrive agli aggiornamenti giornalieri di un'Azione sul proprio telefono

Se l'Azione offre valore agli utenti ogni giorno, offri loro un promemoria per utilizzarla configurando gli aggiornamenti giornalieri. Quando un utente si iscrive agli aggiornamenti giornalieri dell'Azione, riceve una notifica push che può toccare per richiamare uno degli intent dell'Azione.

L'esperienza utente di questi aggiornamenti è la seguente:

  1. L'utente richiama uno degli intent dell'Azione che hai configurato come aggiornamento giornaliero.
  2. L'utente segue la richiesta di iscriversi agli aggiornamenti giornalieri. Questo prompt viene fornito durante una conversazione o sotto forma di chip di suggerimento al termine della conversazione.
  3. L'utente programma un'ora del giorno in cui vuole ricevere il tuo aggiornamento giornaliero, registrandolo con l'Assistente Google.
  4. Ogni giorno all'ora programmata, l'utente riceve una notifica dell'assistente sul proprio dispositivo mobile.
  5. Quando l'utente apre questa notifica, richiama l'intent che hai configurato come aggiornamento giornaliero e interagisce con l'Azione.

Per impostazione predefinita, la richiesta di registrazione all'aggiornamento giornaliero viene visualizzata come chip di suggerimento quando l'utente esce dall'Azione correttamente. Puoi anche aggiungere una richiesta di registrazione durante una conversazione o personalizzare gli aggiornamenti dell'utente.

Casi d'uso

Gli aggiornamenti giornalieri possono essere un utile strumento di coinvolgimento, ma non devono essere incorporati in ogni Azione. Prendi in considerazione questi suggerimenti per decidere se aggiungere iscrizioni di aggiornamento giornaliere a un'azione:

  • Assicurati che gli aggiornamenti giornalieri consentano all'utente di vedere ogni giorno informazioni diverse e utili. Se toccando un aggiornamento giornaliero viene visualizzata la stessa richiesta ogni volta, l'utente probabilmente annullerà l'iscrizione dopo un paio di giorni.
  • Assicurati che la finestra di dialogo abbia senso per l'utente se va direttamente all'intenzione dell'aggiornamento giornaliero. L'utente non partirà necessariamente dall'inizio della conversazione, perciò non dovrebbe aspettarsi molto contesto.
  • Mostra all'utente i vantaggi dell'Azione prima di chiedere di registrarsi per ricevere aggiornamenti giornalieri. L'utente dovrebbe pensare "Voglio questi contenuti ogni giorno" quando gli viene offerta la possibilità di abbonarsi.
  • Non sovraccaricare l'utente con ripetuti suggerimenti di registrazione. Offri un abbonamento di aggiornamento giornaliero subito dopo aver mostrato all'utente a cosa era iscritto ed evita di ripetere l'offerta in altri contesti.
  • Mantieni la conversazione breve dopo l'attivazione dell'intent di aggiornamento. La maggior parte degli aggiornamenti giornalieri dovrebbe consistere in un'unica risposta e poi chiudersi senza richiedere l'input dell'utente.

Configura aggiornamenti giornalieri

Esplora in Dialogflow

Fai clic su Continua per importare il nostro esempio di aggiornamenti giornalieri in Dialogflow. Quindi, segui questi passaggi per eseguire il deployment e testare l'esempio:

  1. Inserisci il nome di un agente e crea un nuovo agente Dialogflow per l'esempio.
  2. Al termine dell'importazione dell'agente, fai clic su Vai all'agente.
  3. Nel menu di navigazione principale, vai ad Fulfillment.
  4. Attiva l'editor incorporato, quindi fai clic su Esegui il deployment. L'editor contiene il codice di esempio.
  5. Nel menu di navigazione principale, vai a Integrazioni, quindi fai clic su Assistente Google.
  6. Nella finestra modale visualizzata, attiva Anteprima automatica delle modifiche e fai clic su Test per aprire il simulatore di azioni.
  7. Nel simulatore, inserisci Talk to my test app per testare il campione.
Continua

Per configurare un intent dell'Azione per gli aggiornamenti giornalieri, segui queste istruzioni:

1. Preparare un intent di aggiornamento

Configura uno degli intent dell'azione come intent di attivazione. Questo intent consente di inviare un aggiornamento giornaliero agli utenti; quando un utente apre la notifica di aggiornamento giornaliera, l'intent si attiva e la conversazione prosegue da lì.

Per definire un intent di attivazione in Dialogflow:

  1. Nella console Dialogflow, fai clic su Integrazioni.
  2. Nella sezione Assistente Google, fai clic su Impostazioni dell'integrazione.
  3. In Rilevamento > Chiamata implicita, fai clic su Aggiungi intent e seleziona l'intent di attivazione, se non è già presente.
  4. Attiva l'opzione Anteprima automatica, se non è già abilitata.
  5. Fai clic su Chiudi.

Nell'SDK Actions, definisci l'intent di aggiornamento come intent di attivazione nel pacchetto Azioni.

2. Attiva aggiornamenti

Per attivare gli aggiornamenti giornalieri per l'intent di attivazione:

  1. Nella console di Actions, vai a Sviluppo > Azioni.
  2. Seleziona l'intento di attivazione. Se l'intent non viene visualizzato nell'elenco, assicurati che sia configurato come intent di attivazione e che l'integrazione con l'assistente di Dialogflow sia impostata in modo da visualizzare l'anteprima automatica delle modifiche.
  3. Scorri verso il basso fino alla sezione Coinvolgimento degli utenti e attiva l'opzione Vuoi offrire aggiornamenti giornalieri agli utenti.
  4. Inserisci un Titolo contenuti.
  5. Fai clic su Salva.

Ora hai configurato l'Azione in modo che offra iscrizioni di aggiornamento giornaliere per un intent. Ora puoi testare gli aggiornamenti giornalieri sul tuo dispositivo mobile.

Personalizza la registrazione all'aggiornamento (facoltativo)

Oltre al chip di suggerimenti e al flusso di registrazione degli aggiornamenti giornalieri gestito dall'assistente, iscrivi gli utenti agli aggiornamenti giornalieri con la tua finestra di dialogo e la tua richiesta di registrazione.

Per un esempio completo di un'azione che gestisce le funzionalità facoltative di aggiornamento giornaliero, consulta gli esempi di coinvolgimento degli utenti di Actions on Google (Node.js e Java).

Per aggiungere alla conversazione una richiesta di registrazione degli aggiornamenti giornalieri personalizzata, segui queste istruzioni:

1. Aggiungi richiesta di registrazione

Aggiungi una finestra di dialogo e un chip di suggerimenti alla conversazione quando vuoi invitare gli utenti a iscriversi agli aggiornamenti giornalieri. Offri queste richieste dopo che l'utente ha interagito con l'intento di aggiornamento, in modo che comprenda i contenuti dei tuoi aggiornamenti giornalieri.

Il codice di esempio seguente richiede a un utente di abbonarsi agli aggiornamenti giornalieri che offrono la temperatura prevista più bassa ogni giorno:

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

Tieni presente che il JSON di seguito descrive una risposta webhook.

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

Tieni presente che il JSON di seguito descrive una risposta webhook.

{
  "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. Gestire la registrazione degli aggiornamenti

Configura un nuovo intent che si attiva quando l'utente segue la richiesta di registrazione. Nel fulfillment per questo nuovo intent, attiva l'intent integrato actions_intent_CONFIGURE_UPDATES con i seguenti parametri:

  • intent: imposta l'intent di aggiornamento che hai configurato.
  • frequency: imposta su "DAILY".

Il seguente codice registra gli aggiornamenti giornalieri per l'intent "Temperatura minima giornaliera":

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

L'assistente prende in carico la tua conversazione e guida l'utente attraverso il resto della configurazione degli aggiornamenti giornalieri. Al completamento della registrazione, l'assistente attiva un intent con un parametro che indica se la registrazione è riuscita o meno.

Le istruzioni per questo passaggio variano a seconda che utilizzi Dialogflow o l'SDK Actions per lo sviluppo.

Dialogflow

Segui questi passaggi per creare un intent che gestisca il risultato della registrazione:

  1. Nella console Dialogflow, crea un nuovo intent.
  2. Aggiungi l'evento actions_intent_REGISTER_UPDATE.
  3. Attiva il fulfillment webhook per l'intent.
  4. Fai clic su Salva.
Nel fulfillment dell'intent, controlla il parametro registered per il risultato e cambia la conversazione di conseguenza.
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
JSON Dialogflow
{
  "payload": {
    "google": {
      "expectUserResponse": false,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "Ok, I'll start giving you daily updates."
            }
          }
        ]
      }
    }
  }
}
SDK Actions

Nel codice di fulfillment, aggiungi la gestione per l'intent integrato actions.intent.REGISTER.UPDATE. Controlla il parametro registered per il risultato e passa la conversazione di conseguenza.

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

Personalizza gli aggiornamenti (facoltativo)

Per personalizzare l'intento di aggiornamento, aggiungi parametri personalizzati quando gli utenti registrano aggiornamenti giornalieri. Quando soddisfi l'intento di aggiornamento, fai riferimento a questi parametri per personalizzare l'aggiornamento giornaliero per l'utente.

Le istruzioni per questa funzionalità variano a seconda che utilizzi Dialogflow o l'SDK Actions per lo sviluppo.

Dialogflow

Definisci un'entità Dialogflow per gestire i parametri personalizzati per l'aggiornamento, poi passa il valore del parametro come argomento per l'intent di aggiornamento. Per configurare aggiornamenti personalizzati in Dialogflow, segui questi passaggi:

  1. Nella console Dialogflow, crea una nuova entità.
  2. Aggiungi alcune voci e sinonimi pertinenti per il tuo parametro.
  3. Fai clic su Salva, quindi apri l'intent di aggiornamento.
  4. Nella sezione Azioni e parametri, imposta actions.intent.CONFIGURE_UPDATES come evento. Nella stessa sezione, aggiungi un parametro dello stesso tipo della nuova entità.
  5. Apri l'intent "aggiorna registrazione" che gestisce l'intent integrato CONFIGURE_UPDATES.
  6. Nella sezione Azioni e parametri, aggiungi un parametro obbligatorio e imposta il tipo sull'entità creata in precedenza.
  7. Aggiorna il codice di fulfillment dell'intent di registrazione in modo da includere un oggetto arguments con i seguenti contenuti:
    • name: il nome del parametro configurato in Dialogflow.
    • textValue: il valore del parametro.

Il codice seguente legge il valore del parametro e lo utilizza nella richiesta di registrazione di aggiornamento:

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

Richiedi all'utente informazioni aggiuntive nel fulfillment dell'intent, poi passale come argomento a sostegno dell'intent di aggiornamento. Per configurare aggiornamenti personalizzati nell'SDK Actions, segui questi passaggi:

  1. Chiedi all'utente le informazioni che vuoi utilizzare per la personalizzazione.
  2. Nel codice di fulfillment per l'intent "update registration" che gestisce CONFIGURE UPDATES, includi un oggetto arguments con i seguenti contenuti:
    • name: il nome dell'argomento.
    • textValue: informazioni dell'utente, da trasmettere come argomento.

Il seguente codice invia un argomento con la richiesta di aggiornamento della registrazione:

SDK Actions 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',
    }));
  }
});
SDK Actions 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();
}
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\":{}}"
}

Quando l'utente richiama l'aggiornamento giornaliero, l'intent di aggiornamento ora include gli argomenti contenenti i valori forniti dall'utente durante la registrazione. Utilizza questi valori per personalizzare l'aggiornamento per ogni utente.

Testa gli aggiornamenti giornalieri

Verifica gli aggiornamenti giornalieri usando un dispositivo mobile con l'Assistente Google utilizzando lo stesso Account Google che hai usato per creare l'Azione. Richiama l'Azione e iscriviti agli aggiornamenti giornalieri, quindi controlla le notifiche del dispositivo intorno all'ora di aggiornamento.