ConsentManager SDK GDPR / CCPA pour iOS

La solution ConsentManager Le SDK pour les applications iOS implémente et fournit des fonctionnalités pour informer l'utilisateur sur la protection des données et demander et recueillir le consentement de l'utilisateur. Il permet aux développeurs d'applications d'intégrer facilement le ConsentManager service dans leur application.

Normes prises en charge

La solution ConsentManager Le SDK GDPR / CCPA pour Android prend en charge les normes industrielles suivantes:

• TCF de l'IAB v1
• TCF de l'IAB v2
• IAB USPrivacy v1
• ConsentManager fournisseurs / objectifs personnalisés
• Mode de consentement supplémentaire Google (chaîne Google AC)

Comment ça marche

1. Intégrez le SDK dans l'application et configurez les paramètres du SDK
2. Une fois le SDK intégré dans une application, le SDK fournira des fonctions au développeur de l'application afin de récupérer les données de consentement
3. Dès que l'application démarre, le SDK récupère automatiquement les informations du ConsentManager serveurs afin de préparer le SDK à son utilisation.
4. Il est recommandé qu'au démarrage de l'application, l'application crée une instance de classe CMPConsentTool. Une fois le fichier créé, le SDK affichera automatiquement l'écran de consentement si nécessaire.
5. Lorsque l'application souhaite traiter des données personnelles, elle doit «demander» au SDK si le consentement a été donné pour l'objectif et le fournisseur spécifiques.

Installation via Cocoapod

Ajouter une bibliothèque avec Cocoapod

Vous pouvez installer le consentmanager SDK en ajoutant consentmanager à votre Podfile comme expliqué dans l'exemple ci-dessous:

target 'YourProject' do
  # Comment the next line if you don't want to use dynamic frameworks
  use_frameworks!
  pod 'CmpSdk'

  target 'YourProjectTests' do
    inherit! :search_paths
     # Pods for testing
  end
  
...
      
end

Une fois que cela est fait, vous devez exécuter pod install dans le répertoire de votre projet pour installer le consentmanager SDK. Après cela, veuillez ouvrir le *.xcworkspace et construire. 

Après avoir suivi toutes les étapes, votre dépendance doit être installée et vous pouvez continuer et l'utiliser dans votre projet.

Installation via XCFramework

Nous vous recommandons vivement d'installer et d'utiliser la bibliothèque avec Cocoapod. Sans cela, il sera plus difficile à maintenir pour l'utilisateur ainsi que pour le développeur. De cette façon, les mises à jour doivent être intégrées manuellement et il existe des problèmes de contrôle de version. Par conséquent, nous prévoyons d'arrêter le service actif pour cette bibliothèque. 

Télécharger le SDK

Veuillez télécharger la dernière version du SDK ici:

Cadre XCF : https://bitbucket.org/consentmanager/consentmanager-xcframework/src/master/

Le SDK est configuré pour iOS version 10 et supérieure.

Intégration

Afin d'intégrer le SDK dans votre projet existant, veuillez suivre ces étapes:

1. Tirez les fichiers du dossier ConsentManager.framework dans le dossier principal de votre application:
   

   
   
   

2. Cliquez sur votre projet et allez dans l'onglet Généralités et développez la pièce sous Cadres, bibliothèques et contenu intégré:
   

   

    

3. Si le module n'est pas encore intégré, cliquez sur + (Plus)> Ajouter autre> Ajouter des fichiers ...:
   

   

4. Sélectionnez le ConsentManager.framework dossier de à cette projet et cliquez sur Ouvert:
   

   

5. Vous devriez maintenant voir le Framework comme "Intégrer et signer" dans la liste:
   

   

6. Accédez à votre contrôleur de vue principal de votre application et importez le framework en utilisant:
   

   #import <ConsentManager/CmpConsentTool.h>

Lancer le SDK

