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.

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:

+ (void)limitDataSharing:(BOOL)shouldLimitDataSharing;

Parámetros:

• NO (falso): El usuario ha optado y consentido compartir sus datos
• YES (verdadero): El usuario ha optado por no participar y no consiente compartir sus datos

Ejemplos de uso

// User has opted in to share their data
Singular.limitDataSharing(false)

// User has opted out and declined to share their data
Singular.limitDataSharing(true)

// Example: Set based on user preference
func handlePrivacyConsent(userConsented: Bool) {
    // Pass inverse: false = opted in, true = opted out
    Singular.limitDataSharing(!userConsented)
    
    print("Data sharing: \(userConsented ? "Enabled" : "Limited")")
}

// User has opted in to share their data
[Singular limitDataSharing:NO];

// User has opted out and declined to share their data
[Singular limitDataSharing:YES];

// Example: Set based on user preference
- (void)handlePrivacyConsent:(BOOL)userConsented {
    // Pass inverse: NO = opted in, YES = opted out
    [Singular limitDataSharing:!userConsented];
    
    NSLog(@"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 mediante el envío de un evento GDPR opt-in a los servidores de Singular.

Firma del método:

+ (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
Singular.trackingOptIn()

// Example: Call after consent dialog
func onUserAcceptedTracking() {
    Singular.trackingOptIn()
    print("User opted in to tracking")
}

// User accepted tracking consent
[Singular trackingOptIn];

// Example: Call after consent dialog
- (void)onUserAcceptedTracking {
    [Singular trackingOptIn];
    NSLog(@"User opted in to tracking");
}

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:

+ (void)stopAllTracking;

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 habilitarlo

// User declined all tracking
Singular.stopAllTracking()

// Example: Handle user opt-out
func onUserDeclinedTracking() {
    Singular.stopAllTracking()
    print("All tracking stopped")
    
    // Optionally store preference
    saveUserTrackingPreference(false)
}

// User declined all tracking
[Singular stopAllTracking];

// Example: Handle user opt-out
- (void)onUserDeclinedTracking {
    [Singular stopAllTracking];
    NSLog(@"All tracking stopped");
    
    // Optionally store preference
    [self saveUserTrackingPreference:NO];
}

reanudarTodoElSeguimiento

Volver a activar el seguimiento después de haberlo detenido con stopAllTracking.

Firma del método:

+ (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
Singular.resumeAllTracking()

// Example: Handle consent update
func onUserResumedTracking() {
    Singular.resumeAllTracking()
    print("Tracking resumed")
    
    // Optionally update stored preference
    saveUserTrackingPreference(true)
}

// User opted back in to tracking
[Singular resumeAllTracking];

// Example: Handle consent update
- (void)onUserResumedTracking {
    [Singular resumeAllTracking];
    NSLog(@"Tracking resumed");
    
    // Optionally update stored preference
    [self saveUserTrackingPreference:YES];
}

isAllTrackingStopped

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

Firma del método:

+ (BOOL)isAllTrackingStopped;

Devuelve:

• YES (verdadero): El seguimiento se ha detenido actualmente a través de stopAllTracking
• NO (falso): El seguimiento está activo (no se ha detenido nunca o se ha reanudado)

// Check current tracking status
let isTrackingStopped = Singular.isAllTrackingStopped()

// Example: Display privacy status in settings
func getPrivacyStatusText() -> String {
    return Singular.isAllTrackingStopped() ? "Tracking: Disabled" : "Tracking: Enabled"
}

// Example: Sync UI with tracking state
func updatePrivacyToggle() {
    let isStopped = Singular.isAllTrackingStopped()
    privacyToggle.isOn = !isStopped
    print("Current tracking state: \(isStopped ? "Stopped" : "Active")")
}

// Check current tracking status
BOOL isTrackingStopped = [Singular isAllTrackingStopped];

// Example: Display privacy status in settings
- (NSString *)getPrivacyStatusText {
    return [Singular isAllTrackingStopped] ? @"Tracking: Disabled" : @"Tracking: Enabled";
}

// Example: Sync UI with tracking state
- (void)updatePrivacyToggle {
    BOOL isStopped = [Singular isAllTrackingStopped];
    self.privacyToggle.on = !isStopped;
    NSLog(@"Current tracking state: %@", isStopped ? @"Stopped" : @"Active");
}

Protección de la intimidad de los niños

trackingUnder13

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:

+ (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
Singular.trackingUnder13()

// Example: Call after age verification
func onAgeVerified(userAge: Int) {
    if userAge < 13 {
        Singular.trackingUnder13()
        print("COPPA mode enabled for user under 13")
    }
}

// User identified as under 13
[Singular trackingUnder13];

// Example: Call after age verification
- (void)onAgeVerified:(int)userAge {
    if (userAge < 13) {
        [Singular trackingUnder13];
        NSLog(@"COPPA mode enabled for user under 13");
    }
}

limitAdvertisingIdentifiers

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

Propiedad de configuración:

@property (assign) BOOL limitAdvertisingIdentifiers;

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 antes del lanzamiento de la app.
• Usuarios COPPA conocidos: Cuando se sabe en el momento de la inicialización que el usuario es menor de 13 años
• Enfoque basado en la privacidad: Aplicar limitaciones de identificadores publicitarios desde la primera sesión del SDK

Método de configuración

Establezca limitaciones de identificadores de publicidad durante la inicialización del SDK para las aplicaciones que conozcan los requisitos de privacidad de antemano.

// Limit advertising identifiers at initialization
let config = SingularConfig(apiKey: "SDK_KEY", andSecret: "SDK_SECRET")
config?.limitAdvertisingIdentifiers = true

Singular.start(config)

// Limit advertising identifiers at initialization
SingularConfig *config = [[SingularConfig alloc] 
    initWithApiKey:@"SDK_KEY" 
    andSecret:@"SDK_SECRET"];
config.limitAdvertisingIdentifiers = YES;

[Singular start:config];

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.

import Foundation

class PrivacyManager {
    
    private let userDefaults = UserDefaults.standard
    private let consentKey = "user_consent"
    private let dataSharingKey = "data_sharing"
    
    // Initialize privacy settings on app start
    func initializePrivacy() {
        let hasUserConsent = getUserConsent()
        let allowDataSharing = getDataSharingPreference()
        
        // Apply stored preferences
        if hasUserConsent {
            Singular.trackingOptIn()
            Singular.resumeAllTracking()
        } else {
            Singular.stopAllTracking()
        }
        
        // Set data sharing preference
        Singular.limitDataSharing(!allowDataSharing)
        
        print("Privacy initialized: consent=\(hasUserConsent), sharing=\(allowDataSharing)")
    }
    
    // User accepts tracking via consent dialog
    func userAcceptedTracking() {
        saveUserConsent(true)
        Singular.trackingOptIn()
        Singular.resumeAllTracking()
        print("User accepted tracking")
    }
    
    // User declines tracking
    func userDeclinedTracking() {
        saveUserConsent(false)
        Singular.stopAllTracking()
        print("User declined tracking")
    }
    
    // User updates data sharing preference
    func setDataSharingEnabled(_ enabled: Bool) {
        saveDataSharingPreference(enabled)
        // Note: limitDataSharing uses inverse logic
        Singular.limitDataSharing(!enabled)
        print("Data sharing: \(enabled ? "Enabled" : "Limited")")
    }
    
    // Get current tracking status
    func isTrackingEnabled() -> Bool {
        return !Singular.isAllTrackingStopped()
    }
    
    // Private helper methods
    private func getUserConsent() -> Bool {
        return userDefaults.bool(forKey: consentKey)
    }
    
    private func saveUserConsent(_ consent: Bool) {
        userDefaults.set(consent, forKey: consentKey)
    }
    
    private func getDataSharingPreference() -> Bool {
        return userDefaults.bool(forKey: dataSharingKey)
    }
    
    private func saveDataSharingPreference(_ enabled: Bool) {
        userDefaults.set(enabled, forKey: dataSharingKey)
    }
}

#import <Foundation/Foundation.h>
#import <Singular/Singular.h>

@interface PrivacyManager : NSObject

- (void)initializePrivacy;
- (void)userAcceptedTracking;
- (void)userDeclinedTracking;
- (void)setDataSharingEnabled:(BOOL)enabled;
- (BOOL)isTrackingEnabled;

@end

@implementation PrivacyManager

static NSString *const kConsentKey = @"user_consent";
static NSString *const kDataSharingKey = @"data_sharing";

// Initialize privacy settings on app start
- (void)initializePrivacy {
    BOOL hasUserConsent = [self getUserConsent];
    BOOL allowDataSharing = [self getDataSharingPreference];
    
    // Apply stored preferences
    if (hasUserConsent) {
        [Singular trackingOptIn];
        [Singular resumeAllTracking];
    } else {
        [Singular stopAllTracking];
    }
    
    // Set data sharing preference
    [Singular limitDataSharing:!allowDataSharing];
    
    NSLog(@"Privacy initialized: consent=%d, sharing=%d", hasUserConsent, allowDataSharing);
}

// User accepts tracking via consent dialog
- (void)userAcceptedTracking {
    [self saveUserConsent:YES];
    [Singular trackingOptIn];
    [Singular resumeAllTracking];
    NSLog(@"User accepted tracking");
}

// User declines tracking
- (void)userDeclinedTracking {
    [self saveUserConsent:NO];
    [Singular stopAllTracking];
    NSLog(@"User declined tracking");
}

// User updates data sharing preference
- (void)setDataSharingEnabled:(BOOL)enabled {
    [self saveDataSharingPreference:enabled];
    // Note: limitDataSharing uses inverse logic
    [Singular limitDataSharing:!enabled];
    NSLog(@"Data sharing: %@", enabled ? @"Enabled" : @"Limited");
}

// Get current tracking status
- (BOOL)isTrackingEnabled {
    return ![Singular isAllTrackingStopped];
}

// Private helper methods
- (BOOL)getUserConsent {
    return [[NSUserDefaults standardUserDefaults] boolForKey:kConsentKey];
}

- (void)saveUserConsent:(BOOL)consent {
    [[NSUserDefaults standardUserDefaults] setBool:consent forKey:kConsentKey];
}

- (BOOL)getDataSharingPreference {
    return [[NSUserDefaults standardUserDefaults] boolForKey:kDataSharingKey];
}

- (void)saveDataSharingPreference:(BOOL)enabled {
    [[NSUserDefaults standardUserDefaults] setBool:enabled forKey:kDataSharingKey];
}

@end