Apoyo a SKAdNetwork

SKAdNetwork es el marco de atribución centrado en la privacidad de Apple para campañas de instalación de aplicaciones iOS. A partir de la versión 4.0.17 del SDK de Unity, SKAdNetwork está habilitado por defecto en el modo gestionado, donde Singular actualiza automáticamente los valores de conversión basándose en el modelo de conversión configurado en el panel de control.

Entendiendo los Modos de SKAN

Modo Gestionado (por defecto)

En el modo gestionado, Singular gestiona automáticamente las actualizaciones de los valores de conversión basándose en el modelo de conversión configurado en el panel de control. Este es el enfoque recomendado para la mayoría de las aplicaciones, ya que requiere un código mínimo y proporciona un seguimiento óptimo de las conversiones.

• Actualizaciones automáticas: Singular gestiona todas las actualizaciones de los valores de conversión en función de los eventos del usuario y del modelo configurado.
• Configuración del cuadro de mando: Diseñe su modelo de conversión en el cuadro de mandos de Singular sin cambios en el código.
• Optimización: Benefíciese de la experiencia de Singular para maximizar las actualizaciones del valor de conversión dentro de las restricciones de Apple.

Modo Manual (Avanzado)

El modo manual le ofrece un control total sobre las actualizaciones de los valores de conversión, permitiéndole implementar una lógica personalizada para determinar cuándo y cómo actualizar los valores de conversión de SKAN. Utilice este modo sólo si tiene requisitos específicos que el Modo Gestionado no puede cumplir.

Versiones Legacy SDK

Si está utilizando una versión de SDK de Unity anterior a la 4.0.17, necesita habilitar manualmente el soporte de SKAdNetwork utilizando uno de los siguientes métodos.

using UnityEngine;
using Singular;

public class AppInitializer : MonoBehaviour
{
    void Awake()
    {
        // Register for SKAdNetwork attribution
        SingularSDK.SkanRegisterAppForAdNetworkAttribution();
    }
}

Configuración del modo manual

Para implementar una lógica de valores de conversión personalizada, active el Modo Manual y utilice los métodos SDK proporcionados para actualizar y supervisar los valores de conversión a lo largo del ciclo de vida de su aplicación.

public static bool SkanUpdateConversionValue(int value)

using UnityEngine;
using Singular;

public class ConversionTracker : MonoBehaviour
{
    void OnUserSignUp()
    {
        // Track the sign-up event
        SingularSDK.Event("SignUp");

        // Update SKAN conversion value to 7
        bool success = SingularSDK.SkanUpdateConversionValue(7);

        if (success)
        {
            Debug.Log("Conversion value updated successfully");
        }
        else
        {
            Debug.LogWarning("Failed to update conversion value");
        }
    }

    void OnPurchaseComplete(float purchaseAmount)
    {
        // Track revenue event
        SingularSDK.Revenue("USD", purchaseAmount);

        // Update conversion value based on purchase tier
        int conversionValue = CalculateConversionValue(purchaseAmount);
        SingularSDK.SkanUpdateConversionValue(conversionValue);
    }

    int CalculateConversionValue(float amount)
    {
        // Your custom logic to determine conversion value
        if (amount >= 100) return 63;      // High value
        if (amount >= 50) return 40;       // Medium value
        if (amount >= 10) return 20;       // Low value
        return 10;                          // Minimal value
    }
}

public static int? SkanGetConversionValue()

using UnityEngine;
using Singular;

public class ConversionMonitor : MonoBehaviour
{
    void CheckConversionValue()
    {
        int? currentValue = SingularSDK.SkanGetConversionValue();

        if (currentValue.HasValue)
        {
            Debug.Log($"Current conversion value: {currentValue.Value}");

            // Only update if current value is below threshold
            if (currentValue.Value < 30)
            {
                SingularSDK.SkanUpdateConversionValue(30);
            }
        }
        else
        {
            Debug.LogWarning("Conversion value not available");
        }
    }
}

public static void SetConversionValueUpdatedHandler(SingularConversionValueUpdatedHandler handler)

using UnityEngine;
using Singular;

public class ConversionValueMonitor : MonoBehaviour, SingularConversionValueUpdatedHandler
{
    void Awake()
    {
        // Register this class as the conversion value update handler
        SingularSDK.SetConversionValueUpdatedHandler(this);
    }

    // This method is called whenever the conversion value is updated
    public void OnConversionValueUpdated(int newValue)
    {
        Debug.Log($"Conversion value updated to: {newValue}");

        // Log the update to your analytics
        LogConversionValueUpdate(newValue);

        // Trigger any app-specific behavior
        if (newValue >= 50)
        {
            UnlockPremiumFeature();
        }
    }

    void LogConversionValueUpdate(int value)
    {
        // Your analytics logging logic
        Debug.Log($"Analytics: SKAN CV = {value}");
    }

    void UnlockPremiumFeature()
    {
        // Your custom logic
        Debug.Log("Premium feature unlocked based on high conversion value");
    }
}

Compatibilidad con App Tracking Transparency (ATT)

App Tracking Transparency (ATT) es el marco de privacidad de Apple que requiere el consentimiento del usuario antes de acceder al IDFA (identificador para anunciantes) del dispositivo y compartir los datos del usuario. Implementar ATT correctamente es fundamental para la atribución de iOS y maximizar la precisión de sus campañas de adquisición de usuarios.

Por qué la ATT es importante para la atribución

