SDK de Unity - Privacidad de datos

Seguir
Avatar
Jared Ornstead
Updated
Documento

Cumplimiento de las leyes de privacidad de datos

Implemente la recopilación de datos que cumpla con la privacidad notificando a Singular las opciones de consentimiento del usuario para GDPR, CCPA y otras regulaciones de privacidad del consumidor.

Cuando los usuarios consientan o rechacen compartir su información con terceros, utilice los métodos de privacidad de Singular para comunicar su elección. Esto garantiza el cumplimiento de normativas como la Ley de Privacidad del Consumidor de California (CCPA)y permite a los socios respetar las preferencias de privacidad del usuario.

Más información: Consulte Privacidad del usuario y Limitar el uso compartido dedatos para obtener información detallada sobre cómo Singular procesa el consentimiento de privacidad.

Limitar el uso compartido de datos

Control del intercambio de datos con terceros

Notifique a Singular si los usuarios han dado su consentimiento para compartir sus datos personales con socios terceros utilizando el método LimitDataSharing.

Firma del método: 

SingularSDK.LimitDataSharing(bool shouldLimitDataSharing)

Parámetros:

  • false: El usuario ha optado y consentido compartir sus datos
  • true: El usuario ha optado por no participar y no consiente compartir sus datos

Importante: Aunque es opcional, este método afecta a la compartición de datos de atribución. Algunos socios sólo comparten información de atribución completa cuando se notifica explícitamente que los usuarios han optado por ello.

Ejemplos de uso

C# 
using UnityEngine;
using Singular;

public class PrivacyManager : MonoBehaviour
{
    // User has opted in to share their data
    public void OnUserOptedInToDataSharing()
    {
        SingularSDK.LimitDataSharing(false);
        Debug.Log("Data sharing enabled");
    }

    // User has opted out and declined to share their data
    public void OnUserOptedOutOfDataSharing()
    {
        SingularSDK.LimitDataSharing(true);
        Debug.Log("Data sharing limited");
    }

    // Example: Set based on user preference
    public void HandlePrivacyConsent(bool userConsented)
    {
        // Pass inverse: false = opted in, true = opted out
        SingularSDK.LimitDataSharing(!userConsented);

        Debug.Log($"Data sharing: {(userConsented ? "Enabled" : "Limited")}");
    }
}

Cómo funciona:

Singular utiliza esta configuración en Postbacks de Privacidad de Usuarioy la pasa a los socios que la requieren para el cumplimiento normativo.

Métodos de cumplimiento de GDPR

Gestione el consentimiento de seguimiento del usuario y controle la funcionalidad del SDK para cumplir con el GDPR (Reglamento General de Protección de Datos) y otras normativas de privacidad.

Gestión del consentimiento de seguimiento

TrackingOptIn

Registre el consentimiento explícito del usuario para el seguimiento enviando un evento GDPR opt-in a los servidores de Singular.

Firma del método: 

SingularSDK.TrackingOptIn()

Cuándo Usar:

  • Cumplimiento GDPR: Llamada cuando los usuarios consienten explícitamente el seguimiento en regiones reguladas por GDPR.
  • Registro de consentimiento: Marca a los usuarios como que han dado su consentimiento GDPR en los sistemas de Singular
  • Comportamiento por defecto: Sin esta llamada, el SDK continúa el seguimiento pero no registra específicamente el consentimiento
C# 
using UnityEngine;
using Singular;

public class GDPRManager : MonoBehaviour
{
    // User accepted tracking consent
    public void OnUserAcceptedTracking()
    {
        SingularSDK.TrackingOptIn();
        Debug.Log("User opted in to tracking");
    }

    // Example: Call after consent dialog
    public void ShowGDPRConsentDialog()
    {
        // Your consent dialog UI logic here
        // ...

        // If user accepts:
        OnUserAcceptedTracking();
    }
}

Métodos de control de seguimiento

StopAllTracking

Desactiva completamente todas las actividades de seguimiento del SDK para el usuario actual en este dispositivo.

Firma del método: 

SingularSDK.StopAllTracking()

Crítico Advertencia: Este método desactiva permanentemente el SDK hasta que se llame a ResumeAllTracking(). El estado deshabilitado persiste durante los reinicios de la aplicación y sólo puede revertirse mediante programación.

Comportamiento:

  • Efecto inmediato: Detiene todo el seguimiento, la notificación de eventos y la recopilación de datos al instante.
  • Estado persistente: Permanece desactivado incluso después de cerrar y volver a abrir la aplicación.
  • Sin restablecimiento automático: Debe llamar explícitamente a ResumeAllTracking() para volver a activarlo.
