SDK do Cordova - Privacidade de dados

Seguir
Avatar
Jared Ornstead
Updated

Conformidade com as leis de privacidade de dados

Implementar a coleta de dados em conformidade com a privacidade, notificando a Singular das escolhas de consentimento do usuário para GDPR, CCPA, COPPA e outros regulamentos de privacidade do consumidor.

Quando os usuários consentirem ou recusarem o compartilhamento das suas informações com terceiros, utilize os métodos de privacidade da Singular para comunicar a sua escolha. Isto assegura a conformidade com regulamentos como o California Consumer Privacy Act (CCPA)e permite que os parceiros respeitem as preferências de privacidade dos usuários.

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

Limitar o compartilhamento 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: 

cordova.plugins.SingularCordovaSdk.limitDataSharing(
  shouldLimitDataSharing: boolean
): void

Parâmetros:

  • false: O usuário optou e consentiu o compartilhamento dos seus dados
  • true: O usuário optou por não participar e não consente o compartilhamento dos seus dados

Importante: Embora opcional, este método afecta o compartilhamento de dados de atribuição. Alguns parceiros só compartilham informações de atribuição completas quando são explicitamente notificados de que os usuários optaram por participar.

Para obter a documentação completa do método, consulte a referência limitDataSharing.

Exemplos de utilização

Implementar controles de compartilhamento de dados com base nas preferências de privacidade do usuário.

JavaScript 
document.addEventListener('deviceready', onDeviceReady, false);

function onDeviceReady() {
  // User has opted in to share their data
  var onUserOptedInToDataSharing = function() {
    cordova.plugins.SingularCordovaSdk.limitDataSharing(false);
    console.log('Data sharing enabled');
  };
  
  // User has opted out and declined to share their data
  var onUserOptedOutOfDataSharing = function() {
    cordova.plugins.SingularCordovaSdk.limitDataSharing(true);
    console.log('Data sharing limited');
  };
  
  // Set based on user preference
  var handlePrivacyConsent = function(userConsented) {
    // Pass inverse: false = opted in, true = opted out
    cordova.plugins.SingularCordovaSdk.limitDataSharing(!userConsented);
    
    console.log('Data sharing: ' + (userConsented ? 'Enabled' : 'Limited'));
  };
  
  // Example: Ask user for consent
  askUserForPrivacyConsent(function(consented) {
    handlePrivacyConsent(consented);
  });
}

function askUserForPrivacyConsent(callback) {
  // Show custom dialog to user
  if (confirm('Do you consent to share your data with third parties?')) {
    callback(true);
  } else {
    callback(false);
  }
}

Como funciona:

A Singular usa essa configuração em Postbacks de privacidade do usuárioe a passa para parceiros que a exigem para conformidade regulatória.

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 rastreamento

TrackingOptIn

Registra o consentimento explícito do usuário para o rastreamento, enviando um evento GDPR opt-in para os servidores Singular.

Assinatura do método: 

cordova.plugins.SingularCordovaSdk.trackingOptIn(): void

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 registra especificamente o consentimento

Para obter a documentação completa do método, consulte a referência trackingOptIn.

Exemplo de implementação

Chame trackingOptIn() depois de os usuários aceitarem o consentimento de rastreamento através da caixa de diálogo de consentimento do seu aplicativo.

JavaScript 
document.addEventListener('deviceready', initializeGDPR, false);

function initializeGDPR() {
  checkStoredConsent();
}

function checkStoredConsent() {
  // Check if user has previously provided consent
  var consent = localStorage.getItem('gdpr_consent');
  
  if (consent === null) {
    // No stored preference - show consent dialog
    showGDPRConsentDialog();
  } else if (consent === 'true') {
    // User previously consented - apply setting
    onUserAcceptedTracking();
  }
}

function showGDPRConsentDialog() {
  // Show custom dialog to user
  var message = 'We would like your permission to track app usage and improve your experience.';
  
  if (confirm(message)) {
    onUserAcceptedTracking();
  } else {
    onUserDeclinedTracking();
  }
}

