SDK do Unreal Engine - Privacidade de dados

Seguir
Avatar
Eyal Rabinovich
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: 

static void 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 só partilham informações de atribuição completas quando são explicitamente notificados de que os utilizadores optaram por participar.

Exemplos de utilização

C++ 
// User has opted in to share their data
void AYourGameMode::OnUserOptedInToDataSharing()
{
    USingularSDKBPLibrary::LimitDataSharing(false);
    UE_LOG(LogTemp, Log, TEXT("Data sharing enabled"));
}

// User has opted out and declined to share their data
void AYourGameMode::OnUserOptedOutOfDataSharing()
{
    USingularSDKBPLibrary::LimitDataSharing(true);
    UE_LOG(LogTemp, Log, TEXT("Data sharing limited"));
}

// Example: Set based on user preference
void AYourGameMode::HandlePrivacyConsent(bool bUserConsented)
{
    // Pass inverse: false = opted in, true = opted out
    USingularSDKBPLibrary::LimitDataSharing(!bUserConsented);

    UE_LOG(LogTemp, Log, TEXT("Data sharing: %s"), 
           bUserConsented ? TEXT("Enabled") : TEXT("Limited"));
}

Como funciona:

A Singular utiliza esta definição nos 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: 

static void 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++ 
// User accepted tracking consent
void AGDPRManager::OnUserAcceptedTracking()
{
    USingularSDKBPLibrary::TrackingOptIn();
    UE_LOG(LogTemp, Log, TEXT("User opted in to tracking"));
}

// Example: Call after consent dialog
void AGDPRManager::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: 

static void 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++ 
// User declined all tracking
void ATrackingController::OnUserDeclinedTracking()
{
    USingularSDKBPLibrary::StopAllTracking();
    UE_LOG(LogTemp, Log, TEXT("All tracking stopped"));

    // Optionally store preference
    SaveBoolToConfig(TEXT("tracking_enabled"), false);
}

// Example: Handle user opt-out from settings menu
void ATrackingController::HandlePrivacySettingsChange(bool bTrackingEnabled)
{
    if (!bTrackingEnabled)
    {
        USingularSDKBPLibrary::StopAllTracking();
        UE_LOG(LogTemp, Log, TEXT("Privacy settings: Tracking disabled"));
    }
}

RetomarTudoRastreio

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

Assinatura do método: 

static void 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++ 
// User opted back in to tracking
void ATrackingController::OnUserResumedTracking()
{
    USingularSDKBPLibrary::ResumeAllTracking();
    UE_LOG(LogTemp, Log, TEXT("Tracking resumed"));

    // Optionally update stored preference
    SaveBoolToConfig(TEXT("tracking_enabled"), true);
}

// Example: Handle consent update from settings
void ATrackingController::HandlePrivacySettingsChange(bool bTrackingEnabled)
{
    if (bTrackingEnabled)
    {
        USingularSDKBPLibrary::ResumeAllTracking();
        UE_LOG(LogTemp, Log, TEXT("Privacy settings: Tracking enabled"));
    }
}

IsAllTrackingStopped

Verificar se o rastreio foi desativado para o utilizador atual.

Assinatura do método: 

static bool IsAllTrackingStopped()

Retorna:

  • true: O rastreio está atualmente parado através de StopAllTracking()
  • false: O rastreio está ativo (nunca foi interrompido ou retomado)
C++ 
// Check current tracking status on startup
void APrivacySettingsUI::BeginPlay()
{
    Super::BeginPlay();
    UpdatePrivacyUI();
}

// Check current tracking status
bool APrivacySettingsUI::IsTrackingEnabled()
{
    return !USingularSDKBPLibrary::IsAllTrackingStopped();
}

// Example: Display privacy status in settings
FString APrivacySettingsUI::GetPrivacyStatusText()
{
    if (USingularSDKBPLibrary::IsAllTrackingStopped())
    {
        return TEXT("Tracking: Disabled");
    }
    else
    {
        return TEXT("Tracking: Enabled");
    }
}

// Example: Sync UI with tracking state
void APrivacySettingsUI::UpdatePrivacyUI()
{
    bool bIsStopped = USingularSDKBPLibrary::IsAllTrackingStopped();

    if (TrackingToggle != nullptr)
    {
        TrackingToggle->SetIsChecked(!bIsStopped);
    }

    if (StatusText != nullptr)
    {
        FString StatusString = bIsStopped ? TEXT("Stopped") : TEXT("Active");
        StatusText->SetText(FText::FromString(
            FString::Printf(TEXT("Current tracking state: %s"), *StatusString)
        ));
    }

    UE_LOG(LogTemp, Log, TEXT("Current tracking state: %s"), 
           bIsStopped ? TEXT("Stopped") : TEXT("Active"));
}

