Actualizaciones diarias (Dialogflow)

Un usuario que se suscribe a las actualizaciones diarias de una acción en su teléfono

Si tu Acción proporciona valor a los usuarios todos los días, muéstrales un recordatorio para y usarlo configurando actualizaciones diarias. Cuando un usuario se suscribe a actualizaciones de tu Action, recibirán una notificación push presiona para invocar uno de los intents de la acción.

La experiencia del usuario con estas actualizaciones es la siguiente:

  1. El usuario invoca uno de los intents de la acción que configuraste como una actualización diaria.
  2. El usuario sigue un mensaje para suscribirse a las actualizaciones diarias. Este mensaje es durante la conversación o como un chip de sugerencias cuando esta termina.
  3. El usuario programa una hora del día en la que desea recibir tu registrando la actualización en el Asistente de Google.
  4. Cada día, a la hora programada, el usuario recibe un Asistente notificación en su dispositivo móvil.
  5. Cuando el usuario abre esta notificación, invoca el intent que configurada como una actualización diaria, además de interactuar con tu acción.

De forma predeterminada, el mensaje de registro de actualización diario aparece como un chip de sugerencias Cuando el usuario salga correctamente de tu Acción. También puedes agregar una conversación el mensaje de registro o personalizar las actualizaciones del usuario.

Casos de uso

Las actualizaciones diarias pueden ser una herramienta de participación útil, pero no deberían se incorporan en todas las Acción. Ten en cuenta estas sugerencias cuando decidas si agregar Suscripciones de actualización diarias a una Acción:

  • Asegúrate de que las actualizaciones diarias hagan que el usuario vea contenido diferente y útil información todos los días. Si presionas una actualización diaria aparece el mismo mensaje es probable que el usuario anule la suscripción después de un par de días.
  • Asegúrate de que el diálogo tenga sentido para el usuario si salta directamente a tu el intent de una actualización diaria. El usuario no necesariamente comenzará desde el principio de la conversación, por lo que no se debería esperar que tengan mucho contexto.
  • Muéstrale al usuario el beneficio de tu acción antes de pedirle que se registre. para recibir actualizaciones diarias. El usuario debe pensar: “Quiero que este contenido día" cuando se les da la opción de suscribirse.
  • No abrumes al usuario con sugerencias repetidas para registrarse. Ofrece un Actualizar la suscripción diaria inmediatamente después de mostrarle al usuario lo que se suscribe y evitar repetir la oferta en otros contextos.
  • Procura que la conversación sea breve después de que se active el intent de actualización. Más diaria las actualizaciones deben consistir solo en una única respuesta y, luego, cerrarse sin que requieren la entrada del usuario.

Configurar actualizaciones diarias

Explorar en Dialogflow

Haz clic en Continuar para importar nuestra muestra de actualizaciones diarias en Dialogflow. Luego, sigue la para implementar y probar la muestra:

  1. Ingresa un nombre de agente y crea un agente de Dialogflow nuevo para la muestra.
  2. Después de que el agente termine de importar, haz clic en Ir al agente.
  3. En el menú de navegación principal, ve a Entrega.
  4. Habilita el Editor intercalado y, luego, haz clic en Implementar. El editor contiene la muestra código.
  5. En el menú de navegación principal, ve a Integrations (Integraciones) y, luego, haz clic en Google Asistente
  6. En la ventana modal que aparece, habilita Cambios en la vista previa automática y haz clic en Probar. para abrir el simulador de Actions.
  7. En el simulador, ingresa Talk to my test app para probar la muestra.
Continuar

Si deseas configurar uno de los intents de tu acción para las actualizaciones diarias, sigue estos instrucciones:

1. Cómo preparar un intent de actualización

Configura uno de los intents de la acción como intent de activación. Este intent Permite que se envíe una actualización diaria a los usuarios. Cuando un usuario abre su actualización diaria la notificación, los activadores del intent y la conversación continúa desde allí.