Avec l'app-start (généralement votre fonction viewDidLoad), vous doivent créer une instance de classe CMPConsentTool. Cela récupérera automatiquement les données nécessaires de notre serveur et déterminera si l'écran de consentement doit être affiché ou non. Si tel est le cas, le SDK affichera automatiquement l'écran de consentement à ce stade, collectera les données et fournira les données à l'application. L'instance peut ensuite être utilisée afin d'obtenir les détails du consentement du SDK afin de l'utiliser dans l'application.

#import "ViewController.h"
#import <ConsentManager/CMPConsentTool.h>

@interface ViewController ()
@property (weak, nonatomic) IBOutlet UILabel *GDPRConsentStringLabel;
@end

@implementation ViewController
static CMPConsentTool *cmpConsentTool = nil;

- (void)viewDidLoad {
    [super viewDidLoad];
  	cmpConsentTool = [[CMPConsentTool alloc] init:@"delivery.consentmanager.net" addId:@"123456" addAppName:@"my%20Test%20App" addLanguage:@"DE" 							addViewController:self];
}

- (IBAction)showGDPRConsentTool:(id)sender {
    [cmpConsentTool openCmpConsentToolView];
}
@end

Exemple pour Swift:

cmpConsentTool = CMPConsentTool.init("delivery.consentmanager.net", addId: "123456", addAppName: "my%20test%20app", addLanguage: "DE", add: self)

Veuillez noter qu'il est important d'initialiser le SDK dans la méthode didAppear. Sinon, la vue peut ne pas être prête à être utilisée et le SDK peut échouer.

Veuillez vous assurer d'utiliser les données de configuration correctes. Les données de configuration se trouvent dans votre ConsentManager compte à Menu> Obtenir le code.

SwiftUI

Pour intégrer le SDK dans un environnement SwiftUI, vous devez fournir un UIViewController qui est enveloppé à l'intérieur d'un UIViewControllerRepresentable. Vous pouvez trouver plus d'informations sur le site officiel documentation pomme. Avant d'intégrer le SDK, assurez-vous d'avoir déjà intégré le module dans votre projet. 

1. Nous commençons par créer un UiViewController habituel similaire aux exemples pour Swift/Objective C

import UIKit
import consentmanager


class CmpViewController: UIViewController {
    struct CmpConfig {
           static let domain = "www.consentmanager.net"
           static let appId = "123456"
           static let appName = "test App"
           static let language = "DE"
       }
    var cmpConsentTool: CMPConsentTool? = nil
    func onClose() -> Void {
        NSLog("closed event");
    }

    func onOpen() -> Void {
        NSLog("opened event");
    }

    func onCMPNotOpened() -> Void {
        NSLog("not opened event");
    }
    
    override func viewDidLoad() {
        cmpConsentTool = CMPConsentTool.init(CmpConfig.domain, addId: CmpConfig.appId, addAppName: CmpConfig.appName, addLanguage: CmpConfig.language, add: self, autoupdate: true, addOpenListener: onOpen, addOnCMPNotOpenedListener: onCMPNotOpened);
        
        // creating a example button to manually open the consent screen
        let button = UIButton.init(frame: CGRect.init(x: 10, y: 100, width: 100, height: 50))
        button.setTitle("Consent", for: .normal)
        button.backgroundColor = .red
        button.addTarget(self, action: #selector(onShowConsentClicked), for: .touchUpInside)
        self.view.addSubview(button)
    }
    
    /**
     * Show consent button was clicked
     */
    @objc func onShowConsentClicked(sender: UIButton!) {
        cmpConsentTool!.openView()
    }
}

2. Pour utiliser le contrôleur dans le interface utilisateur rapide vous devez créer un UIViewControllerRepresentable qui instancie le CmpViewController :

import SwiftUI

struct CmpViewControllerRepresentable: UIViewControllerRepresentable {
    func makeUIViewController(context: Context) -> UIViewController {
        let cmpViewController = CmpViewController()
        
        return cmpViewController
    }
    