function onUserAcceptedTracking() {
  // Record user consent with Singular
  cordova.plugins.SingularCordovaSdk.trackingOptIn();
  console.log('User opted in to tracking');
  
  // Save preference locally
  localStorage.setItem('gdpr_consent', 'true');
}

function onUserDeclinedTracking() {
  console.log('User declined tracking');
  localStorage.setItem('gdpr_consent', 'false');
}

Métodos de controle de rastreamento

StopAllTracking

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

Assinatura do método: 

cordova.plugins.SingularCordovaSdk.stopAllTracking(): void

Crítico Aviso: Este método desativa permanentemente o SDK até que resumeAllTracking() seja chamado. O estado de desativação persiste durante as reinicializações do aplicativo 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 o aplicativo ser fechado e reaberto
  • Sem reinicialização automática: Tem de chamar explicitamente resumeAllTracking() para voltar a ativar

Para obter a documentação completa do método, consulte a referência stopAllTracking.

Exemplo de implementação

Parar o rastreamento quando os usuários recusam o consentimento ou optam por sair através das configurações de privacidade.

JavaScript 
// User declined all tracking
function onUserDeclinedTracking() {
  cordova.plugins.SingularCordovaSdk.stopAllTracking();
  console.log('All tracking stopped');
  
  // Store preference
  localStorage.setItem('tracking_enabled', 'false');
}

// Handle user opt-out from settings menu
function handlePrivacySettingsChange(trackingEnabled) {
  if (!trackingEnabled) {
    cordova.plugins.SingularCordovaSdk.stopAllTracking();
    console.log('Privacy settings: Tracking disabled');
    localStorage.setItem('tracking_enabled', 'false');
  }
}

RetomarTudoRastreio

Reativar o rastreamento depois de ter sido interrompido com stopAllTracking().

Assinatura do método: 

cordova.plugins.SingularCordovaSdk.resumeAllTracking(): void

Casos de utilização:

  • Alteração de consentimento: O usuário altera as preferências de privacidade e volta a optar pelo rastreamento
  • Configurações de privacidade: O usuário atualiza o consentimento através do menu de configurações do aplicativo
  • Conformidade regional: Voltar a ativar o rastreamento quando o usuário se desloca para regiões não regulamentadas

Para obter a documentação completa do método, consulte a referência resumeAllTracking.

Exemplo de implementação

Retomar o rastreamento quando os usuários optarem por voltar a participar ou atualizarem as suas preferências de privacidade.

JavaScript 
// User opted back in to tracking
function onUserResumedTracking() {
  cordova.plugins.SingularCordovaSdk.resumeAllTracking();
  console.log('Tracking resumed');
  
  // Update stored preference
  localStorage.setItem('tracking_enabled', 'true');
}

// Handle consent update from settings
function handlePrivacySettingsChange(trackingEnabled) {
  if (trackingEnabled) {
    cordova.plugins.SingularCordovaSdk.resumeAllTracking();
    console.log('Privacy settings: Tracking enabled');
    localStorage.setItem('tracking_enabled', 'true');
  }
}

IsAllTrackingStopped

Verificar se o rastreamento foi desativado para o usuário atual.

Assinatura do método: 

cordova.plugins.SingularCordovaSdk.isAllTrackingStopped(
  success: Function
): void

Retorna:

  • true: O rastreamento está atualmente parado através de stopAllTracking()
  • false: O rastreamento está ativo (nunca foi parado ou retomado)

Para obter a documentação completa do método, consulte a referência isAllTrackingStopped.

Exemplo de implementação

Verificar o estado do rastreamento para sincronizar o estado da IU com o estado do rastreamento do SDK.

JavaScript 
document.addEventListener('deviceready', initializePrivacyUI, false);

function initializePrivacyUI() {
  updatePrivacyUI();
}