A partir de iOS 14.5, las apps deben solicitar permiso al usuario a través del marco ATT antes de acceder al IDFA. Aunque la atribución sigue siendo posible sin el IDFA utilizando métodos de huella digital y probabilísticos, disponer del IDFA mejora significativamente la precisión de la atribución y proporciona una correspondencia determinista.

• Atribución determinista: El IDFA permite una atribución precisa a nivel de dispositivo que conecta directamente las impresiones publicitarias con las instalaciones.
• Optimización de la red publicitaria: Las redes publicitarias pueden optimizar mejor las campañas y proporcionar informes más precisos con el acceso al IDFA.
• Información a nivel de usuario: El acceso al IDFA permite un análisis más granular del comportamiento del usuario y el seguimiento de cohortes.

Momento de inicialización del SDK

Si el SDK inicializa y envía la primera sesión antes de que el usuario responda a la solicitud de ATT, el IDFA no será capturado, resultando en una atribución menos precisa.

¿Por qué retrasar la inicialización?

Por defecto, Singular SDK envía una sesión inmediatamente después de la inicialización. Cuando esta sesión proviene de un nuevo dispositivo, activa el proceso de atribución de Singular utilizando sólo los datos disponibles en ese momento. Si el usuario aún no ha respondido a la solicitud de ATT, el IDFA no estará disponible y la atribución se basará en métodos menos precisos.

Configurar el tiempo de espera del SDK

Configure el SDK para que espere la respuesta ATT del usuario antes de inicializarse estableciendo la propiedad waitForTrackingAuthorizationWithTimeoutInterval. Este retardo da tiempo al usuario para responder al aviso ATT a la vez que evita retrasos indefinidos si no se muestra el aviso.

Pasos de Configuración

1. Seleccione el SingularSDKObject en su jerarquía de escena Unity.
2. En el panel Inspector, localice la propiedad waitForTrackingAuthorizationWithTimeoutInterval.
3. Establezca el valor basado en su implementación ATT:
   • Mostrando aviso ATT: Establecer a 300(5 minutos)
   • No mostrar aviso ATT: Dejar en 0(sin espera)

Ejemplo de implementación

A continuación se muestra cómo implementar ATT en su aplicación Unity con el tiempo de inicialización SDK adecuado.

using UnityEngine;
using Singular;

#if UNITY_IOS
using Unity.Advertisement.IosSupport;
#endif

public class ATTManager : MonoBehaviour
{
    void Start()
    {
#if UNITY_IOS
        // Check ATT status on iOS
        RequestTrackingAuthorization();
#else
        // Initialize SDK immediately on non-iOS platforms
        InitializeSingularSDK();
#endif
    }

#if UNITY_IOS
    void RequestTrackingAuthorization()
    {
        // Check current authorization status
        var status = ATTrackingStatusBinding.GetAuthorizationTrackingStatus();

        if (status == ATTrackingStatusBinding.AuthorizationTrackingStatus.NOT_DETERMINED)
        {
            // Request authorization if not yet determined
            ATTrackingStatusBinding.RequestAuthorizationTracking(OnATTResponse);
        }
        else
        {
            // Status already determined, initialize SDK
            InitializeSingularSDK();
        }
    }

    void OnATTResponse(int status)
    {
        // Log the user's response
        switch (status)
        {
            case (int)ATTrackingStatusBinding.AuthorizationTrackingStatus.AUTHORIZED:
                Debug.Log("User authorized tracking - IDFA will be available");
                break;
            case (int)ATTrackingStatusBinding.AuthorizationTrackingStatus.DENIED:
                Debug.Log("User denied tracking - IDFA not available");
                break;
            case (int)ATTrackingStatusBinding.AuthorizationTrackingStatus.RESTRICTED:
                Debug.Log("Tracking restricted by device settings");
                break;
            default:
                Debug.Log("ATT status unknown");
                break;
        }

        // Initialize SDK after receiving response
        InitializeSingularSDK();
    }
#endif

    void InitializeSingularSDK()
    {
        // SDK is initialized with waitForTrackingAuthorizationWithTimeoutInterval
        // configured in the Inspector, so it will wait for ATT if needed
        // If Initialize On Awake is disabled, manually initialize here
        // SingularSDK.InitializeSingularSDK();

        Debug.Log("Singular SDK initialized");
    }
}

Mejores prácticas de ATT

• Mensajes previos al aviso: Muestre a los usuarios una pantalla previa a la ATT en la que se explique por qué necesita el permiso de seguimiento y en qué les beneficia (mejores anuncios, mejor experiencia). Esto puede aumentar significativamente las tasas de aceptación.
• El momento es importante: Muestre la solicitud de ATT en un momento natural del flujo de su aplicación, no inmediatamente después del primer lanzamiento. Deje que los usuarios experimenten primero su aplicación.
• Mensajes personalizados: Personalice su mensaje de aviso de ATT en su archivo Info.plist utilizando la tecla NSUserTrackingUsageDescription para explicar claramente su propósito de seguimiento.
• Pruebe a fondo: Pruebe tanto las situaciones autorizadas como las denegadas para asegurarse de que su aplicación funciona correctamente independientemente de la elección del usuario.
• Respete la elección del usuario: Nunca preguntes repetidamente a los usuarios que han denegado el seguimiento ni muestres mensajes agresivos que les presionen para que acepten.

Recursos adicionales

• Documentación del marco de transparencia de seguimiento de aplicaciones de Apple
• Prácticas de Opt-In y Opt-Out del SDK de Singular
• Directrices de Apple sobre privacidad del usuario y uso de datos