    func updateUIViewController(_ uiViewController: UIViewController, context: Context) {
    }
}

3. Nous pouvons maintenant utiliser le ControllerView dans le contexte SwiftUI :

import SwiftUI

@main
struct cmpApp: App {
    var body: some Scene {
        WindowGroup {
            CmpViewControllerRepresentable()
        }
        
        
    }
}

Un exemple de projet est fourni ici

Utilisation de la dernière version du SDK

Afin de savoir quelle version du SDK est la plus récente, veuillez vérifier les balises dans notre repro :

Utilisation du SDK

Vérifier le consentement

Afin de vérifier si un fournisseur ou un objectif a son consentement, vous pouvez utiliser les deux méthodes:

if(consentTool!.hasPurposeConsent("52", purposeIsV1orV2: false))
{
    if(consentTool!.hasVendorConsent("s26", purposeIsV1orV2: false))
    {
        //do something with data
    }
}

Les deux méthodes hasPurposeConsent et hasVendorConsent nécessitent deux paramètres:

• id - Chaîne du fournisseur ou de l'ID de fonction. Veuillez noter que les identifiants de fournisseur peuvent avoir différents formats ("123", "s123" et "c123"), veuillez vérifier avec Menu> Fournisseurs et Menu> Objectifs dans votre ConsentManager compte.
• isIABVendor / isIABPurpose - Si le fournisseur ou l'objet est un fournisseur / objectif qui suit la norme IAB TCF, vous devrez définir un vrai, sinon un faux.

N'oubliez pas: tous les fournisseurs qui n'appartiennent pas à l'IAB ont des ID commençant par un "s" ou "c" (par exemple, "s123"); les fournisseurs qui appartiennent à l'IAB ont des ID ne commençant pas par un «s» ou «c».

Réouverture de l'écran de consentement

Afin de permettre à l'utilisateur de modifier les choix, vous pouvez simplement appeler openCmpConsentToolView():

consentTool.openCmpConsentToolView();

Swift:

cmpConsentTool!.openView()

Transmission d'informations sur le consentement à d'autres sources

Dans certains cas, une application native peut contenir des vues Web afin d'afficher certaines choses comme du contenu publicitaire ou publicitaire. Afin de transmettre les informations de consentement du SDK à la vue Web, veuillez utiliser la fonction:

consentData = CMPStorageConsentManager.exportCMPData(this);

Cela exportera les informations de consentement et toutes les autres données nécessaires au CMP. Vous pouvez ensuite transmettre ces informations au CMP qui se trouve dans votre vue Web en l'ajoutant à l'URL appelée dans la vue Web:

myWebView.loadURL("https://mywebsite.com/....#cmpimport=" + consentData);

Blocage de contenu dynamique avec espace réservé UIView

L'espace réservé viewObject peut être implémenté pour obtenir la fonctionnalité de blocage de contenu dynamique ici.Vous pouvez créer la vue avec la méthode suivante : 

class ViewController: UIViewController, CmpPlaceholderAcceptedDelegate {
//...
  
@objc func createPlaceholderView{
	let params : CmpPlaceholderParams = CmpPlaceholderParams.init(vendorId: "123");
	let placeholder : CmpPlaceholderView = (cmpConsentTool?.createPlaceholder(CGRect.init(x: 0, y: 300, width: view.frame.size.width, height: 				view.frame.size.height), params))!;
	placeholder.vendorDelegate = self;
	view.addSubview(placeholder);	
}



func vendorAccepted(_ placeholderView: CmpPlaceholderView!) {
	//... actions to do when the consent is accepted
  	// Like showing youtube video view
}
// ...
}

Avec l'objet Wrapper CMPPlaceholderParams vous pouvez également transmettre des paramètres facultatifs tels que des textes personnalisés ou une image d'aperçu facultative. vous pouvez ajouter des textes personnalisés comme indiqué ci-dessous : 

params.buttonText = "Click me";

La logique métier requise, lorsque vous souhaitez afficher la vue et lorsqu'elle n'a pas besoin d'être appliquée par le développeur. Pour obtenir des informations lorsque l'utilisateur interagit avec l'espace réservé, vous pouvez utiliser le délégué préparé CmpPlaceholderAcceptedDelegate. Avec le délégué, vous devrez implémenter la fonction vendorAccepted où vous pouvez contrôler une logique supplémentaire lorsque l'utilisateur a accepté le consentement. 

Intégration avec Apple Tracking Transparency (ATT)

Depuis iOS 14, Apple a introduit le cadre Apple Tracking Transparency, qui exige que chaque application doit exposer les données de suivi qu'elle utilise. Le cadre ATT en lui-même n'est pas conforme à l'IAB TCF/GDPR, etc. et n'est qu'une version spécifique à Apple pour demander le consentement de l'utilisateur pour le suivi des données. Pour permettre à l'utilisateur une meilleure expérience, nous soutenons une solution pour synchroniser les consentements entre le SDK CMP et l'interface ATT. Le SDK propose deux solutions différentes pour cela. 

1. Le développeur intègre lui-même le framework ATT, puis transmet les informations résultantes au SDK CMP. La documentation Apples peut être trouvée ici

Nous recommandons cette intégration. Vous êtes toujours en mesure d'obtenir le contrôle total de l'interface ATT et de mettre en œuvre votre processus personnalisé en fonction de l'utilisateur.  

L'intégration pourrait ressembler à ceci. 