// Check current tracking status
function isTrackingEnabled(callback) {
  cordova.plugins.SingularCordovaSdk.isAllTrackingStopped(function(isStopped) {
    callback(!isStopped);
  });
}

// Display privacy status in settings
function getPrivacyStatusText(callback) {
  cordova.plugins.SingularCordovaSdk.isAllTrackingStopped(function(isStopped) {
    var text = isStopped ? 'Tracking: Disabled' : 'Tracking: Enabled';
    callback(text);
  });
}

// Sync UI with tracking state
function updatePrivacyUI() {
  cordova.plugins.SingularCordovaSdk.isAllTrackingStopped(function(isStopped) {
    var statusElement = document.getElementById('tracking-status');
    var toggleElement = document.getElementById('tracking-toggle');
    
    if (statusElement) {
      statusElement.textContent = isStopped ? 'Tracking: Disabled' : 'Tracking: Enabled';
    }
    
    if (toggleElement) {
      toggleElement.checked = !isStopped;
    }
    
    console.log('Current tracking state: ' + (isStopped ? 'Stopped' : 'Active'));
  });
}

// Handle toggle change from UI
function onTrackingToggleChanged(enabled) {
  if (enabled) {
    cordova.plugins.SingularCordovaSdk.resumeAllTracking();
  } else {
    cordova.plugins.SingularCordovaSdk.stopAllTracking();
  }
  
  updatePrivacyUI();
}

Proteção da privacidade das crianças

