Añadir soporte para enlaces profundos

Los enlaces profundosdirigen a los usuarios a contenidos específicos dentro de su aplicación. Cuando los usuarios tocan un enlace profundo en un dispositivo con su aplicación instalada, la aplicación se abre directamente al contenido deseado, como una página de producto o una experiencia específica.

Los enlaces de seguimiento singulares admiten tanto enlaces profundos estándar (para aplicaciones instaladas) como enlaces profundos diferidos (para nuevas instalaciones). Para más información, consulte las preguntas frecuentes sobre deep linkingy las preguntas frecuentes sobre Singular Links.

Requisitos

Requisitos previos

Complete los requisitosprevios de Singular Linkspara habilitar la vinculación profunda para su aplicación.

Implemente el controlador de enlaces singulares

SingularLinkHandler proporciona un mecanismo de devolución de llamada para recuperar los parámetros de enlace profundo, enlace profundo diferido y passthrough de los enlaces de seguimiento de Singular cuando se abre la aplicación.

Parámetros disponibles:

• Enlace profundo (_dl): La URL de destino dentro de su aplicación para los usuarios que hagan clic en el enlace.
• Enlace profundo diferido (_ddl): La URL de destino para los usuarios que instalan la aplicación después de hacer clic en el enlace
• Passthrough (_p): Datos personalizados pasados a través del enlace de seguimiento para un contexto adicional

Configuración del SDK

Añadir SingularLinkHandler a Config

Configure el SingularLinkHandler durante la inicialización del SDK para procesar los datos de enlace profundo entrantes y diferidos.

private fun initSingularSDK() {
    val config = SingularConfig("SDK_KEY", "SDK_SECRET")
        .withSingularLink(intent) { params ->
            val deeplink = params.deeplink
            val passthrough = params.passthrough
            val isDeferred = params.isDeferred

            Log.d("SingularLink", "Deeplink: ${deeplink ?: "null"}")
            Log.d("SingularLink", "Passthrough: ${passthrough ?: "null"}")
            Log.d("SingularLink", "Is Deferred: $isDeferred")
            
            // Handle deep link routing
            deeplink?.let { url ->
                handleDeepLink(url, isDeferred)
            }
        }

    try {
        Singular.init(applicationContext, config)
        Log.d("Singular", "SDK initialized successfully")
    } catch (e: Exception) {
        Log.e("Singular", "SDK initialization failed: ${e.message}")
    }
}

override fun onNewIntent(intent: Intent?) {
  super.onNewIntent(intent)
  // Configure onNewIntent to handle Warm start deeplinks
  intent?.let {
    setIntent(intent)
    initSingularSDK()
  }
}

private void initSingularSDK() {
    SingularConfig config = new SingularConfig("SDK_KEY", "SDK_SECRET")
        .withSingularLink(getIntent(), new SingularLinkHandler() {
            @Override
            public void onResolved(SingularLinkParams params) {
                String deeplink = params.getDeeplink();
                String passthrough = params.getPassthrough();
                boolean isDeferred = params.isDeferred();
                
                Log.d("SingularLink", "Deeplink: " + (deeplink != null ? deeplink : "null"));
                Log.d("SingularLink", "Passthrough: " + (passthrough != null ? passthrough : "null"));
                Log.d("SingularLink", "Is Deferred: " + isDeferred);
                
                // Handle deep link routing
                if (deeplink != null) {
                    handleDeepLink(deeplink, isDeferred);
                }
            }
        });
        
    try {
        Singular.init(getApplicationContext(), config);
        Log.d("Singular", "SDK initialized successfully");
    } catch (Exception e) {
        Log.e("Singular", "SDK initialization failed: " + e.getMessage());
    }
}

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    // Configure onNewIntent to handle Warm start deeplinks
    if (intent != null) {
        setIntent(intent);
        initSingularSDK();
    }
}

Comportamiento del Handler

Comprensión de la ejecución de SingularLinkHandler

El SingularLinkHandler se comporta de forma diferente dependiendo de si la aplicación está recién instalada o ya instalada.

Nueva instalación (enlace profundo diferido)

En una instalación nueva, no existe ninguna URL abierta cuando se inicia la aplicación. Singular completa la atribución para determinar si el enlace de seguimiento contenía un valor de enlace profundo o de enlace profundo diferido.

Flujode enlace profundo diferido:

1. El usuario hace clic en un enlace de seguimiento de Singular configurado con un valor de enlace profundo.
2. El usuario instala y abre la aplicación por primera vez
3. Singular SDK envía la primera sesión a los servidores de Singular
4. La atribución se completa e identifica el enlace profundo a partir del enlace de seguimiento
5. El valor del enlace profundo vuelve al SingularLinkHandler en el parámetro deeplink con isDeferred = true

Ya instalada (enlace profundo inmediato)

Cuando la aplicación ya está instalada, al hacer clic en un enlace singular se abre la aplicación inmediatamente utilizando la tecnología Android App Links.

Flujo de enlace profundo inmediato:

1. El usuario hace clic en un enlace de seguimiento Singular
2. Android OS proporciona una URL abierta que contiene todo el enlace de seguimiento Singular
3. Durante la inicialización del SDK, Singular analiza la intención de Android.
4. Singular extrae los valores deeplink y passthrough
5. Los valores vuelven a través del SingularLinkHandler con isDeferred = false

Parámetros Passthrough

Capture datos adicionales del clic del enlace de seguimiento utilizando parámetros passthrough.

Si se incluye un parámetro passthrough (_p) en el enlace de seguimiento, el parámetro passthrough del SingularLinkHandler contiene los datos correspondientes. Utilícelo para capturar metadatos de campaña, datos de segmentación de usuarios o cualquier información personalizada que necesite en la aplicación.

val config = SingularConfig("SDK_KEY", "SDK_SECRET")
    .withSingularLink(intent) { params ->
        // Extract passthrough data
        params.passthrough?.let { passthroughData ->
            // Parse and use custom data
            val jsonData = JSONObject(passthroughData)
            val campaignId = jsonData.optString("campaign_id")
            val userSegment = jsonData.optString("segment")
            
            Log.d("SingularLink", "Campaign ID: $campaignId")
            Log.d("SingularLink", "User Segment: $userSegment")
        }
    }

SingularConfig config = new SingularConfig("SDK_KEY", "SDK_SECRET")
    .withSingularLink(getIntent(), new SingularLinkHandler() {
        @Override
        public void onResolved(SingularLinkParams params) {
            // Extract passthrough data
            String passthroughData = params.getPassthrough();
            if (passthroughData != null) {
                try {
                    // Parse and use custom data
                    JSONObject jsonData = new JSONObject(passthroughData);
                    String campaignId = jsonData.optString("campaign_id");
                    String userSegment = jsonData.optString("segment");
                    
                    Log.d("SingularLink", "Campaign ID: " + campaignId);
                    Log.d("SingularLink", "User Segment: " + userSegment);
                } catch (JSONException e) {
                    Log.e("SingularLink", "Error parsing passthrough data");
                }
            }
        }
    });

Reenviar todos los parámetros de consulta

Capture todos los parámetros de consulta de la URL del enlace de seguimiento añadiendo el parámetro _forward_params=2.

Cuando se añade _forward_params=2 al enlace de seguimiento, todos los parámetros de consulta se incluyen en el parámetro deeplink del SingularLinkHandler, dándole acceso a la URL completa con todos sus parámetros.