Gérer la collecte de données

Le manifeste de confidentialité d’Apple

Qu’est-ce que les données de suivi ?

Apple définit les « données de suivi » comme des données collectées dans votre application à propos d’un utilisateur final ou d’un appareil, liées à des données third-party (telles que la publicité ciblée) ou à un courtier en données. Pour une définition complète avec des exemples, consultez Apple : Suivi.

Par défaut, le SDK Braze ne collecte pas de données de suivi. Cependant, selon la configuration de votre SDK Braze, vous pourriez être amené à répertorier les données spécifiques à Braze dans le manifeste de confidentialité de votre application.

Qu’est-ce qu’un manifeste de confidentialité ?

Un manifeste de confidentialité est un fichier dans votre projet Xcode qui décrit les raisons pour lesquelles votre application et les SDK tiers collectent des données, ainsi que leurs méthodes de collecte. Chacun de vos SDK tiers qui effectue un suivi des données nécessite son propre manifeste de confidentialité. Lorsque vous créez le rapport de confidentialité de votre application, ces fichiers de manifeste de confidentialité sont automatiquement agrégés en un seul rapport.

Domaines de données de suivi d’API

À partir d’iOS 17.2, Apple bloquera tous les endpoints de suivi déclarés dans votre application jusqu’à ce que l’utilisateur final accepte une invite de transparence du suivi publicitaire (ATT). Braze fournit des endpoints de suivi pour acheminer vos données de suivi, tout en vous permettant d’acheminer les données first-party non liées au suivi vers l’endpoint d’origine.

Déclaration des données de suivi Braze

Conseil

Pour un guide complet, consultez le tutoriel sur les données de suivi de la vie privée.

Prérequis

La version suivante du SDK Braze est requise pour implémenter cette fonctionnalité :

Étape 1 : Examiner vos politiques actuelles

Examinez les politiques actuelles de collecte de données de votre SDK Braze avec votre équipe juridique afin de déterminer si votre application collecte des données de suivi telles que définies par Apple. Si vous ne collectez aucune donnée de suivi, vous n’avez pas besoin de personnaliser votre manifeste de confidentialité pour le SDK Braze pour le moment. Pour plus d’informations sur les politiques de collecte de données du SDK Braze, consultez Collecte de données du SDK.

Important

Si l’un de vos SDK non-Braze collecte des données de suivi, vous devrez examiner ces politiques séparément.

Étape 2 : Créer un manifeste de confidentialité

Tout d’abord, vérifiez si vous disposez déjà d’un manifeste de confidentialité en recherchant un fichier PrivacyInfo.xcprivacy dans votre projet Xcode. Si vous disposez déjà de ce fichier, vous pouvez passer à l’étape suivante. Sinon, consultez Apple : Créer un manifeste de confidentialité.

Étape 3 : Ajouter votre endpoint au manifeste de confidentialité

Dans votre projet Xcode, ouvrez le fichier PrivacyInfo.xcprivacy de votre application, puis faites un clic droit sur le tableau et cochez Raw Keys and Values.

Sous App Privacy Configuration, choisissez NSPrivacyTracking et définissez sa valeur sur YES.

Sous App Privacy Configuration, choisissez NSPrivacyTrackingDomains. Dans le tableau de domaines, ajoutez un nouvel élément et définissez sa valeur sur l’endpoint que vous avez précédemment ajouté à votre AppDelegate préfixé par sdk-tracking.

Étape 4 : Déclarer vos données de suivi

Ensuite, ouvrez AppDelegate.swift puis listez chaque propriété de suivi que vous souhaitez déclarer en créant une liste de suivi statique ou dynamique. Gardez à l’esprit qu’Apple bloquera ces propriétés jusqu’à ce que l’utilisateur final accepte l’invite ATT, donc ne listez que les propriétés que vous et votre équipe juridique considérez comme des données de suivi. Par exemple :

• exemple statique
• exemple dynamique

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]
    )
  }
}

Étape 5 : Empêcher les boucles de tentatives infinies

Pour empêcher le SDK d’entrer dans une boucle de tentatives infinie, utilisez la méthode set(adTrackingEnabled: enableAdTracking) pour gérer les autorisations ATT. La propriété adTrackingEnabled dans votre méthode SceneDelegate.swift doit être gérée de manière similaire à ce qui suit :

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

Désactivation du suivi des données

