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:

static void 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

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

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:

static void 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

// 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 control de seguimiento

StopAllTracking

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

Firma del método:

static void 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.

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

ReanudarTodoElSeguimiento

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

Firma del método:

static void 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

// 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

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

Firma del método:

static bool 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)

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

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:

static void 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

// 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: 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. De este modo se garantiza que todo el seguimiento posterior respete la normativa de protección de la intimidad de los menores.

Mejores prácticas de implementación

Ejemplo de gestión completa de la privacidad

Implemente controles de privacidad completos que respeten las preferencias del usuario y cumplan la normativa.

// 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
}

Mejores prácticas:

Almacenamiento persistente: Guarde las preferencias del usuario utilizando el sistema SaveGame de Unreal Engine o archivos de configuración personalizados.
Inicialización temprana: Aplique la configuración de privacidad durante BeginPlay() antes de la inicialización del SDK cuando sea posible.
Sincronización de la IU: Mantenga la configuración de la interfaz de usuario sincronizada con el estado real del SDK utilizando IsAllTrackingStopped()
Comunicación clara: Proporcionar 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: Mantén registros de cuándo y cómo los usuarios proporcionan o revocan su consentimiento

Método Resumen de referencia

Método	Descripción	Cuándo utilizarlo
`LimitDataSharing(bool)`	Control del intercambio de datos con terceros basado en el consentimiento del usuario	Cumplimiento de la CCPA, preferencias de privacidad del usuario
`TrackingOptIn()`	Registrar el consentimiento explícito de seguimiento del GDPR	Cumplimiento del GDPR en regiones de la UE
`StopAllTracking()`	Desactivar completamente el seguimiento del SDK	El usuario rechaza todo consentimiento de seguimiento
`ResumeAllTracking()`	Volver a activar el seguimiento después de detenerlo	El usuario cambia su consentimiento para volver a activarlo
`IsAllTrackingStopped()`	Comprobar el estado actual del seguimiento	Sincronizar la interfaz de usuario, comprobar el estado antes de las operaciones
`TrackingUnder13()`	Activar las protecciones COPPA para niños	Usuario identificado como menor de 13 años

SDK de Unreal Engine - Privacidad de datos

Cumplimiento de las leyes de privacidad de datos

Limitar el uso compartido de datos

Control del intercambio de datos con terceros

Ejemplos de uso

Métodos de cumplimiento de GDPR

Gestión del consentimiento de seguimiento

TrackingOptIn

Métodos de control de seguimiento

StopAllTracking

ReanudarTodoElSeguimiento

IsAllTrackingStopped

Protección de la intimidad de los niños

SeguimientoMenoresde13

Mejores prácticas de implementación

Ejemplo de gestión completa de la privacidad

Método Resumen de referencia