Para definir un intent de activación en Dialogflow, haz lo siguiente:

  1. En la consola de Dialogflow, haz clic en Integraciones.
  2. En la sección Asistente de Google, haz clic en Configuración de integración.
  3. En Descubrimiento > Invocación implícita, haz clic en Agregar intent y selecciona el intent activador si aún no está ahí.
  4. Activa la Vista previa automática de los cambios si aún no está habilitada.
  5. Haz clic en Cerrar.

En el SDK de Actions, define tu intent de actualización como un intent activador en el Paquete de acción.

2. Habilitar actualizaciones

A fin de activar las actualizaciones diarias para el intent que se activa, haz lo siguiente:

  1. En la Consola de Actions, navega a Desarrollo > Actions (Acciones).
  2. Selecciona el intent activador. Si tu intent no aparece en la lista, asegúrate de que esté configurado como un intent de activación y el Asistente de Dialogflow está configurada para obtener una vista previa automática de los cambios.
  3. Desplázate hacia abajo hasta la sección Participación del usuario y activa la opción. ¿Te gustaría ofrecer actualizaciones diarias a los usuarios?
  4. Ingresa un Título del contenido.
  5. Haz clic en Guardar.

Configuraste tu acción para que ofrezca suscripciones de actualización diarias durante un . Ahora puedes probar las actualizaciones diarias en tu propio dispositivo móvil.

Personaliza el registro de actualizaciones (opcional)

Además del chip de sugerencias y la actualización diaria manejada por el Asistente del flujo de registro, suscríbete a los usuarios a actualizaciones diarias con tus un diálogo propio y un mensaje de registro.

Para ver un ejemplo completo de una Acción que controla las funciones opcionales de actualización diaria, consulta los ejemplos de participación de los usuarios de Actions on Google (Node.js) y Java).

Para agregar a tu conversación un mensaje personalizado de registro de actualización diario, sigue estas instrucciones:

1. Agregar mensaje de registro

Agrega un diálogo y un chip de sugerencias a la conversación cuando quieras preguntar que los usuarios se suscriban a actualizaciones diarias. Ofrece estas indicaciones después de que el usuario interactúe. con tu intent de actualización, de modo que comprendan el contenido de tus actualizaciones.

El siguiente código de ejemplo le solicita al usuario que se suscriba a las actualizaciones diarias que ofrecer la temperatura esperada más baja cada día:

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

Ten en cuenta que el siguiente JSON describe una respuesta de 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 del SDK de Actions

Ten en cuenta que el siguiente JSON describe una respuesta de 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. Cómo controlar el registro de actualizaciones

Configura un intent nuevo que se active cuando el usuario siga tu registro. mensaje. En la entrega de este nuevo intent, activa el actions_intent_CONFIGURE_UPDATES. intent integrado con el los siguientes parámetros:

  • intent: Establece el intent de actualización que configuraste.
  • frequency: Configurado como "DAILY".

El siguiente código registra las actualizaciones diarias de la "Temperatura diaria más baja" intent:

Dialogflow para Node.js
app.intent('Subscribe to Daily Updates', (conv) => {
  conv.ask(new RegisterUpdate({
    intent: 'Daily Lowest Temperature',
    frequency: 'DAILY',
  }));
});
index.js
.
.
SDK de Actions para 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 de Actions para Java
ResponseBuilder responseBuilder = getResponseBuilder(request);
return responseBuilder.add(new RegisterUpdate()
    .setIntent("Daily Lowest Temperature")
    .setFrequency("DAILY"))
    .build();
UpdatesApp.java
.
.
JSON de 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 del SDK de 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. Cómo controlar el resultado

El Asistente se hará cargo de la conversación y guiará al usuario por el el resto de su configuración de actualizaciones diarias. Cuando se complete el registro, Asistente activa un intent con un parámetro que indica si el si el registro fue exitoso o no.

Las instrucciones para este paso varían en función de si usas Dialogflow o el SDK de Actions para desarrollo.