C# 
using UnityEngine;
using Singular;

public class TrackingController : MonoBehaviour
{
    // User declined all tracking
    public void OnUserDeclinedTracking()
    {
        SingularSDK.StopAllTracking();
        Debug.Log("All tracking stopped");

        // Optionally store preference
        PlayerPrefs.SetInt("tracking_enabled", 0);
        PlayerPrefs.Save();
    }

    // Example: Handle user opt-out from settings menu
    public void HandlePrivacySettingsChange(bool trackingEnabled)
    {
        if (!trackingEnabled)
        {
            SingularSDK.StopAllTracking();
            Debug.Log("Privacy settings: Tracking disabled");
        }
    }
}

ReanudarTodoElSeguimiento

Volver a activar el seguimiento después de haberlo detenido con StopAllTracking().

Firma del método: 

SingularSDK.ResumeAllTracking()

Casos de uso:

  • Cambio de consentimiento: El usuario cambia sus preferencias de privacidad y vuelve a activar el seguimiento
  • Ajustes de privacidad: El usuario actualiza su consentimiento a través del menú de configuración de la aplicación
  • Cumplimiento regional: Volver a activar el seguimiento cuando el usuario se traslada a regiones no reguladas
C# 
using UnityEngine;
using Singular;

public class TrackingController : MonoBehaviour
{
    // User opted back in to tracking
    public void OnUserResumedTracking()
    {
        SingularSDK.ResumeAllTracking();
        Debug.Log("Tracking resumed");

        // Optionally update stored preference
        PlayerPrefs.SetInt("tracking_enabled", 1);
        PlayerPrefs.Save();
    }

    // Example: Handle consent update from settings
    public void HandlePrivacySettingsChange(bool trackingEnabled)
    {
        if (trackingEnabled)
        {
            SingularSDK.ResumeAllTracking();
            Debug.Log("Privacy settings: Tracking enabled");
        }
    }
}

IsAllTrackingStopped

Comprueba si se ha desactivado el seguimiento para el usuario actual.

Firma del método: 

bool SingularSDK.IsAllTrackingStopped()

Devuelve:

  • true: El seguimiento se ha detenido actualmente a través de StopAllTracking()
  • false: El seguimiento está activo (no se ha detenido nunca o se ha reanudado)
C# 
using UnityEngine;
using UnityEngine.UI;
using Singular;

public class PrivacySettingsUI : MonoBehaviour
{
    public Toggle trackingToggle;
    public Text statusText;

    void Start()
    {
        // Check current tracking status on startup
        UpdatePrivacyUI();
    }

    // Check current tracking status
    public bool IsTrackingEnabled()
    {
        return !SingularSDK.IsAllTrackingStopped();
    }

    // Example: Display privacy status in settings
    public string GetPrivacyStatusText()
    {
        if (SingularSDK.IsAllTrackingStopped())
        {
            return "Tracking: Disabled";
        }
        else
        {
            return "Tracking: Enabled";
        }
    }

    // Example: Sync UI with tracking state
    public void UpdatePrivacyUI()
    {
        bool isStopped = SingularSDK.IsAllTrackingStopped();

        if (trackingToggle != null)
        {
            trackingToggle.isOn = !isStopped;
        }

        if (statusText != null)
        {
            statusText.text = GetPrivacyStatusText();
        }

        Debug.Log($"Current tracking state: {(isStopped ? "Stopped" : "Active")}");
    }

    // Handle toggle change from UI
    public void OnTrackingToggleChanged(bool enabled)
    {
        if (enabled)
        {
            SingularSDK.ResumeAllTracking();
        }
        else
        {
            SingularSDK.StopAllTracking();
        }

        UpdatePrivacyUI();
    }
}

Protección de la intimidad de los niños

SeguimientoMenoresde13