// Handle toggle change from UI
void APrivacySettingsUI::OnTrackingToggleChanged(bool bEnabled)
{
    if (bEnabled)
    {
        USingularSDKBPLibrary::ResumeAllTracking();
    }
    else
    {
        USingularSDKBPLibrary::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: 

static void 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++ 
// User identified as under 13
void ACOPPAManager::OnUserUnder13()
{
    USingularSDKBPLibrary::TrackingUnder13();
    UE_LOG(LogTemp, Log, TEXT("COPPA mode enabled for user under 13"));
}

// Example: Call after age verification
void ACOPPAManager::OnAgeVerified(int UserAge)
{
    if (UserAge < 13)
    {
        USingularSDKBPLibrary::TrackingUnder13();
        UE_LOG(LogTemp, Log, TEXT("COPPA restrictions applied"));

        // Also limit data sharing for children
        USingularSDKBPLibrary::LimitDataSharing(true);
    }
}

// Example: Age gate implementation
void AAgeGateWidget::OnAgeSubmitted(int UserAge)
{
    if (UserAge < 13)
    {
        // Apply COPPA protections
        USingularSDKBPLibrary::TrackingUnder13();
        USingularSDKBPLibrary::LimitDataSharing(true);

        UE_LOG(LogTemp, Warning, TEXT("Child user detected - privacy protections enabled"));

        // Show age-appropriate content
        ShowChildSafeContent();
    }
    else
    {
        // Standard tracking for users 13+
        UE_LOG(LogTemp, Log, TEXT("Adult user - standard tracking enabled"));
        InitializeStandardTracking();
    }
}

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. Isto garante que todo o seguimento subsequente respeita os regulamentos de privacidade das crianças.

Melhores práticas de implementação

Exemplo de gestão de privacidade completa

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

C++ 
// ComprehensivePrivacyManager.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "ComprehensivePrivacyManager.generated.h"

UCLASS()
class YOURGAME_API AComprehensivePrivacyManager : public AActor
{
    GENERATED_BODY()

public:
    AComprehensivePrivacyManager();

protected:
    virtual void BeginPlay() override;

public:
    // Initialize privacy settings on app startup
    UFUNCTION(BlueprintCallable, Category = "Privacy")
    void InitializePrivacySettings();

    // User accepts tracking via consent dialog
    UFUNCTION(BlueprintCallable, Category = "Privacy")
    void OnUserAcceptedTracking();

    // User declines tracking
    UFUNCTION(BlueprintCallable, Category = "Privacy")
    void OnUserDeclinedTracking();

    // User updates data sharing preference
    UFUNCTION(BlueprintCallable, Category = "Privacy")
    void SetDataSharingEnabled(bool bEnabled);

    // Check if tracking is currently enabled
    UFUNCTION(BlueprintCallable, Category = "Privacy")
    bool IsTrackingEnabled();

    // Get current privacy status as readable text
    UFUNCTION(BlueprintCallable, Category = "Privacy")
    FString GetPrivacyStatus();

private:
    // Helper methods for config storage
    bool GetUserConsent();
    void SaveUserConsent(bool bConsent);
    bool GetDataSharingPreference();
    void SaveDataSharingPreference(bool bEnabled);

    // Config keys
    static const FString PREF_USER_CONSENT;
    static const FString PREF_DATA_SHARING;
};

// ComprehensivePrivacyManager.cpp
#include "ComprehensivePrivacyManager.h"
#include "SingularSDKBPLibrary.h"
#include "Kismet/GameplayStatics.h"

const FString AComprehensivePrivacyManager::PREF_USER_CONSENT = TEXT("privacy_user_consent");
const FString AComprehensivePrivacyManager::PREF_DATA_SHARING = TEXT("privacy_data_sharing");

AComprehensivePrivacyManager::AComprehensivePrivacyManager()
{
    PrimaryActorTick.bCanEverTick = false;
}

void AComprehensivePrivacyManager::BeginPlay()
{
    Super::BeginPlay();

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

void AComprehensivePrivacyManager::InitializePrivacySettings()
{
    bool bHasUserConsent = GetUserConsent();
    bool bAllowDataSharing = GetDataSharingPreference();

    // Apply stored tracking preference
    if (bHasUserConsent)
    {
        USingularSDKBPLibrary::TrackingOptIn();
        USingularSDKBPLibrary::ResumeAllTracking();
        UE_LOG(LogTemp, Log, TEXT("Privacy initialized: Tracking enabled with consent"));
    }
    else
    {
        USingularSDKBPLibrary::StopAllTracking();
        UE_LOG(LogTemp, Log, TEXT("Privacy initialized: Tracking disabled"));
    }

    // Set data sharing preference (inverse logic)
    USingularSDKBPLibrary::LimitDataSharing(!bAllowDataSharing);

    UE_LOG(LogTemp, Log, TEXT("Privacy initialized: consent=%s, sharing=%s"), 
           bHasUserConsent ? TEXT("true") : TEXT("false"),
           bAllowDataSharing ? TEXT("true") : TEXT("false"));
}

void AComprehensivePrivacyManager::OnUserAcceptedTracking()
{
    SaveUserConsent(true);

    USingularSDKBPLibrary::TrackingOptIn();
    USingularSDKBPLibrary::ResumeAllTracking();

    UE_LOG(LogTemp, Log, TEXT("User accepted tracking"));
}

void AComprehensivePrivacyManager::OnUserDeclinedTracking()
{
    SaveUserConsent(false);

    USingularSDKBPLibrary::StopAllTracking();

    UE_LOG(LogTemp, Log, TEXT("User declined tracking"));
}

void AComprehensivePrivacyManager::SetDataSharingEnabled(bool bEnabled)
{
    SaveDataSharingPreference(bEnabled);

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

    UE_LOG(LogTemp, Log, TEXT("Data sharing: %s"), 
           bEnabled ? TEXT("Enabled") : TEXT("Limited"));
}

bool AComprehensivePrivacyManager::IsTrackingEnabled()
{
    return !USingularSDKBPLibrary::IsAllTrackingStopped();
}

FString AComprehensivePrivacyManager::GetPrivacyStatus()
{
    bool bIsEnabled = !USingularSDKBPLibrary::IsAllTrackingStopped();
    bool bDataSharingEnabled = GetDataSharingPreference();

    return FString::Printf(TEXT("Tracking: %s\nData Sharing: %s"),
                          bIsEnabled ? TEXT("Enabled") : TEXT("Disabled"),
                          bDataSharingEnabled ? TEXT("Enabled") : TEXT("Limited"));
}

// Private helper methods for config storage

bool AComprehensivePrivacyManager::GetUserConsent()
{
    // Implement your config storage retrieval here
    // Example using GameInstance or SaveGame system
    return false; // Default to no consent
}

void AComprehensivePrivacyManager::SaveUserConsent(bool bConsent)
{
    // Implement your config storage here
    // Example using GameInstance or SaveGame system
}

bool AComprehensivePrivacyManager::GetDataSharingPreference()
{
    // Implement your config storage retrieval here
    return false; // Default to limited sharing
}

void AComprehensivePrivacyManager::SaveDataSharingPreference(bool bEnabled)
{
    // Implement your config storage here
}

Melhores práticas:

  • Armazenamento persistente: Guarde as preferências do utilizador utilizando o sistema SaveGame do Unreal Engine ou ficheiros de configuração personalizados
  • Inicialização antecipada: Aplicar configurações de privacidade durante BeginPlay() antes da inicialização do SDK, quando possível
  • Sincronização da interface do usuário: 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

Resumo da referência do método

Método Descrição Quando utilizar
LimitDataSharing(bool) Controlar a partilha de dados de terceiros com base no consentimento do utilizador Conformidade com a CCPA, preferências de privacidade do utilizador
TrackingOptIn() Registar o consentimento explícito de rastreio do RGPD Conformidade com o RGPD nas regiões da UE
StopAllTracking() Desativar completamente o rastreio do SDK O utilizador recusa todo o consentimento de seguimento
ResumeAllTracking() Voltar a ativar o seguimento após a interrupção O utilizador altera o consentimento para voltar a participar
IsAllTrackingStopped() Verificar o estado atual do seguimento Sincronizar a IU, verificar o estado antes das operações
TrackingUnder13() Ativar as protecções COPPA para crianças Utilizador identificado como tendo menos de 13 anos de idade