       func requestPermission() {
           if #available(iOS 14, *) {
               ATTrackingManager.requestTrackingAuthorization(completionHandler: { status in
                   switch status {
                   case .authorized:
                       // Tracking authorization dialog was shown and accepted
                       // TODO custom code here:
                   case .denied:
                       // Tracking authorization dialog was shown and permission is denied
                       // TODO custom code here:
                   case .notDetermined:
                       // Tracking authorization dialog has not been shown
                       // TODO custom code here:
                   case .restricted:
                       // Tracking authorization dialog has not been shown app is restricted for tracking
                       // TODO custom code here:
                   }
                   // After determination of the att status, pass the information to the cmp sdk                                                           
                   CmpConfig.setAppleTrackingStatus(status.rawValue);
               })
           }
       }

La demande d'autorisation pourrait ressembler à ceci. La ligne de code importante est 19 où les informations sont transmises au SDK CMP. En fonction du statut ATT, le SDK CMP définit des informations de consentement prédéfinies. 

2. Le développeur active le suivi automatique des pommes. Le SDK CMP gère la demande avec un protocole par défaut. Le statut sera ensuite géré par le SDK CMP. Ensuite, il est possible d'obtenir le statut ATT par le développeur. Les actions personnalisées doivent néanmoins être gérées sur demande comme dans l'option 1. Vous pouvez activer la demande ATT automatique avec :

Cela affichera la couche ATT du système d'exploitation. 

CmpConfig.setAutoAppleTracking(true);

Assurez-vous d'activer cette fonction avant l'instanciation du SDK CMP. 

Si vous n'utilisez pas ATT, vous devrez peut-être prendre une note pour l'examen Apple automatique. Depuis l'Apple ATT est intégré en option mais pas utilisé. Apple peut ne pas approuver l'Application automatiquement.

Écouteurs d'événements personnalisés

Pour ajouter une logique de processus supplémentaire, vous pouvez utiliser des écouteurs d'événement. Les écouteurs d'événement suivants sont disponibles :

Autorisation d'importation/exportation

Pour importer ou exporter le consentement, vous pouvez utiliser la fonction exportCMPData() et importCMPData(String cmpData). Vérifiez l'exemple ci-dessous : 

// Instanstiate CMPConsentTool()
cmpConsentTool = CMPConsentTool.init(...)

// Importing consent data if you like
cmpConsentTool.importCMPData("${your consentString}");

// ... Your code here ...


// Exporting Consent data 
let consentString : String = CMPConsentTool.exportCMPData()

La chaîne de consentement que vous devez transmettre doit être encodée en base64.

Compiler / télécharger sur l'AppStore

