SDK do Unity - Privacidade de dados

Seguir
Avatar
Jared Ornstead
Updated
Documento

Conformidade com as leis de privacidade de dados

Implemente a coleta de dados em conformidade com a privacidade, notificando a Singular sobre as opções de consentimento do usuário para GDPR, CCPA e outros regulamentos de privacidade do consumidor.

Quando os utilizadores consentirem ou recusarem a partilha das suas informações com terceiros, utilize os métodos de privacidade da Singular para comunicar a sua escolha. Isso garante a conformidade com regulamentos como a Lei de Privacidade do Consumidor da Califórnia (CCPA)e permite que os parceiros respeitem as preferências de privacidade do usuário.

Saiba mais: Consulte Privacidade do usuário e Limitar compartilhamento de dadospara obter informações detalhadas sobre como a Singular processa o consentimento de privacidade.

Limitar a partilha de dados

Controlar o compartilhamento de dados de terceiros

Notificar a Singular se os usuários consentiram em compartilhar seus dados pessoais com parceiros terceiros usando o método LimitDataSharing.

Assinatura do método: 

SingularSDK.LimitDataSharing(bool shouldLimitDataSharing)

Parâmetros:

  • false: O utilizador optou e consentiu a partilha dos seus dados
  • true: O utilizador optou por não participar e não consente a partilha dos seus dados

Importante: Embora opcional, este método afecta a partilha de dados de atribuição. Alguns parceiros apenas partilham informações de atribuição completas quando são explicitamente notificados de que os utilizadores optaram por participar.

Exemplos de utilização

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

Como funciona:

A Singular utiliza esta definição em Postbacks de privacidade do utilizadore transmite-a aos parceiros que a exigem para conformidade regulamentar.

Métodos de conformidade com o GDPR

Gerencie o consentimento de rastreamento do usuário e controle a funcionalidade do SDK para estar em conformidade com o GDPR (Regulamento Geral de Proteção de Dados) e outros regulamentos de privacidade.

Gestão do consentimento de rastreio

TrackingOptIn

Regista o consentimento explícito do utilizador para o rastreio, enviando um evento GDPR opt-in para os servidores Singular.

Assinatura do método: 

SingularSDK.TrackingOptIn()

Quando usar:

  • Conformidade com o GDPR: Chamar quando os usuários consentirem explicitamente com o rastreamento em regiões regulamentadas pelo GDPR
  • Registro de consentimento: Marca os usuários como tendo fornecido consentimento GDPR nos sistemas da Singular
  • Comportamento padrão: Sem esta chamada, o SDK continua a rastrear mas não regista especificamente o consentimento
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 controlo de rastreio

StopAllTracking

Desabilita completamente todas as atividades de rastreamento do SDK para o usuário atual neste dispositivo.

Assinatura do método: 

SingularSDK.StopAllTracking()

Crítico Aviso: Este método desactiva permanentemente o SDK até que ResumeAllTracking() seja chamado. O estado de desativação persiste durante as reinicializações da aplicação e só pode ser revertido programaticamente.

Comportamento:

  • Efeito imediato: Interrompe todo o rastreamento, relatório de eventos e coleta de dados instantaneamente
  • Estado persistente: Permanece desativado mesmo depois de a aplicação ser fechada e reaberta
  • Sem reinicialização automática: Tem de chamar explicitamente ResumeAllTracking() para voltar a ativar
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");
        }
    }
}

RetomarTudoRastreio

Reativar o rastreio depois de ter sido interrompido com StopAllTracking().

Assinatura do método: 

SingularSDK.ResumeAllTracking()

Casos de utilização:

  • Alteração de consentimento: O utilizador altera as preferências de privacidade e volta a optar pelo rastreio
  • Definições de privacidade: O utilizador actualiza o consentimento através do menu de definições da aplicação
  • Conformidade regional: Reativar o rastreio quando o utilizador se desloca para regiões não regulamentadas
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

Verificar se o rastreio foi desativado para o utilizador atual.

Assinatura do método: 

bool SingularSDK.IsAllTrackingStopped()

Retorna:

  • true: O rastreio está atualmente parado através de StopAllTracking()
  • false: O rastreio está ativo (nunca foi interrompido ou retomado)
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();
    }
}

Proteção da privacidade das crianças

TrackingUnder13

Notifica a Singular de que o utilizador tem menos de 13 anos de idade para cumprir a COPPA (Children's Online Privacy Protection Act) e outros regulamentos de privacidade infantil.

Assinatura do método: 

SingularSDK.TrackingUnder13()

Requisitos de conformidade:

  • Conformidade com a COPPA: Necessário para aplicações que recolhem dados de crianças com menos de 13 anos nos Estados Unidos
  • Conteúdo com limite de idade: Utilizar quando os utilizadores se identificam como tendo menos de 13 anos durante o registo ou a verificação da idade
  • Rastreio restrito: Limita a recolha de dados para cumprir as leis de proteção da privacidade das crianças
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: Chame este método o mais cedo possível depois de determinar que o utilizador tem menos de 13 anos, idealmente durante a inicialização da aplicação ou imediatamente após a verificação da idade. Isso garante que todo o rastreamento subsequente respeite os regulamentos de privacidade das crianças.

SetLimitAdvertisingIdentifiers

Restringe a coleta e o uso de identificadores de publicidade (GAID no Android, IDFA no iOS) após a inicialização do SDK para aplicativos de público misto.

Assinatura do método: 

SingularSDK.SetLimitAdvertisingIdentifiers(bool isEnabled)

Parâmetros:

  • true: Ativar o modo de identificadores de publicidade limitados (restringir a recolha)
  • false: Desativar o modo de identificadores de publicidade limitados (recolha normal)

Casos de uso:

  • Aplicações de público misto: Aplicações que servem adultos e crianças em que a idade é determinada após o lançamento da aplicação
  • Controlos de privacidade dinâmicos: Ajustar o rastreio com base nas acções do utilizador ou no conteúdo acedido
  • Restrições de tempo de execução: Aplicar limitações de identificadores de publicidade após a configuração inicial do 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 configuração: Também é possível limitar os identificadores de publicidade durante a inicialização do SDK, definindo a propriedade limitAdvertisingIdentifiers na configuração do SDK Singular, se conhecer os requisitos de privacidade antes do início do SDK.

Propriedade de configuração

Definir limitações de identificadores de publicidade durante a inicialização do SDK para aplicações que conhecem os requisitos de privacidade antecipadamente.

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

Práticas recomendadas de implementação

Exemplo de gerenciamento de privacidade completo

Implemente controlos de privacidade abrangentes que respeitem as preferências do utilizador e cumpram os regulamentos.

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

Melhores práticas:

  • Armazenamento persistente: Guarde as preferências do utilizador utilizando PlayerPrefs ou uma solução de armazenamento seguro
  • Inicialização antecipada: Aplicar definições de privacidade antes da inicialização do SDK, quando possível
  • Sincronização da IU: Mantenha as configurações da interface do usuário sincronizadas com o estado real do SDK usando IsAllTrackingStopped()
  • Comunicação clara: Fornecer controlos de privacidade claros e acessíveis nas definições da aplicação
  • Lógica inversa: Lembre-se de que LimitDataSharing(false) significa que a partilha de dados está activada, enquanto true significa que está limitada
  • Documentação de conformidade: Manter registos de quando e como os utilizadores fornecem ou revogam o consentimento