Gerenciar a coleta de dados

Manifesto de privacidade da Apple

O que são dados de rastreamento?

A Apple define “dados de rastreamento” como os dados coletados em seu app sobre um usuário final ou dispositivo que estão vinculados a dados de terceiros (como publicidade direcionada) ou a um corretor de dados. Para uma definição completa com exemplos, consulte Apple: Rastreamento.

Por padrão, o SDK da Braze não coleta dados de rastreamento. No entanto, dependendo da configuração do SDK da Braze, talvez seja necessário listar dados específicos da Braze no manifesto de privacidade do seu app.

O que é um manifesto de privacidade?

Um manifesto de privacidade é um arquivo em seu projeto Xcode que descreve o motivo pelo qual seu app e SDKs de terceiros coletam dados, juntamente com seus métodos de coleta de dados. Cada um dos seus SDKs de terceiros que rastreiam dados exige seu próprio manifesto de privacidade. Quando você cria o relatório de privacidade do seu app, esses arquivos de manifesto de privacidade são automaticamente agregados em um único relatório.

Domínios de dados de rastreamento da API

A partir do iOS 17.2, a Apple bloqueará todos os endpoints de rastreamento declarados em seu app até que o usuário final aceite um aviso de Transparência de Rastreamento de Anúncios (ATT). A Braze fornece endpoints de rastreamento para encaminhar seus dados de rastreamento e, ao mesmo tempo, permite que você encaminhe dados primários que não sejam de rastreamento para o endpoint original.

Declarando dados de rastreamento da Braze

Dica

Para um passo a passo completo, consulte o tutorial de dados de rastreamento de privacidade.

Pré-requisitos

A seguinte versão do SDK da Braze é necessária para implementar este recurso:

Etapa 1: Revise suas políticas atuais

Revise as políticas atuais de coleta de dados do SDK da Braze com sua equipe jurídica para determinar se o seu app coleta dados de rastreamento conforme definido pela Apple. Se você não estiver coletando nenhum dado de rastreamento, não é necessário personalizar o manifesto de privacidade para o SDK da Braze neste momento. Para saber mais sobre as políticas de coleta de dados do SDK da Braze, consulte Coleta de dados do SDK.

Importante

Se algum dos seus SDKs que não são da Braze coletar dados de rastreamento, você precisará revisar essas políticas separadamente.

Etapa 2: Crie um manifesto de privacidade

Primeiro, verifique se você já possui um manifesto de privacidade procurando um arquivo PrivacyInfo.xcprivacy no seu projeto Xcode. Se você já tiver esse arquivo, pode continuar para a próxima etapa. Caso contrário, consulte Apple: Criar um manifesto de privacidade.

Etapa 3: Adicione seu endpoint ao manifesto de privacidade

No seu projeto Xcode, abra o arquivo PrivacyInfo.xcprivacy do seu app, clique com o botão direito na tabela e marque Raw Keys and Values.

Em App Privacy Configuration, escolha NSPrivacyTracking e defina seu valor como YES.

Em App Privacy Configuration, escolha NSPrivacyTrackingDomains. No array de domínios, adicione um novo elemento e defina seu valor como o endpoint que você adicionou anteriormente ao seu AppDelegate com o prefixo sdk-tracking.

Etapa 4: Declare seus dados de rastreamento

Em seguida, abra o AppDelegate.swift e liste cada propriedade de rastreamento que você deseja declarar, criando uma lista de rastreamento estática ou dinâmica. Lembre-se de que a Apple bloqueará essas propriedades até que o usuário final aceite o prompt de ATT, então liste apenas as propriedades que você e sua equipe jurídica consideram como dados de rastreamento. Por exemplo:

• exemplo estático
• exemplo dinâmico

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import UIKit
import BrazeKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

  static var braze: Braze? = nil

  func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    let configuration = Braze.Configuration(apiKey: brazeApiKey, endpoint: brazeEndpoint)
    // Declare which types of data you wish to collect for user tracking.
    configuration.api.trackingPropertyAllowList = [
      .dateOfBirth,
      .customEvent(["event-1"]),
      .customAttribute(["attribute-1", "attribute-2"])
    ]
    let braze = Braze(configuration: configuration)
    AppDelegate.braze = braze
    return true
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func sceneDidBecomeActive(_ scene: UIScene) {
  // Request and check your user's tracking authorization status.
  ATTrackingManager.requestTrackingAuthorization { status in
    // Let Braze know whether user data is allowed to be collected for tracking.
    let enableAdTracking = status == .authorized
    AppDelegate.braze?.set(adTrackingEnabled: enableAdTracking)

    // Add the `.firstName` and `.lastName` properties, while removing the `.everything` configuration.
    AppDelegate.braze?.updateTrackingAllowList(
      adding: [.firstName, .lastName],
      removing: [.everything]
    )
  }
}

