Aggiornamenti giornalieri (Dialogflow)

Se l'Azione apporta valore agli utenti ogni giorno, ricorda loro di per usarlo configurando aggiornamenti giornalieri. Quando un utente si abbona ogni giorno aggiornamenti per l'Azione, riceveranno una notifica push possibile tocca per richiamare uno degli intenti dell'azione.

L'esperienza di un utente con questi aggiornamenti è la seguente:

1. L'utente richiama uno degli intent dell'Azione che hai configurato come aggiornamento giornaliero.
2. L'utente segue una richiesta di iscrizione agli aggiornamenti giornalieri. Questo prompt è vengono forniti durante una conversazione o come chip di suggerimento al termine della conversazione.
3. L'utente pianifica un'ora del giorno in cui desidera ricevere la tua aggiornamento, registrando l'aggiornamento con l'Assistente Google.
4. L'utente riceve un assistente all'orario programmato di ogni giorno notifica sul dispositivo mobile.
5. Quando l'utente apre questa notifica, richiama l'intent che configurato come aggiornamento giornaliero e interagire con l'Azione.

Per impostazione predefinita, la richiesta di aggiornamento giornaliero della registrazione viene visualizzata come chip di suggerimento quando l'utente chiude l'azione correttamente. Puoi anche aggiungere una conversazione a metà conversazione richiesta di registrazione o personalizzare gli aggiornamenti dell'utente.

Casi d'uso

Gli aggiornamenti giornalieri possono essere uno strumento di coinvolgimento utile ma non dovrebbero esserlo incorporato in ogni Azione. Considera questi suggerimenti per decidere se aggiungere aggiornano quotidianamente le iscrizioni a un'azione:

• Assicurati che gli aggiornamenti giornalieri facciano sì che l'utente veda informazioni diverse e utili informazioni ogni giorno. Se tocchi un aggiornamento giornaliero, viene visualizzato lo stesso messaggio è probabile che l'utente annulli l'iscrizione dopo un paio di giorni.
• Assicurati che la finestra di dialogo sia sensata per l'utente se passa direttamente al tuo l'intento di un aggiornamento quotidiano. L'utente non partirà necessariamente dall'inizio della conversazione, quindi non ci si aspetta che abbiano molto contesto.
• Mostra all'utente il vantaggio dell'azione prima di invitarlo a registrarsi per ricevere aggiornamenti giornalieri. L'utente dovrebbe pensare: "Voglio questi contenuti ogni giorno" quando viene offerta la possibilità di abbonarsi.
• Non sovraccaricare l'utente con suggerimenti ripetuti per la registrazione. Offri un aggiornamento giornaliero dell'abbonamento subito dopo aver mostrato all'utente i contenuti che vorrebbe sottoscrivere ed evitare di ripetere l'offerta in altri contesti.
• Mantieni la conversazione breve dopo l'attivazione dell'intento di aggiornamento. Più giornaliera gli aggiornamenti devono essere costituiti da una sola risposta e poi devono essere chiusi senza richiedono l'input dell'utente.

Imposta aggiornamenti giornalieri

Per configurare uno degli intent dell'Azione per gli aggiornamenti giornalieri, segui questi istruzioni:

1. Prepara 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 l'aggiornamento giornaliero. notifica, l'intento si attiva e la conversazione continua 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 di integrazione.
3. In Rilevamento > Chiamata implicita, fai clic su Aggiungi intent. e seleziona l'intento di attivazione, se non è già presente.
4. Attiva l'opzione Anteprima automatica delle modifiche, se non è già abilitata.
5. Fai clic su Chiudi.

Nell'SDK Actions, definisci l'intent di aggiornamento come intento di attivazione nel Pacchetto di azioni.

2. Abilita gli aggiornamenti

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

1. Nella console Actions, vai a Sviluppo > Azioni.
2. Seleziona l'intento di attivazione. Se il tuo intent non compare nell'elenco, assicurati che sia configurato come intent di attivazione e come assistente di Dialogflow e l'integrazione è impostata per 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.

Hai configurato l'Azione in modo da offrire iscrizioni giornaliere ad aggiornamenti per un l'intento. Ora puoi testare gli aggiornamenti giornalieri sul tuo dispositivo mobile.

Personalizza la registrazione dell'aggiornamento (facoltativo)

Oltre al chip di suggerimento e all'aggiornamento giornaliero gestito dall'assistente flusso di registrazione, iscrivi gli utenti agli aggiornamenti giornalieri con una finestra di dialogo e una richiesta di registrazione.

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

Per aggiungere una richiesta di registrazione di aggiornamento giornaliero personalizzata alla conversazione, segui queste istruzioni:

1. Aggiungi richiesta di registrazione

Aggiungi una finestra di dialogo e un chip di suggerimento alla conversazione quando vuoi inviare un prompt agli utenti di abbonarsi ad aggiornamenti giornalieri. Offri queste richieste dopo l'interazione dell'utente con il tuo intento di aggiornamento, in modo che comprendano i contenuti aggiornamenti.

Il codice di esempio riportato di seguito richiede all'utente di abbonarsi ad aggiornamenti giornalieri che offrire la temperatura prevista più bassa ogni giorno:

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

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

• intent: impostato sull'intent di aggiornamento che hai configurato.
• frequency - Imposta su "DAILY".

Il seguente codice registra aggiornamenti giornalieri per la "Temperatura minima giornaliera" intent:

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. Gestire il risultato

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

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

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

(Facoltativo) Personalizza gli aggiornamenti

Per personalizzare l'intenzione di aggiornamento, aggiungi parametri personalizzati quando gli utenti si registrano aggiornamenti quotidiani. Quando completi l'intent di aggiornamento, fai riferimento a questi parametri per personalizzare l'aggiornamento giornaliero per l'utente in questione.

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

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

Ora, quando l'utente richiama il tuo aggiornamento giornaliero, il tuo intento di aggiornamento include argomenti contenenti i valori forniti dall'utente durante la registrazione. Utilizza questi i valori per personalizzare l'aggiornamento per ciascun utente.

Testa gli aggiornamenti giornalieri

Verifica gli aggiornamenti giornalieri usando un dispositivo mobile con l'Assistente Google usando 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 l'ora dell'aggiornamento.