[iOS] 1. Consentmanager Intégration SDK

Les 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.

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 CmpSdk à 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 Swift Package Manager

1. Ouvrez le gestionnaire de paquets Swift

Cliquez sur File > Swift Packages > Add Package Dependency.

2. Ajoutez l'URL du référentiel SDK

Vous verrez maintenant une nouvelle fenêtre dans laquelle vous pourrez entrer l'URL du référentiel du SDK. La plupart des SDK sont hébergés sur GitHub, donc l'URL ressemblera souvent à https://github.com/iubenda/cm-sdk-xcframework.git. Après avoir entré l'URL, cliquez sur Next.

3. Sélectionnez la version du SDK

SPM va maintenant récupérer le référentiel et vous demander de sélectionner une version.

Vous pouvez choisir d'ajouter le package en sélectionnant une règle de version :

• Up to Next Major: Cela mettra à jour le paquet jusqu'à la prochaine version majeure. C'est l'option recommandée car elle ajoute des mises à jour qui n'ont pas de modifications avec rupture.
• Up to Next Minor: Cela mettra à jour le paquet jusqu'à la prochaine version mineure.
• Exact: Cela verrouillera le paquet sur une version spécifique. Aucune mise à jour ne sera installée.

Sélectionnez la version que vous souhaitez utiliser et cliquez sur Next.

4. Ajoutez le SDK à votre cible

Sur l'écran suivant, sélectionnez les cibles auxquelles vous souhaitez ajouter la dépendance de package. Les cibles sont généralement votre application et tous les tests que vous pourriez avoir.
Cliquez Finish pour terminer le processus.

5. Importez le SDK 

Maintenant que le SDK a été ajouté à votre projet, vous devez l'importer pour l'utiliser. Accédez au fichier dans lequel vous souhaitez utiliser le SDK et ajoutez l'instruction d'importation suivante en haut :

import CmpSdk

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.

/** Initialize with CmpConfig */
let cmpConfig : CmpConfig = CmpConfig.init()
CmpConfig.setValues(myCmpConfig.domain, addCodeId: myCmpConfig.appId, addAppName: myCmpConfig.appName, addLanguage: myCmpConfig.language)
cmpConsentTool = CMPConsentTool(cmpConfig: cmpConfig, viewController: self)
  
/** Initialize without CmpConfig */
  
cmpConsentTool = cmpConsentTool(CMPConsentTool(domain: myCmpConfig.domain, codeId: myCmpConfig.appId, appName: myCmpConfig.appName, language: myCmpConfig.language, viewController: self))
        
/** Optionally chain callbacks */
cmpConsentTool = cmpConsentTool.withOpenListener(onOpen)
            				   .withOnCmpButtonClickedCallback(onButtonClickedEvent)
            				   .withCloseListener(onClose)
           					   .withErrorListener(onCmpError)

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 > CodeId

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(CMPConsentTool(domain: CmpConfig.domain, codeId: CmpConfig.appId, appName: CmpConfig.appName, language: CmpConfig.language, viewController: self))
        // 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 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 openView()

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 = CmpConsentTool.exportCmpString();

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

/** to pass the att status you can use the cmpatt parameter (1=accepted, 2=declined) */

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

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.importCmpString("${your consentString}");

// ... Your code here ...


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

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

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 :

Blocage de contenu dynamique avec espace réservé UIView

Cette fonction est obsolète et sera supprimée à l'avenir. Veuillez utiliser l'API enableVendorList

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.