Etapa 5: Evite loops infinitos de tentativas

Para evitar que o SDK entre em um loop infinito de tentativas, use o método set(adTrackingEnabled: enableAdTracking) para lidar com as permissões de ATT. A propriedade adTrackingEnabled no método do seu SceneDelegate.swift deve ser tratada de forma semelhante ao seguinte:

1
2
3
4
5
6
7
8
func sceneDidBecomeActive(_ scene: UIScene) {
    // Request and check your user's tracking authorization status.
    ATTrackingManager.requestTrackingAuthorization { status in
      // Let Braze know whether user data is allowed to be collected for tracking.
      let enableAdTracking = status == .authorized
      AppDelegate.braze?.set(adTrackingEnabled: enableAdTracking)
    }
}

Desativando o rastreamento de dados

Para desativar a atividade de rastreamento de dados no SDK Swift, defina a propriedade enabled como false na sua instância da Braze. Quando enabled é definido como false, o SDK da Braze ignora todas as chamadas à API pública. O SDK também cancela todas as ações em andamento, como solicitações de rede, processamento de eventos, etc.

Limpando dados armazenados anteriormente

Você pode usar o método wipeData() para limpar completamente os dados do SDK armazenados localmente no dispositivo de um usuário.

Para versões 7.0.0 e posteriores do Braze Swift, o SDK e o método wipeData() geram aleatoriamente um UUID para o ID do dispositivo. No entanto, se o seu useUUIDAsDeviceId estiver definido como false ou se você estiver usando a versão 5.7.0 ou anterior do Swift SDK, também será necessário fazer uma solicitação POST para /users/delete, pois o Identifier for Vendors (IDFV) será automaticamente usado como o ID do dispositivo desse usuário.

Se você usa integração manual de push e seu app chama wipeData() e depois reativa o SDK na mesma execução do app, chame registerForRemoteNotifications() novamente para que a Braze possa receber um token de dispositivo atualizado. Para saber mais, consulte configuração de notificações por push.

Retomando o rastreamento de dados

Para retomar a coleta de dados, defina enabled como true. Lembre-se de que isso não recuperará nenhum dado previamente apagado.

Logout e cancelamento de registro de push

O SDK da Braze fornece métodos para parar de direcionar um dispositivo quando um usuário cancela o registro de notificações por push ou faz logout. Esses métodos removem os dados de registro de push do usuário atual no servidor da Braze e no SDK, de modo que a Braze não envie mais Campaigns de notificação por push futuras para esse usuário.

Logout

Quando um usuário faz logout de um aplicativo, chame o método logout do SDK para remover o registro de push do dispositivo do usuário atual e executar automaticamente ações de limpeza no SDK. O método logout realiza o seguinte:

• Cancela o registro do token de push do dispositivo e de quaisquer tokens push-to-start de Live Activities do usuário atual no servidor da Braze.
• Se a chamada de cancelamento de registro for bem-sucedida, o SDK limpa os dados do SDK armazenados localmente e desativa o SDK.
• Em caso de falha, gera um erro e um sinalizador isRetriable para permitir que o integrador tome uma ação.

• swift
• objective-c

1
2
3
4
5
6
7
8
9
// Completion handler
AppDelegate.braze?.logout { result in
  switch result {
  case .success:
    print("Logout successful")
  case .failure(let error):
    print("Logout failed: \(error.message), isRetriable: \(error.isRetriable)")
  }
}

1
2
3
4
5
6
7
// Async/await
do {
  try await AppDelegate.braze?.logout()
  print("Logout successful")
} catch let error as Braze.LogoutErrorResult {
  print("Logout failed: \(error.message), isRetriable: \(error.isRetriable)")
}