Pour désactiver l’activité de suivi des données sur le SDK Swift, définissez la propriété enabled sur false dans votre instance Braze. Lorsque enabled est défini sur false, le SDK Braze ignore tous les appels à l’API publique. Le SDK annule également toutes les actions en cours, telles que les requêtes réseau, le traitement des événements, etc.

Effacer les données précédemment stockées

Vous pouvez utiliser la méthode wipeData() pour effacer complètement les données SDK stockées localement sur l’appareil d’un utilisateur.

Pour les versions 7.0.0 et ultérieures de Braze Swift, le SDK et la méthode wipeData() génèrent aléatoirement un UUID pour l’ID de l’appareil. Cependant, si votre useUUIDAsDeviceId est défini sur false ou si vous utilisez la version 5.7.0 ou antérieure du SDK Swift, vous devrez également effectuer une requête POST vers /users/delete car votre identifiant pour les fournisseurs (IDFV) sera automatiquement utilisé comme ID d’appareil de cet utilisateur.

Si vous utilisez l’intégration manuelle des notifications push et que votre application appelle wipeData() puis réactive le SDK au cours de la même exécution de l’application, appelez à nouveau registerForRemoteNotifications() afin que Braze puisse recevoir un jeton d’appareil actualisé. Pour plus d’informations, consultez la section configuration des notifications push.

Reprise du suivi des données

Pour reprendre la collecte de données, définissez enabled sur true. Gardez à l’esprit que cela ne restaurera pas les données précédemment effacées.

Déconnexion et désinscription des notifications push

Le SDK Braze fournit des méthodes pour cesser de cibler un appareil lorsqu’un utilisateur se désinscrit des notifications push ou se déconnecte. Ces méthodes suppriment les données d’inscription push de l’utilisateur actuel sur le serveur Braze et dans le SDK, de sorte que Braze n’envoie plus de futures Campaigns de notifications push à cet utilisateur.

Déconnexion

Lorsqu’un utilisateur se déconnecte d’une application, appelez la méthode logout du SDK pour supprimer l’inscription push de l’appareil de l’utilisateur actuel et effectuer automatiquement des actions de nettoyage dans le SDK. La méthode logout effectue les opérations suivantes :

• Désinscrit le jeton push de l’appareil, ainsi que tous les jetons push-to-start des Live Activities, de l’utilisateur actuel sur le serveur Braze.
• Si l’appel de désinscription réussit, le SDK efface les données SDK stockées localement et désactive le SDK.
• En cas d’échec, une erreur est levée avec un indicateur isRetriable pour permettre à l’intégrateur d’agir.

• 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);
  }
}];

Réactiver le suivi et les notifications push après logout

Après un logout réussi, redéfinissez enabled sur true, puis réinscrivez-vous aux notifications auprès de votre système d’exploitation (OS) ou fournisseur de notifications push en suivant la configuration push Swift.

Éviter les appels de désinscription immédiats

Évitez d’appeler logout ou unregisterPush directement après l’inscription aux notifications push auprès de l’OS ou du fournisseur de notifications push. En raison du traitement asynchrone côté serveur, cela peut dans de rares cas réajouter le jeton push à l’utilisateur Braze.

Désinscription des notifications push

Pour cesser d’envoyer des notifications push à un appareil sans nettoyage automatique supplémentaire, utilisez la méthode unregisterPush. Celle-ci supprime le jeton push de l’appareil de l’utilisateur actuel sur le serveur Braze et efface le jeton stocké localement.

• 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);
  }
}];

Réinscrire les notifications push après unregisterPush

Après avoir appelé unregisterPush, réinscrivez-vous aux notifications auprès de votre OS ou fournisseur de notifications push en suivant la configuration push Swift avant d’envoyer à nouveau des notifications push Braze.

Éviter les appels de désinscription immédiats

Évitez d’appeler logout ou unregisterPush directement après l’inscription aux notifications push auprès de l’OS ou du fournisseur de notifications push. En raison du traitement asynchrone côté serveur, cela peut dans de rares cas réajouter le jeton push à l’utilisateur Braze.

Désinscrire les jetons push-to-start pour les Live Activities

Les Live Activities peuvent être démarrées à distance à l’aide de jetons push-to-start. Pour empêcher Braze de démarrer à distance des Live Activities sur un appareil, appelez la méthode unregisterPushToStart pour désinscrire tous les types actuellement enregistrés (par défaut) ou une liste spécifique de types d’Activity.