Dialogflow

Sigue estos pasos para crear un intent que controle el resultado del registro:

  1. En la consola de Dialogflow, crear un intent nuevo.
  2. Agrega el evento actions_intent_REGISTER_UPDATE.
  3. Activar la entrega de webhook para el intent
  4. Haz clic en Guardar.
En tu entrega del intent, verifica el registered. para el resultado y reorientar la conversación según corresponda.
Dialogflow para 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 de Dialogflow
{
  "payload": {
    "google": {
      "expectUserResponse": false,
      "richResponse": {
        "items": [
          {
            "simpleResponse": {
              "textToSpeech": "Ok, I'll start giving you daily updates."
            }
          }
        ]
      }
    }
  }
}
.
.
SDK de Actions

En tu código de entrega, agrega el control de actions.intent.REGISTER.UPDATE. un intent integrado. Verifica el parámetro registered para ver el resultado. y orientar la conversación en consecuencia.

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

Cómo personalizar las actualizaciones (opcional)

Para personalizar tu intent de actualización, agrega parámetros personalizados cuando los usuarios se registren actualizaciones diarias. Cuando completes el intent de actualización, haz referencia a estos parámetros. para personalizar la actualización diaria para ese usuario.

Las instrucciones para esta función varían en función de si usas o no Dialogflow o el SDK de Actions para desarrollo.

Dialogflow

Definir una entidad de Dialogflow para manejar los parámetros personalizados para la actualización y, luego, entregar el valor del parámetro como argumento para tu intent de actualización. Para configurar actualizaciones personalizadas en Dialogflow, sigue estos pasos:

  1. En la consola de Dialogflow, crea una entidad nueva.
  2. Agrega algunas entradas y sinónimos que sean relevantes para tu parámetro.
  3. Haz clic en Save y, luego, abre tu intent de actualización.
  4. En la sección Actions and parameters, configura actions.intent.CONFIGURE_UPDATES. como el evento. En la misma sección, agrega un parámetro con el mismo tipo que la entidad nueva.
  5. Abre la opción "Actualizar registro". que controla el intent integrado CONFIGURE_UPDATES.
  6. En la sección Acciones y parámetros (Actions and parameters), agrega un parámetro obligatorio y establece su tipo en la entidad creada anteriormente.
  7. Actualiza el código de entrega de tu intent de registro para incluir un objeto arguments con el siguiente contenido:
    • name: Es el nombre de tu parámetro como se configuró en Dialogflow.
    • textValue: Es el valor de tu parámetro.

El siguiente código lee el valor del parámetro y lo usa en la solicitud de registro de actualización:

Dialogflow para 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 de 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 de Actions

Solicitar información adicional al usuario en la entrega de intents Luego, entrega la información como argumento para tu intent de actualización. Para configurar actualizaciones personalizadas en el SDK de Actions, sigue estos pasos:

  1. Solicita al usuario la información que deseas usar para personalización.
  2. En el código de entrega de tu "registro de actualización" que controla el CONFIGURE UPDATES, incluye un objeto arguments con el siguiente contenido:
      .
    • name: Es un nombre para tu argumento.
    • textValue: Es la información del usuario que se pasará como argumento.

El siguiente código envía un argumento con la solicitud de registro de actualización:

SDK de Actions para 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 de Actions para 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 del SDK de 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\":{}}"
}

Cuando el usuario invoca la actualización diaria, el intent de actualización ahora incluye Argumentos que contienen los valores que proporcionó el usuario durante el registro. Usar estas opciones de salida para personalizar la actualización de cada usuario.

Cómo probar actualizaciones diarias

Prueba tus actualizaciones diarias en un dispositivo móvil con el Asistente de Google mediante la misma Cuenta de Google que usaste para crear tu Acción. Invoca tu acción y suscríbete a las actualizaciones diarias, y revisa las notificaciones de tu dispositivo la hora de actualización.