Afin de compiler le SDK pour l'AppStore, vous pouvez utiliser le script suivant pour nettoyer le répertoire de travail:

APP_PATH="${TARGET_BUILD_DIR}/${WRAPPER_NAME}"
FRAMEWORK_NAME="ConsentManager.framework"
# Check if Framework is present.
FRAMEWORK_LOCATION=$(find "$APP_PATH" -name "$FRAMEWORK_NAME" -type d)
if [ -z $FRAMEWORK_LOCATION ]; then
echo "Couldn't find ConsentManager.framework in $APP_PATH. Make sure 'Embed Frameworks' build phase is listed before the 'Strip Unused Architectures' build phase."
exit 1
fi
# This script strips unused architectures
find "$APP_PATH" -name "$FRAMEWORK_NAME" -type d | while read -r FRAMEWORK
do
FRAMEWORK_EXECUTABLE_NAME=$(defaults read "$FRAMEWORK/Info.plist" CFBundleExecutable)
FRAMEWORK_EXECUTABLE_PATH="$FRAMEWORK/$FRAMEWORK_EXECUTABLE_NAME"
echo "Executable is $FRAMEWORK_EXECUTABLE_PATH"
EXTRACTED_ARCHS=()
for ARCH in $ARCHS
do
echo "Extracting $ARCH from $FRAMEWORK_EXECUTABLE_NAME"
lipo -extract "$ARCH" "$FRAMEWORK_EXECUTABLE_PATH" -o "$FRAMEWORK_EXECUTABLE_PATH-$ARCH"
EXTRACTED_ARCHS+=("$FRAMEWORK_EXECUTABLE_PATH-$ARCH")
done
echo "Merging extracted architectures: ${ARCHS}"
lipo -o "$FRAMEWORK_EXECUTABLE_PATH-merged" -create "${EXTRACTED_ARCHS[@]}"
rm "${EXTRACTED_ARCHS[@]}"
echo "Replacing original executable with thinned version"
rm "$FRAMEWORK_EXECUTABLE_PATH"
mv "$FRAMEWORK_EXECUTABLE_PATH-merged" "$FRAMEWORK_EXECUTABLE_PATH"
done

Diagramme de séquence du SDK CMP

Dans cet exemple, nous vous montrons trois flux de séquence SDK possibles pour comprendre le Consentmanager et il processus. 

1. Lors de la création d'une instance à l'aide de initialiser fonction, il y a deux résultats possibles. Le premier est lorsque l'API Consentmanger informe le SDK que le CMP ne s'ouvrira pas, ce qui déclenche le OnCmpNotOpenedCallbackOnCmpNotOpenedCallback. Le deuxième résultat est lorsque la couche de consentement s'ouvre, permettant à l'utilisateur d'interagir avec elle, et cela déclenche le OnOpenCallback. Une fois que l'utilisateur a donné son consentement et que celui-ci a été traité, le OnCmpCloseCallbackOnCmpCloseCallback est appelé.

S'il vous plaît noter que le OnErrorCallback est représenté par les flèches rouges en pointillés pour fournir des exemples d'erreurs pouvant survenir au cours du processus.

2. Créer une instance et appeler le openAndCheckConsent fonctions conduiront à un processus similaire. La différence est qu'en découplant la création de l'instance et la vérification de l'API Consentmanger, vous gagnez la possibilité d'ajouter une logique métier et d'interagir avec l'API des bibliothèques.

3. Créer une instance et appeler le openLayer fonction ouvrira le calque sans vérifier le Consentmanager, si c'est nécessaire. Si le consentement a déjà été donné, les options et les paramètres seront affichés à l'utilisateur. Le flux de processus ressemblera à ceci :

Changelog

Le journal des modifications peut être trouvé ici dans notre dépôt.

Préférences NSUserDefaults

Le SDK définira NSUserDefaults valeurs pour IAB TCF v1, IAB TCF v2, IAB USPrivacy et Google AC String.

Les clés suivantes sont définies:

Présentation de l'API