Suporte a notificações push

Acompanhe as interações dos usuários com notificações push para medir campanhas de re-engajamento e atribuir conversões com precisão, integrando o Firebase Cloud Messaging (FCM) ao SDK do Singular.

Siga as diretrizes de implementação abaixo para garantir que os dados das notificações sejam corretamente passados ao SDK do Singular para a atribuição adequada.

Guia de implementação

Tratar notificações do FCM

Sobrescreva o método onMessageReceived() no seu FirebaseMessagingService para capturar os dados da notificação quando as mensagens push chegarem.

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);
}

Processar e encaminhar os dados da notificação

Crie um intent que inicie sua MainActivity com o payload da notificação anexado, garantindo que o Singular receba os dados de rastreamento.

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 o SDK para payloads de push

Adicione seletores de payload de notificação push à sua configuração do SDK para especificar onde os links do Singular estão localizados na estrutura de dados da notificação.

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);

Configuração de seletores:

• Chaves simples: Use arrayOf("sng_link") para chaves de nível superior no payload.
• Chaves aninhadas: Use arrayOf("rootObj", "nestedObj", "key") para percorrer estruturas JSON aninhadas.
• Vários caminhos: Defina múltiplos arrays de seletores para verificar diferentes locais possíveis onde os links do Singular podem estar.

Guia de validação

Verificar o payload no Start Session

Confirme se os links de notificações push estão sendo passados corretamente ao Singular inspecionando a chamada da API de Start Session.

O SDK do Singular inclui o payload da notificação push no parâmetro singular_link na solicitação de Start Session quando os usuários tocam em notificações.

Exemplo de uso de solicitação 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

Configuração avançada

Configuração de domínios ESP

Configure domínios externos se você encapsular links do Singular dentro de domínios de provedores de serviços de email (ESP) ou outros domínios de terceiros.

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"));

Roteamento dinâmico de deep links

Implemente vários destinos de deep link a partir de uma única notificação configurando um link de rastreamento do Singular com overrides dinâmicos de redirecionamento.

Exemplo de uso: Uma notificação de notícia urgente com várias opções de ação

• Ler as últimas notícias: newsapp://article?id=12345
• Tópicos em alta: newsapp://trending
• Esportes: newsapp://sports

Em vez de criar vários links de rastreamento, use um único link do Singular e sobrescreva os redirecionamentos dinamicamente com base na escolha do usuário. Consulte Sobrescrever redirecionamentos em links de rastreamento do Singular para detalhes de implementação.

Considerações importantes

Notas de implementação

• Sem manipulador de callback: Ao contrário de withSingularLink , o recurso de notificações push não fornece callbacks de payload. Implemente sua própria lógica de deep linking para encaminhar os usuários para conteúdo específico dentro do seu app.
• Fluxo de atribuição: Quando os usuários tocam nas notificações, o Singular recupera o payload e o inclui no evento de Start Session disparado por Singular.init() . O backend processa esses dados para atribuir o touchpoint da notificação push e registrar o rastreamento de re-engajamento.
• Restrições de domínio: Apenas os domínios de links do Singular ( sng.link ) da página Manage Links são permitidos por padrão. Configure os domínios ESP explicitamente para links encapsulados usando withESPDomains()