Notez que les Live Activities en cours d’exécution continuent de recevoir des mises à jour et que cette méthode supprime uniquement la possibilité de démarrer de nouvelles activités à distance. Pour plus d’informations sur les Live Activities, consultez Live Activities.

Remarque

Évitez d’appeler logout ou unregisterPushToStart directement après avoir appelé registerPushToStart pour une Live Activity. En raison de la nature asynchrone du traitement côté serveur, cela peut dans de rares cas entraîner le réajout du jeton push-to-start à l’utilisateur Braze.

L’exemple suivant montre comment désinscrire tous les types d’activités push-to-start. Utilisez-le lorsqu’un utilisateur déconnecté ne doit plus recevoir de nouvelles Live Activities démarrées à distance.

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

L’exemple suivant montre comment désinscrire des types d’activités spécifiques. Utilisez-le lorsque seules certaines Live Activities doivent cesser d’être démarrées à distance.

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

Remarque

unregisterPushToStart ne dispose pas d’une API Objective-C, car les Live Activities reposent sur des types exclusifs à Swift.

Collecte de l’IDFV

Dans les versions précédentes du SDK iOS de Braze, le champ IDFV (Identifier for Vendor) était automatiquement collecté en tant qu’ID d’appareil de l’utilisateur. À partir du SDK Swift v5.7.0, le champ IDFV pouvait être désactivé de manière optionnelle, et Braze définissait à la place un UUID aléatoire comme ID d’appareil. À partir du SDK Swift v7.0.0, le champ IDFV n’est plus collecté par défaut, et un UUID est défini comme ID d’appareil à la place.

La fonctionnalité useUUIDAsDeviceId configure le SDK Swift pour définir l’ID d’appareil en tant qu’UUID. Traditionnellement, le SDK iOS attribuait à l’ID d’appareil la valeur IDFV générée par Apple. Avec cette fonctionnalité activée par défaut sur votre application iOS, tous les nouveaux utilisateurs créés via le SDK se voient attribuer un ID d’appareil égal à un UUID.

Si vous souhaitez toujours collecter l’IDFV séparément, vous pouvez utiliser set(identifierforvendor:).

Remarque

La lecture de braze.deviceId bloque le thread appelant jusqu’à ce que le SDK ait terminé ses opérations post-initialisation. Pour les contextes sur le thread principal ou sensibles à la latence, utilisez plutôt les alternatives non bloquantes.

• 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);
}];

Considérations

Version du SDK

Dans le SDK Swift v7.0.0+, lorsque useUUIDAsDeviceId est activé (par défaut), tous les nouveaux utilisateurs créés se voient attribuer un ID d’appareil aléatoire. Tous les utilisateurs existants conservent la même valeur d’ID d’appareil, qui peut avoir été l’IDFV.

Lorsque cette fonctionnalité n’est pas activée, les appareils continuent de se voir attribuer l’IDFV lors de leur création.

En aval

Partenaires technologiques : lorsque cette fonctionnalité est activée, les partenaires technologiques qui dérivent la valeur IDFV à partir de l’ID d’appareil Braze n’auront plus accès à cette donnée. Si la valeur IDFV dérivée de l’appareil est nécessaire pour votre intégration partenaire, nous vous recommandons de définir cette fonctionnalité sur false.

Currents : useUUIDAsDeviceId défini sur true signifie que l’ID d’appareil envoyé dans Currents ne sera plus égal à la valeur IDFV.

Questions fréquemment posées

Ce changement aura-t-il un impact sur mes utilisateurs existants dans Braze ?

Non. Lorsqu’elle est activée, cette fonctionnalité n’écrase aucune donnée utilisateur dans Braze. Les nouveaux ID d’appareil UUID ne seront créés que pour les nouveaux appareils ou lorsque wipedata() est appelé.

Puis-je désactiver cette fonctionnalité après l’avoir activée ?

Oui, cette fonctionnalité peut être activée et désactivée à votre convenance. Les ID d’appareil précédemment stockés ne seront jamais écrasés.

Puis-je toujours capturer la valeur IDFV via Braze ailleurs ?

Oui, vous pouvez toujours collecter l’IDFV de manière optionnelle via le SDK Swift (la collecte est désactivée par défaut).