Info
Contenu

[iOS] 1. consentmanager Intégration SDK

La 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

Trouver les versions natives du SDK compatibles ici.

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 le gestionnaire de packages Swift

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

let cmpConfig : CmpConfig = CmpConfig.shared.setup(withId: config.appId, domain: config.domain, appName: config.appName, language: config.language);
// optional configure additional parameter
cmpConfig.isAutomaticATTRequest = true;

// initialize the SDK
cmpConsentTool = CMPConsentTool(cmpConfig: cmpConfig)
        
/** 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 viewDidLoad. 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 config {
        static let domain = "delivery.consentmanager.net"
        static let appId = "testCodeID"
        static let appName = "testApp"
        static let language = "DE"
    }

    var cmpManager: CMPConsentTool? = nil
    
    private func setupCmpConfig() {
        // Do any additional setup after loading the view.
        let cmpConfig : CmpConfig = CmpConfig.shared.setup(withId: config.appId, domain: config.domain, appName: config.appName, language: config.language);
        cmpConfig.isAutomaticATTRequest = true;
        cmpManager = CMPConsentTool(cmpConfig: cmpConfig)
            .withErrorListener(onCMPError)
            .withCloseListener(onClose)
            .withOnCMPNotOpenedListener(onCMPNotOpened).initialize()
    }
    
    func onClose() -> Void {
        NSLog("closed event");
    }

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

    func onCMPNotOpened() -> Void {
        NSLog("not opened event");
    }
    
    override func viewDidLoad() {
    	super.viewDidLoad()
    	setupCmpConfig();
       
        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!) {
        cmpManager!.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 ContrôleurView dans le contexte SwiftUI :

import SwiftUI

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

Un exemple de projet est fourni ici

Pour implémenter la fonctionnalité où certains domaines sont sur liste blanche et, lorsqu'ils sont accessibles dans la WebView de la plateforme de consentement (CMP), ne sont pas ouverts dans un navigateur externe comme Safari mais dans la WebView elle-même, vous pouvez implémenter un mécanisme de rappel pour effectuer des actions personnalisées basées sur le domaine, comme l'ouverture d'un autre ViewController :

cmpConfig.domainWhitelist = ["add your domains to be whitelisted"]
        
cmpManager.withOnCmpLinkClickListener({ url, decisionHandler in
                //check URL and add the nav action
                decisionHandler!.pointee = WKNavigationActionPolicy.allow
                decisionHandler!.pointee = WKNavigationActionPolicy.cancel
                // return shouldCloseWebView (true) or stay open (false)
                return true
            })        

 

Utilisation du SDK

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

if(consentTool!.hasPurposeConsent("52"))
{
    if(consentTool!.hasVendorConsent("s26"))
    {
        //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()

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)

Si vous utilisez le suivi ou l'analyse dans votre application, nous vous recommandons de lire le guide sur Mise en œuvre du TCA ici.

Création d'une mise en page personnalisée

Pour une mise en page personnalisée, il existe 2 fonctions de rappel qui fournissent le viewController et le uiView. Dans l'exemple ci-dessous, vous pouvez voir comment personnaliser la mise en page

        let cmpLayout = CmpLayout.default()
        cmpLayout?.cornerRadius = 10.0
        cmpLayout?.customLayout = CGRect(x: 0, y: 0, width: 200, height: 300)
        cmpManager = CMPConsentTool(cmpConfig: cmpConfig)
            .withCmpViewControllerConfigurationBlock({ viewController in
                viewController?.modalPresentationStyle = .formSheet
                //example of customizing controller
            })
            .withCmpViewConfigurationBlock({ uiView in
                cmpLayout?.apply(to: uiView)
                // or use your own uiView logic 
            })

É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 :

Prénom

Se produit

 

CmpOpenListener

Écouteur d'événement à l'ouverture du CMP

CmpCloseListener

Écouteur d'événement lorsque CMP est fermé

CmpNotOpenedListener

Écouteur d'événement lorsque CMP n'a pas besoin d'être ouvert

CmpErrorListener

Listener sera appelé si une erreur se produit lors de l'appel du serveur ou de l'affichage de la vue.

CmpButtonClickedListener

Écouteur pour l'événement lorsque le bouton est cliqué et que la couche de consentement se ferme

CmpATTrackingStatusChangedListener

Le statut de l'écouteur pour ATTracking a été modifié

onCmpUpdateGoogleConsent

Écouteur pour les changements de mode de consentement

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. La première est lorsque l'API Consentmanger informe le SDK que la 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 SurOpenCallback. 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 SurErreurRappel est représenté par les flèches rouges en pointillés pour fournir des exemples d'erreurs pouvant survenir au cours du processus.

Initialiser-Cmp-Sequence-Diagram.png

2. Créer une instance et appeler le ouvrirAndCheckConsent les fonctions conduiront à un processus similaire. La différence est qu'en dissociant la création de l'instance et la vérification de l'API consentementmanger, vous obtenez 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 couche ouverte 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 :

openlayer-Cmp-Sequence-Diagram-.png

 

Journal

Lorsque vous utilisez notre SDK iOS, vous devrez peut-être déboguer ou analyser les informations des journaux à diverses fins. Les journaux générés par notre SDK sont étiquetés sous « CmpConfig », vous permettant de filtrer et d'afficher facilement uniquement les journaux pertinents. Ce guide fournit des instructions étape par étape sur la façon d'accéder à ces journaux dans Xcode.

Rechercher la balise

Dans la console de débogage de Xcode, vous pouvez rechercher des journaux spécifiquement marqués avec « Consentement » ou « CMP » pour isoler les journaux générés par notre SDK.

Facultatif : Ajuster le niveau détaillé

In CmpConfig, vous pouvez ajuster le niveau détaillé pour des journaux plus détaillés.

cmpConfig.isDebugMode = true   
cmpConfig.logLevel = CmpLogLevel.debug
  • Permet des journaux plus détaillés
  • Utile pour le débogage et l'analyse.

En ajustant le niveau détaillé, vous pouvez obtenir des informations de journal plus complètes, facilitant le débogage et l'analyse du comportement de notre SDK dans votre application.

Retour en haut de la page