Actualizaciones diarias (Dialogflow)

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

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:

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. 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:

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. 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.

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

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.

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

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.