Implemente a conformidade com a COPPA (Children's Online Privacy Protection Act) e proteja a privacidade das crianças notificando a Singular quando os usuários tiverem menos de 13 anos de idade.

TrackingUnder13

Habilitar proteções de privacidade para crianças

Notifica a Singular que o usuário tem menos de 13 anos de idade para estar em conformidade com a COPPA e outras regulamentações de privacidade infantil.

Assinatura do método: 

cordova.plugins.SingularCordovaSdk.trackingUnder13(): void

Requisitos de conformidade:

  • Conformidade com a COPPA: Necessário para aplicativos que coletam dados de crianças menores de 13 anos nos Estados Unidos
  • Conteúdo com limite de idade: Utilizar quando os usuários se identificam como tendo menos de 13 anos durante o registro ou a verificação da idade
  • Rastreamento restrito: Limita a coleta de dados para cumprir as leis de proteção da privacidade das crianças

Para obter a documentação completa do método, consulte a referência trackingUnder13.

Exemplo de implementação

Chamar trackingUnder13() imediatamente após determinar que o usuário tem menos de 13 anos através da verificação da idade.

JavaScript 
document.addEventListener('deviceready', initializeCOPPA, false);

function initializeCOPPA() {
  // Check if user's age was previously verified
  var ageCategory = localStorage.getItem('user_age_category');
  
  if (ageCategory === 'under_13') {
    applyChildPrivacyProtections();
  }
}

// User identified as under 13
function onUserUnder13() {
  cordova.plugins.SingularCordovaSdk.trackingUnder13();
  console.log('COPPA mode enabled for user under 13');
  
  // Store age category for app restart
  localStorage.setItem('user_age_category', 'under_13');
}

// Call after age verification
function onAgeVerified(userAge) {
  if (userAge < 13) {
    cordova.plugins.SingularCordovaSdk.trackingUnder13();
    console.log('COPPA restrictions applied');
    
    // Also limit advertising identifiers
    cordova.plugins.SingularCordovaSdk.setLimitAdvertisingIdentifiers(true);
    
    localStorage.setItem('user_age_category', 'under_13');
    
    alert('Special privacy protections have been applied to your account.');
  } else {
    localStorage.setItem('user_age_category', 'adult');
    console.log('Adult account - standard tracking');
  }
}

// Example: Age verification form
function handleAgeSubmit() {
  var ageInput = document.getElementById('age-input');
  var userAge = parseInt(ageInput.value, 10);
  
  if (isNaN(userAge) || userAge < 1 || userAge > 120) {
    alert('Please enter a valid age.');
    return;
  }
  
  onAgeVerified(userAge);
}

// Apply all child privacy protections
function applyChildPrivacyProtections() {
  cordova.plugins.SingularCordovaSdk.trackingUnder13();
  cordova.plugins.SingularCordovaSdk.setLimitAdvertisingIdentifiers(true);
  console.log('Child privacy protections applied');
}

Melhores práticas: Chamar trackingUnder13()o mais cedo possível depois de determinar a idade do usuário. Combine com setLimitAdvertisingIdentifiers(true) para uma proteção abrangente da privacidade das crianças.

Implementação completa da privacidade

Implemente uma gestão de privacidade abrangente que cubra a conformidade com o RGPD, a CCPA e a COPPA com armazenamento persistente e sincronização da IU.

Exemplo de implementação completa

Módulo de gestão de privacidade

Crie um módulo de gestão de privacidade reutilizável que trata de toda a inicialização e persistência das configurações de privacidade.

JavaScript 
// Privacy Manager Module
var PrivacyManager = {
  // Storage keys
  PREF_USER_CONSENT: 'privacy_user_consent',
  PREF_DATA_SHARING: 'privacy_data_sharing',
  PREF_AGE_CATEGORY: 'user_age_category',
  
  /**
   * Initialize privacy settings on app startup
   */
  initialize: function() {
    var hasUserConsent = this.getUserConsent();
    var allowDataSharing = this.getDataSharingPreference();
    var ageCategory = this.getAgeCategory();
    
    // Apply age-based restrictions first
    if (ageCategory === 'under_13') {
      cordova.plugins.SingularCordovaSdk.trackingUnder13();
      cordova.plugins.SingularCordovaSdk.setLimitAdvertisingIdentifiers(true);
      console.log('COPPA restrictions applied on startup');
    }
    
    // Apply stored tracking preference
    if (hasUserConsent) {
      cordova.plugins.SingularCordovaSdk.trackingOptIn();
      cordova.plugins.SingularCordovaSdk.resumeAllTracking();
      console.log('Privacy initialized: Tracking enabled with consent');
    } else {
      cordova.plugins.SingularCordovaSdk.stopAllTracking();
      console.log('Privacy initialized: Tracking disabled');
    }
    
    // Set data sharing preference (inverse logic)
    cordova.plugins.SingularCordovaSdk.limitDataSharing(!allowDataSharing);
    
    console.log('Privacy initialized: consent=' + hasUserConsent + ', sharing=' + allowDataSharing);
  },
  
  /**
   * User accepts tracking via consent dialog
   */
  onUserAcceptedTracking: function() {
    this.saveUserConsent(true);
    
    cordova.plugins.SingularCordovaSdk.trackingOptIn();
    cordova.plugins.SingularCordovaSdk.resumeAllTracking();
    
    console.log('User accepted tracking');
  },
  
  /**
   * User declines tracking
   */
  onUserDeclinedTracking: function() {
    this.saveUserConsent(false);
    
    cordova.plugins.SingularCordovaSdk.stopAllTracking();
    
    console.log('User declined tracking');
  },
  
  /**
   * User updates data sharing preference
   */
  setDataSharingEnabled: function(enabled) {
    this.saveDataSharingPreference(enabled);
    
    // Note: LimitDataSharing uses inverse logic
    // false = data sharing enabled, true = data sharing limited
    cordova.plugins.SingularCordovaSdk.limitDataSharing(!enabled);
    
    console.log('Data sharing: ' + (enabled ? 'Enabled' : 'Limited'));
  },
  
  /**
   * Check if tracking is currently enabled
   */
  isTrackingEnabled: function(callback) {
    cordova.plugins.SingularCordovaSdk.isAllTrackingStopped(function(isStopped) {
      callback(!isStopped);
    });
  },
  
  /**
   * Get current privacy status as readable text
   */
  getPrivacyStatus: function(callback) {
    var self = this;
    
    this.isTrackingEnabled(function(isEnabled) {
      var dataSharingEnabled = self.getDataSharingPreference();
      var ageCategory = self.getAgeCategory();
      
      var status = 'Tracking: ' + (isEnabled ? 'Enabled' : 'Disabled') + '\n';
      status += 'Data Sharing: ' + (dataSharingEnabled ? 'Enabled' : 'Limited');
      
      if (ageCategory === 'under_13') {
        status += '\nCOPPA: Restrictions Applied';
      }
      
      callback(status);
    });
  },
  
  /**
   * Set user's age and apply appropriate protections
   */
  setUserAge: function(age) {
    if (age < 13) {
      cordova.plugins.SingularCordovaSdk.trackingUnder13();
      cordova.plugins.SingularCordovaSdk.setLimitAdvertisingIdentifiers(true);
      localStorage.setItem(this.PREF_AGE_CATEGORY, 'under_13');
      console.log('Age set to under 13 - COPPA protections applied');
    } else {
      localStorage.setItem(this.PREF_AGE_CATEGORY, 'adult');
      console.log('Age set to adult - standard tracking');
    }
  },
  
  // Private helper methods
  getUserConsent: function() {
    var value = localStorage.getItem(this.PREF_USER_CONSENT);
    return value === 'true';
  },
  
  saveUserConsent: function(consent) {
    localStorage.setItem(this.PREF_USER_CONSENT, consent.toString());
  },
  
  getDataSharingPreference: function() {
    var value = localStorage.getItem(this.PREF_DATA_SHARING);
    return value === 'true';
  },
  
  saveDataSharingPreference: function(enabled) {
    localStorage.setItem(this.PREF_DATA_SHARING, enabled.toString());
  },
  
  getAgeCategory: function() {
    return localStorage.getItem(this.PREF_AGE_CATEGORY);
  }
};

// Initialize on device ready
document.addEventListener('deviceready', function() {
  PrivacyManager.initialize();
}, false);

Principais diretrizes de implementação

Práticas recomendadas:

  • Armazenamento persistente: Guarde as preferências do usuário utilizando o localStorage ou uma solução de armazenamento segura
  • Inicialização antecipada: Aplicar as configurações de privacidade imediatamente após a inicialização do SDK
  • Sincronização da IU: Manter as configurações da IU sincronizadas com o estado atual do SDK utilizando isAllTrackingStopped()
  • Comunicação clara: Fornecer controles de privacidade claros e acessíveis nas configurações do aplicativo
  • Lógica inversa: Lembre-se que limitDataSharing(false) significa que o compartilhamento de dados está ativado, enquanto true significa que está limitado
  • Prioridade COPPA: Aplicar as proteções de privacidade das crianças (trackingUnder13()) antes de outras configurações de privacidade
  • Documentação de conformidade: Manter registros de quando e como os usuários fornecem ou revogam o consentimento

Lista de controle de verificação

Certifique-se de que a implementação da privacidade cumpre os requisitos de conformidade:

  1. Coleta de consentimento: É solicitado o consentimento explícito dos usuários antes do início do rastreamento
  2. Registro do consentimento: Chamada para trackingOptIn()quando os usuários fornecem o consentimento do RGPD
  3. Controles de compartilhamento de dados: Utilizar limitDataSharing() para comunicar as preferências dos usuários aos parceiros
  4. Mecanismo de auto-exclusão: Os usuários podem parar o rastreamento através de stopAllTracking() nas configurações de privacidade
  5. Verificação de idade: Implementar portas de idade e ligar para trackingUnder13() para crianças
  6. Configurações persistentes: As preferências de privacidade são guardadas e reaplicadas ao reiniciar o aplicativo
  7. Transparência da interface do usuário: A tela das configurações de privacidade apresenta claramente o estado atual do rastreamento