1
2
3
4
5
6
[AppDelegate.braze logoutWithCompletion:^(NSError * _Nullable error) {
  if (error) {
    NSNumber *isRetriable = error.userInfo[BRZLogoutErrorUserInfoKey.isRetriable];
    NSLog(@"Logout failed: %@, isRetriable=%@", error.localizedDescription, isRetriable);
  }
}];

Reativar rastreamento e push após logout

Após um logout bem-sucedido, defina enabled de volta para true e, em seguida, registre-se novamente para notificações com o seu sistema operacional (SO) ou provedor de push seguindo a configuração de push para Swift.

Evite chamadas imediatas de cancelamento de registro

Evite chamar logout ou unregisterPush diretamente após registrar-se para notificações por push com o SO ou provedor de push. Devido ao processamento assíncrono do servidor, isso pode, em casos raros, readicionar o token de push ao usuário da Braze.

Cancelar registro de push

Para parar de enviar push para um dispositivo sem limpeza automatizada adicional, use o método unregisterPush. Isso remove o token de push do dispositivo do usuário atual no servidor da Braze e limpa o token armazenado localmente.

• swift
• objective-c

1
2
3
4
5
6
7
8
9
// Completion handler
AppDelegate.braze?.notifications.unregisterPush { result in
  switch result {
  case .success:
    print("Push unregistered successfully")
  case .failure(let error):
    print("Push unregistration failed: \(error.message), isRetriable: \(error.isRetriable)")
  }
}

1
2
3
4
5
6
7
// Async/await
do {
  try await AppDelegate.braze?.notifications.unregisterPush()
  print("Push unregistered successfully")
} catch let error as Braze.PushUnregistrationError {
  print("Push unregistration failed: \(error.message), isRetriable: \(error.isRetriable)")
}

1
2
3
4
5
6
7
8
[AppDelegate.braze.notifications unregisterPushWithCompletion:^(NSError * _Nullable error) {
  if (error) {
    NSNumber *isRetriable = error.userInfo[BRZPushUnregistrationErrorUserInfoKey.isRetriable];
    NSNumber *statusCode = error.userInfo[BRZPushUnregistrationErrorUserInfoKey.httpStatusCode];
    NSLog(@"Push unregistration failed: %@, isRetriable=%@ status=%@",
          error.localizedDescription, isRetriable, statusCode);
  }
}];

Registrar push novamente após unregisterPush

Após chamar unregisterPush, registre-se novamente para notificações com o seu SO ou provedor de push seguindo a configuração de push para Swift antes de enviar notificações por push da Braze novamente.

Evite chamadas imediatas de cancelamento de registro

Evite chamar logout ou unregisterPush diretamente após registrar-se para notificações por push com o SO ou provedor de push. Devido ao processamento assíncrono do servidor, isso pode, em casos raros, readicionar o token de push ao usuário da Braze.

Cancelar registro de tokens push-to-start para Live Activities

Live Activities podem ser iniciadas remotamente usando tokens push-to-start. Para impedir que a Braze inicie remotamente Live Activities em um dispositivo, chame o método unregisterPushToStart para cancelar o registro de todos os tipos registrados atualmente (padrão) ou de uma lista específica de tipos de Activity.

Observe que Live Activities em execução continuam recebendo atualizações e que este método apenas remove a capacidade de iniciar novas atividades remotamente. Para saber mais sobre Live Activities, consulte Live Activities.

Nota

Evite chamar logout ou unregisterPushToStart diretamente após chamar registerPushToStart para uma Live Activity. Devido à natureza assíncrona do processamento do servidor, em casos raros, isso pode levar à readição do token push-to-start ao usuário da Braze.

O exemplo a seguir mostra como cancelar o registro de todos os tipos de atividade push-to-start. Use-o quando um usuário desconectado não deve mais receber novas Live Activities iniciadas remotamente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Unregister all currently-registered activity types
// Completion handler
AppDelegate.braze?.liveActivities.unregisterPushToStart { result in
  switch result {
  case .success:
    print("Push-to-start unregistered successfully")
  case .failure(let error):
    print("Push-to-start unregistration failed: \(error.message), isRetriable: \(error.isRetriable)")
  }
}

