Soporte para notificaciones push

Realiza el seguimiento de las interacciones del usuario con las notificaciones push para medir campañas de re-engagement y atribuir conversiones con precisión integrando Firebase Cloud Messaging (FCM) con el SDK de Singular.

Sigue las directrices de implementación a continuación para asegurar que los datos de las notificaciones se pasen correctamente al SDK de Singular para una atribución adecuada.

Guía de implementación

Manejar notificaciones de FCM

Sobrescribe el método onMessageReceived() en tu FirebaseMessagingService para capturar los datos de la notificación cuando lleguen los mensajes push.

override fun onMessageReceived(message: RemoteMessage) {
    super.onMessageReceived(message)
    var title = ""
    var body = ""

    message.notification?.let {
        Log.d("singular-app", it.toString())
        title = it.title ?: ""
        body = it.body ?: ""
    }

    val data: Map<String, String> = message.data
    if (data.isNotEmpty()) {
        Log.d("singular-app", data.toString())
    }

    // Forward payload data to intent
    processNotification(title, body, data)
}

@Override
public void onMessageReceived(@NonNull RemoteMessage message) {
    super.onMessageReceived(message);
    String title = "";
    String body = "";

    if (message.getNotification() != null) {
        Log.d("singular-app", message.getNotification().toString());
        title = message.getNotification().getTitle();
        body = message.getNotification().getBody();
    }

    Map<String, String> data = message.getData();
    if (!data.isEmpty()) {
        Log.d("singular-app", data.toString());
    }

    // Forward payload data to intent
    processNotification(title, body, data);
}

Procesar y reenviar los datos de la notificación

Crea un intent que inicie tu MainActivity con el payload de la notificación adjunto, garantizando que Singular reciba los datos de seguimiento.

private fun processNotification(title: String, body: String, data: Map<String, String>) {
    val intent = Intent(this, MainActivity::class.java).apply {
        flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK

        // Attach notification data to the intent
        data.forEach { (key, value) ->
            putExtra(key, value)
        }
    }

    val pendingIntent = PendingIntent.getActivity(
        this,
        0,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
    )

    val notificationBuilder = NotificationCompat.Builder(this, "your_channel_id")
        .setSmallIcon(R.drawable.ic_notification)
        .setContentTitle(title)
        .setContentText(body)
        .setPriority(NotificationCompat.PRIORITY_HIGH)
        .setAutoCancel(true)
        .setContentIntent(pendingIntent)

    val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
    notificationManager?.notify(0, notificationBuilder.build())
}

private void processNotification(String title, String body, Map<String, String> data) {
    Intent intent = new Intent(this, MainActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);

    // Attach notification data to the intent
    for (Map.Entry<String, String> entry : data.entrySet()) {
        intent.putExtra(entry.getKey(), entry.getValue());
    }

    PendingIntent pendingIntent = PendingIntent.getActivity(
            this,
            0,
            intent,
            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
    );

    NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, "your_channel_id")
            .setSmallIcon(R.drawable.ic_notification)
            .setContentTitle(title)
            .setContentText(body)
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setAutoCancel(true)
            .setContentIntent(pendingIntent);

    NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    if (notificationManager != null) {
        notificationManager.notify(0, notificationBuilder.build());
    }
}

Configurar el SDK para los payloads de push

Agrega selectores de payload de notificaciones push a tu configuración del SDK para especificar dónde se encuentran los enlaces de Singular dentro de la estructura de datos de la notificación.

val pushSelectors = arrayOf(
    arrayOf("sng_link"),
    arrayOf("rootObj", "nestedObj", "anotherNested", "singularLink")
)

val config = SingularConfig("SDK_KEY", "SDK_SECRET")
    .withPushNotificationPayload(intent, pushSelectors)

Singular.init(applicationContext, config)

String[][] pushSelectors = {
    {"sng_link"},
    {"rootObj", "nestedObj", "anotherNested", "singularLink"}
};

SingularConfig config = new SingularConfig("SDK_KEY", "SDK_SECRET")
    .withPushNotificationPayload(getIntent(), pushSelectors);

Singular.init(getApplicationContext(), config);

Configuración de selectores:

• Claves simples: Usa arrayOf("sng_link") para claves de nivel superior en el payload.
• Claves anidadas: Usa arrayOf("rootObj", "nestedObj", "key") para recorrer estructuras JSON anidadas.
• Múltiples rutas: Define múltiples arreglos de selectores para verificar diferentes ubicaciones posibles de los enlaces de Singular.

Guía de validación

Verificar el payload en Start Session

Confirma que los enlaces de notificaciones push se pasen correctamente a Singular inspeccionando la llamada al API de Start Session.

El SDK de Singular incluye el payload de la notificación push bajo el parámetro singular_link en la solicitud de Start Session cuando los usuarios tocan las notificaciones.

Ejemplo de uso de solicitud de Start Session:

https://sdk-api-v1.singular.net/api/v1/start?
a=<SDK-Key>
&singular_link=https://singularassist2.sng.link/C4nw9/r1m0?_dl=singular://test&_smtype=3
&i=net.singular.singularsampleapp
&s=1740905574084
&sdk=Singular/v12.6.2

Configuración avanzada

Configuración de dominios ESP

Configura dominios externos si envuelves los enlaces de Singular dentro de dominios de proveedores de servicios de correo electrónico (ESP) u otros dominios de terceros.

val config = SingularConfig("SDK_KEY", "SDK_SECRET")
    .withESPDomains(listOf("sl.esp.link", "custom.domain.com"))

SingularConfig config = new SingularConfig("SDK_KEY", "SDK_SECRET")
    .withESPDomains(Arrays.asList("sl.esp.link", "custom.domain.com"));

Enrutamiento dinámico de deep links

Implementa múltiples destinos de deep link desde una única notificación configurando un enlace de seguimiento de Singular con overrides dinámicos de redirección.

Ejemplo de uso: Una notificación de noticias de última hora con múltiples opciones de acción

• Leer las últimas noticias: newsapp://article?id=12345
• Temas en tendencia: newsapp://trending
• Deportes: newsapp://sports

En lugar de crear múltiples enlaces de seguimiento, usa un único enlace de Singular y sobrescribe las redirecciones dinámicamente según la selección del usuario. Consulta Sobrescribir redirecciones en enlaces de seguimiento de Singular para detalles de implementación.

Consideraciones importantes

Notas de implementación

• Sin manejador de callback: A diferencia de withSingularLink , la funcionalidad de notificaciones push no proporciona callbacks de payload. Implementa tu propia lógica de deep linking para enrutar a los usuarios a contenido específico dentro de tu app.
• Flujo de atribución: Cuando los usuarios tocan notificaciones, Singular recupera el payload y lo incluye en el evento de Start Session disparado por Singular.init() . El backend procesa estos datos para atribuir el touchpoint de la notificación push y registrar el seguimiento de re-engagement.
• Restricciones de dominio: Solo los dominios de enlaces de Singular ( sng.link ) de la página Manage Links están permitidos de forma predeterminada. Configura los dominios ESP explícitamente para enlaces envueltos usando withESPDomains()