Notifica a Singular que el usuario es menor de 13 años para cumplir con la ley COPPA (Children's Online Privacy Protection Act) y otras normativas sobre privacidad infantil.

Firma del método: 

SingularSDK.TrackingUnder13()

Requisitos de cumplimiento:

  • Cumplimiento de COPPA: Obligatorio para apps que recopilen datos de menores de 13 años en Estados Unidos.
  • Contenido restringido por edad: Se utiliza cuando los usuarios se identifican como menores de 13 años durante el registro o la verificación de la edad
  • Seguimiento restringido: Limita la recopilación de datos para cumplir con las leyes de protección de la privacidad infantil
C# 
using UnityEngine;
using Singular;

public class COPPAManager : MonoBehaviour
{
    // User identified as under 13
    public void OnUserUnder13()
    {
        SingularSDK.TrackingUnder13();
        Debug.Log("COPPA mode enabled for user under 13");
    }
    
    // Example: Call after age verification
    public void OnAgeVerified(int userAge)
    {
        if (userAge < 13)
        {
            SingularSDK.TrackingUnder13();
            Debug.Log("COPPA restrictions applied");
            
            // Also limit advertising identifiers
            SingularSDK.SetLimitAdvertisingIdentifiers(true);
        }
    }
}

Importante: Llame a este método lo antes posible después de determinar que el usuario es menor de 13 años, idealmente durante la inicialización de la aplicación o inmediatamente después de la verificación de la edad. Esto garantiza que todo el seguimiento posterior respete la normativa de protección de la intimidad de los menores.

SetLimitAdvertisingIdentifiers

Restringe la recopilación y el uso de identificadores de publicidad (GAID en Android, IDFA en iOS) tras la inicialización del SDK para aplicaciones de audiencia mixta.

Firma del método: 

SingularSDK.SetLimitAdvertisingIdentifiers(bool isEnabled)

Parámetros:

  • true: Habilitar el modo de identificadores publicitarios limitados (restringir la recopilación).
  • false: Desactivar el modo de identificadores publicitarios limitados (recopilación normal)

Casos de uso:

  • Aplicaciones de público mixto: Apps que sirven tanto a adultos como a niños en las que la edad se determina tras el lanzamiento de la app.
  • Controles dinámicos de privacidad: Ajustar el seguimiento en función de las acciones del usuario o del contenido al que se accede
  • Restricciones de tiempo de ejecución: Aplicar limitaciones de identificadores publicitarios tras la configuración inicial del SDK
C# 
using UnityEngine;
using Singular;

public class AdvertisingIdentifierManager : MonoBehaviour
{
    // Limit advertising identifiers after initialization
    public void EnableLimitedMode()
    {
        SingularSDK.SetLimitAdvertisingIdentifiers(true);
        Debug.Log("Advertising identifiers limited");
    }
    
    // Example: Mixed audience app with age gate
    public void OnKidsModeSwitched(bool isKidsMode)
    {
        if (isKidsMode)
        {
            SingularSDK.SetLimitAdvertisingIdentifiers(true);
            Debug.Log("Advertising identifiers limited for kids mode");
        }
        else
        {
            SingularSDK.SetLimitAdvertisingIdentifiers(false);
            Debug.Log("Advertising identifiers unrestricted for adult mode");
        }
    }
    
    // Example: Content-based restrictions
    public void OnViewingChildrensContent()
    {
        SingularSDK.SetLimitAdvertisingIdentifiers(true);
        Debug.Log("Ad identifiers restricted for children's content");
    }
    
    // Example: Combined with TrackingUnder13
    public void OnAgeVerified(int age)
    {
        if (age < 13)
        {
            SingularSDK.TrackingUnder13();
            SingularSDK.SetLimitAdvertisingIdentifiers(true);
            Debug.Log("Full COPPA restrictions applied");
        }
    }
}

Alternativa de configuración: También puede limitar los identificadores de publicidad durante la inicialización del SDK estableciendo la propiedad limitAdvertisingIdentifiers en la configuración de Singular SDK si conoce los requisitos de privacidad antes de que se inicie el SDK.

Propiedad de configuración

Establezca limitaciones de identificadores publicitarios durante la inicialización del SDK para aplicaciones que conozcan los requisitos de privacidad por adelantado.

C# 
using UnityEngine;
using Singular;

public class SDKInitializer : MonoBehaviour
{
    void Start()
    {
        // Get reference to SingularSDK component
        var singularSDK = GetComponent<SingularSDK>();
        
        // Limit advertising identifiers at initialization
        singularSDK.limitAdvertisingIdentifiers = true;
        
        // Initialize SDK
        if (!singularSDK.InitializeOnAwake)
        {
            SingularSDK.InitializeSingularSDK();
        }
    }
}

Mejores prácticas de implementación

Ejemplo de gestión completa de la privacidad

Implemente controles de privacidad completos que respeten las preferencias de los usuarios y cumplan la normativa.

C# 
using UnityEngine;
using Singular;

public class ComprehensivePrivacyManager : MonoBehaviour
{
    private const string PREF_USER_CONSENT = "privacy_user_consent";
    private const string PREF_DATA_SHARING = "privacy_data_sharing";

    void Start()
    {
        // Initialize privacy settings on app start
        InitializePrivacySettings();
    }

    /// <summary>
    /// Initialize privacy settings on app startup based on stored preferences
    /// </summary>
    public void InitializePrivacySettings()
    {
        bool hasUserConsent = GetUserConsent();
        bool allowDataSharing = GetDataSharingPreference();

        // Apply stored tracking preference
        if (hasUserConsent)
        {
            SingularSDK.TrackingOptIn();
            SingularSDK.ResumeAllTracking();
            Debug.Log("Privacy initialized: Tracking enabled with consent");
        }
        else
        {
            SingularSDK.StopAllTracking();
            Debug.Log("Privacy initialized: Tracking disabled");
        }

        // Set data sharing preference (inverse logic)
        SingularSDK.LimitDataSharing(!allowDataSharing);

        Debug.Log($"Privacy initialized: consent={hasUserConsent}, sharing={allowDataSharing}");
    }

    /// <summary>
    /// User accepts tracking via consent dialog
    /// </summary>
    public void OnUserAcceptedTracking()
    {
        SaveUserConsent(true);

        SingularSDK.TrackingOptIn();
        SingularSDK.ResumeAllTracking();

        Debug.Log("User accepted tracking");
    }

    /// <summary>
    /// User declines tracking
    /// </summary>
    public void OnUserDeclinedTracking()
    {
        SaveUserConsent(false);

        SingularSDK.StopAllTracking();

        Debug.Log("User declined tracking");
    }

    /// <summary>
    /// User updates data sharing preference
    /// </summary>
    /// <param name="enabled">True to enable data sharing, false to limit it</param>
    public void SetDataSharingEnabled(bool enabled)
    {
        SaveDataSharingPreference(enabled);

        // Note: LimitDataSharing uses inverse logic
        // false = data sharing enabled, true = data sharing limited
        SingularSDK.LimitDataSharing(!enabled);

        Debug.Log($"Data sharing: {(enabled ? "Enabled" : "Limited")}");
    }

    /// <summary>
    /// Check if tracking is currently enabled
    /// </summary>
    /// <returns>True if tracking is active, false if stopped</returns>
    public bool IsTrackingEnabled()
    {
        return !SingularSDK.IsAllTrackingStopped();
    }

    /// <summary>
    /// Get current privacy status as readable text
    /// </summary>
    /// <returns>Human-readable tracking status</returns>
    public string GetPrivacyStatus()
    {
        bool isEnabled = !SingularSDK.IsAllTrackingStopped();
        bool dataSharingEnabled = GetDataSharingPreference();

        return $"Tracking: {(isEnabled ? "Enabled" : "Disabled")}\n" +
               $"Data Sharing: {(dataSharingEnabled ? "Enabled" : "Limited")}";
    }

    // Private helper methods for PlayerPrefs storage

    private bool GetUserConsent()
    {
        return PlayerPrefs.GetInt(PREF_USER_CONSENT, 0) == 1;
    }

    private void SaveUserConsent(bool consent)
    {
        PlayerPrefs.SetInt(PREF_USER_CONSENT, consent ? 1 : 0);
        PlayerPrefs.Save();
    }

    private bool GetDataSharingPreference()
    {
        return PlayerPrefs.GetInt(PREF_DATA_SHARING, 0) == 1;
    }

    private void SaveDataSharingPreference(bool enabled)
    {
        PlayerPrefs.SetInt(PREF_DATA_SHARING, enabled ? 1 : 0);
        PlayerPrefs.Save();
    }
}

Mejores prácticas:

  • Almacenamiento persistente: Guarde las preferencias del usuario utilizando PlayerPrefs o una solución de almacenamiento seguro.
  • Inicialización temprana: Aplique la configuración de privacidad antes de la inicialización del SDK cuando sea posible.
  • Sincronización de la interfaz de usuario: Mantenga la configuración de la interfaz de usuario sincronizada con el estado real del SDK utilizando IsAllTrackingStopped()
  • Comunicación clara: Proporcione controles de privacidad claros y accesibles en la configuración de la aplicación
  • Lógica inversa: Recuerde que LimitDataSharing(false) significa que el intercambio de datos está activado, mientras que true significa que está limitado.
  • Documentación de cumplimiento: Mantenga registros de cuándo y cómo los usuarios proporcionan o revocan su consentimiento