// Async/await
do {
  try await AppDelegate.braze?.liveActivities.unregisterPushToStart()
  print("Push-to-start unregistered successfully")
} catch let error as Braze.PushUnregistrationError {
  print("Push-to-start unregistration failed: \(error.message), isRetriable: \(error.isRetriable)")
}

O exemplo a seguir mostra como cancelar o registro de tipos de atividade específicos. Use-o quando apenas Live Activities selecionadas devem parar de ser iniciadas remotamente.

1
2
3
4
5
6
7
8
9
// Unregister specific activity types
AppDelegate.braze?.liveActivities.unregisterPushToStart(types: ["ActivityType1", "ActivityType2"]) { result in
  switch result {
  case .success:
    print("Push-to-start unregistered successfully")
  case .failure(let error):
    print("Push-to-start unregistration failed: \(error.message), isRetriable: \(error.isRetriable)")
  }
}

Nota

unregisterPushToStart não possui uma API em Objective-C, pois Live Activities dependem de tipos exclusivos do Swift.

Coleta de IDFV

Em versões anteriores do SDK da Braze para iOS, o campo IDFV (Identifier for Vendor) era coletado automaticamente como o ID do dispositivo do usuário. A partir do Swift SDK v5.7.0, o campo IDFV passou a poder ser desativado opcionalmente, e a Braze passaria a definir um UUID aleatório como o ID do dispositivo. A partir do Swift SDK v7.0.0, o campo IDFV não será mais coletado por padrão, e um UUID será definido como o ID do dispositivo.

O recurso useUUIDAsDeviceId configura o Swift SDK para definir o ID do dispositivo como um UUID. Tradicionalmente, o SDK para iOS atribuía ao ID do dispositivo o valor IDFV gerado pela Apple. Com esse recurso ativado por padrão no seu app iOS, todos os novos usuários criados pelo SDK receberão um ID de dispositivo igual a um UUID.

Se você ainda quiser coletar o IDFV separadamente, pode usar set(identifierforvendor:).

Nota

A leitura de braze.deviceId bloqueia a thread de chamada até que o SDK conclua suas operações pós-inicialização. Para contextos na thread principal ou sensíveis à latência, use as alternativas não bloqueantes.

• swift
• objective-c

1
2
3
4
5
6
7
// Completion handler — always delivers on the main thread.
AppDelegate.braze?.getDeviceId { deviceId in
  print("Device ID:", deviceId)
}

// Async/await (iOS 13.0+, tvOS 13.0+, watchOS 6.0+, macOS 10.15+)
let deviceId = await AppDelegate.braze?.getDeviceId()

1
2
3
4
// Completion handler — always delivers on the main thread.
[AppDelegate.braze getDeviceIdWithCompletion:^(NSString *deviceId) {
  NSLog(@"Device ID: %@", deviceId);
}];

Considerações

Versão do SDK

No Swift SDK v7.0.0+, quando useUUIDAsDeviceId está ativado (padrão), todos os novos usuários criados receberão um ID de dispositivo aleatório. Todos os usuários existentes manterão o mesmo valor de ID de dispositivo, que pode ter sido o IDFV.

Quando esse recurso não está ativado, os dispositivos continuarão recebendo o IDFV na criação.

Impactos posteriores

Parceiros de tecnologia: quando esse recurso está ativado, qualquer parceiro de tecnologia que derive o valor do IDFV a partir do ID de dispositivo da Braze não terá mais acesso a esse dado. Se o valor do IDFV derivado do dispositivo for necessário para sua integração com parceiros, recomendamos definir esse recurso como false.

Currents: useUUIDAsDeviceId definido como true significa que o ID de dispositivo enviado no Currents não será mais igual ao valor do IDFV.

Perguntas frequentes

Essa mudança afetará meus usuários existentes na Braze?

Não. Quando ativado, esse recurso não sobrescreverá nenhum dado de usuário na Braze. Novos IDs de dispositivo UUID serão criados apenas para novos dispositivos ou quando wipedata() for chamado.

Posso desativar esse recurso depois de ativá-lo?

Sim, esse recurso pode ser ativado e desativado conforme sua necessidade. IDs de dispositivo armazenados anteriormente nunca serão sobrescritos.

Ainda posso capturar o valor do IDFV pela Braze de outra forma?

Sim, você ainda pode coletar opcionalmente o IDFV pelo Swift SDK (a coleta é desativada por padrão).