Info
Innehåll

Consentmanager SDK för iOS

Version 1.6.0 och senare

Du har nu möjlighet ConsentManager SDK för iOS-appar implementerar och tillhandahåller funktionalitet för att informera användaren om dataskydd och fråga och samla in samtycke från användaren. Det gör det möjligt för app-utvecklare att enkelt integrera ConsentManager tjänst i deras app.

Stödda standarder

Du har nu möjlighet ConsentManager GDPR / CCPA SDK för Android stöder följande branschstandarder:

  • IAB TCF v1
  • IAB TCF v2
  • IAB USPrivacy v1
  • ConsentManager anpassade leverantörer / ändamål
  • Googles ytterligare samtyckesläge (Google AC String)

 

Cmp-Sdk-Screen-Shot---settings.png

Hur det fungerar

  1. Integrera SDK i appen och konfigurera SDK-inställningarna
  2. När SDK-enheten är sammankopplad i en app kommer SDK att tillhandahålla funktioner för apputvecklaren för att hämta samtyckesdata
  3. Så snart appen startar hämtar SDK automatiskt information från ConsentManager servrar för att förbereda SDK för dess användning.
  4. Det rekommenderas att appen skapar en klassinstans vid start av appen CMPConsentTool. När detta har skapats kommer SDK automatiskt att visa samtyckeskärmen vid behov.
  5. När appen vill behandla personuppgifter, bör den "fråga" SDK om samtycke gavs för det specifika syftet och leverantören.

Installation via Cocoapod

Lägg till bibliotek med Cocoapod

Du kan installera consentmanager SDK genom att lägga till CmpSdk till din Podfile som förklaras i exemplet nedan:

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

När detta är klart måste du köra pod install i din projektkatalog för att installera consentmanager SDK. Efter detta, vänligen öppna *.xcworkspace och bygga. 

När du har följt alla steg bör ditt beroende installeras och du kan fortsätta och använda det i ditt projekt.

Initiera SDK

Med app-start (oftast din viewDidLoad-funktion) kan du måste skapa en instans av klass CMPConsentTool. Detta hämtar automatiskt nödvändig data från vår server och avgör om samtycksskärmen måste visas eller inte. I så fall kommer SDK automatiskt att visa samtyckskärmen vid denna tidpunkt, samla in data och tillhandahålla informationen till appen. Instansen kan sedan användas för att få samtyckeuppgifter från SDK för att kunna använda den i appen.

/** 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)

Observera att det är viktigt att initialisera SDK i metoden didAppear. Annars kanske vyn inte är klar att använda och SDK kan misslyckas.

Se till att använda rätt konfigurationsdata. Konfigurationsdata kan hittas i din ConsentManager konto på Meny > Hämta kod > CodeId

SwiftUI

För att integrera SDK:n i en SwiftUI-miljö måste du tillhandahålla en UIViewController som är insvept i en UIViewControllerRepresentable. Du kan hitta mer information om på tjänstemannen äppeldokumentation. Innan du integrerar SDK:n se till att du redan har integrerat modulen i ditt projekt. 

1. Vi börjar med att skapa en vanlig UiViewController liknande exemplen för 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. För att använda styrenheten i swiftUI du måste skapa en UIViewControllerRepresentable som instansierar CmpViewController:

import SwiftUI

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

3. Nu kan vi använda ControllerView i SwiftUI-kontexten:

import SwiftUI

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

Ett exempelprojekt tillhandahålls här

Med SDK

För att kontrollera om en leverantör eller syfte har samtycke kan du använda de två metoderna:

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

Båda metoderna hasPurposeConsent och hasVendorConsent kräver två parametrar:

  • id - Sträng av leverantören eller syfte-ID. Observera att leverantörs-ID: n kan ha olika format ("123", "s123" och "c123"), vänligen dubbelkontrollera med Meny> Leverantörer och Meny> Syften i din ConsentManager konto.
  • isIABVendor / isIABPurpose - Om leverantören eller syftet är en leverantör / syfte som följer IAB TCF-standarden, måste du ställa in en sann, annars en falsk.

Kom ihåg: Alla leverantörer som inte tillhör IAB har ID som börjar med "s" eller "c" (t.ex. "s123"); leverantörer som tillhör IAB har ID som inte börjar med "s" eller "c".

Öppna åtkomstskärmen igen

För att låta användaren ändra valen kan du helt enkelt ringa openView()

cmpConsentTool!.openView()

I vissa fall kan en inbyggd app innehålla webbvisningar för att visa vissa saker som reklam eller innehåll. För att överföra samtyckeinformation från SDK till webbvisningen, använd funktionen:

consentData = CmpConsentTool.exportCmpString(this);

Detta kommer att exportera samtyckeinformationen och all ytterligare information som behövs av CMP. Du kan sedan skicka den här informationen till CMP som finns i din webbvy genom att lägga till den i URL: en som heter i webbvisningen:

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

 

Dynamisk innehållsblockering med platshållare UIView

Platshållaren viewObject kan implementeras för att få funktionen för dynamisk innehållsblockering här.Du kan skapa vyn med följande metod: 

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
}
// ...
}

Med Wrapper Object CMPPlaceholderParams du kan också skicka valfria parametrar som anpassade texter eller en valfri förhandsvisningsbild. du kan lägga till anpassade texter som visas nedan: 

params.buttonText = "Click me";

Den nödvändiga affärslogiken, när du vill visa vyn och när den inte behöver appliceras av utvecklaren. För att få information när användaren interagerar med platshållaren kan du använda den förberedda delegaten CmpPlaceholderAcceptedDelegate. Med delegaten måste du implementera funktionen vendorAccepted där du kan styra ytterligare logik när användaren accepterade samtycket. 

Integration med Apple Tracking Transparency (ATT)

Sedan iOS 14 introducerade Apple Apple Tracking Transparency-ramverket, som kräver att varje app måste avslöja vilken spårningsdata den använder. ATT-ramverket i sig är inte kompatibelt med IAB TCF/GDPR, etc. och är bara en Apple-specifik version för att fråga användarens samtycke för spårning av data. För att ge användaren en bättre upplevelse stödjer vi en lösning för att synkronisera samtyckena mellan CMP SDK och ATT-gränssnittet. SDK erbjuder två olika lösningar för detta. 

1. Utvecklaren integrerar ATT Framework på egen hand och skickar sedan den resulterande informationen till CMP SDK. Apples dokumentation finns här

Vi rekommenderar denna integration. Du kan fortfarande få full kontroll över ATT-gränssnittet och implementera din skräddarsydda process beroende på användaren.  

Integrationen skulle kunna se ut så här. 

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

Begäran om tillstånd kan se ut så här. Den viktiga kodraden är 19 där informationen skickas till CMP SDK. Beroende på ATT-statusen ställer CMP SDK in fördefinierad samtyckesinformation. 

 

2. Utvecklaren aktiverar den automatiska äppelspårningen. CMP SDK hanterar begäran med ett standardprotokoll. Statusen kommer då att hanteras av CMP SDK. Efteråt är det möjligt att få ATT-status av utvecklaren anpassade åtgärder bör ändå hanteras på begäran som i alternativ 1. Du kan aktivera den automatiska ATT-begäran med:

Detta kommer att visa ATT-lagret från operativsystemet. 

CmpConfig.setAutoAppleTracking(true);

Se till att aktivera den här funktionen innan instansieringen av CMP SDK. 

Om du inte använder ATT kan du behöva göra en anteckning för den automatiska Apple Review. Eftersom Apple ATT är integrerat som tillval men inte används. Apple kanske inte godkänner programmet automatiskt.

Anpassade evenemangslyssnare

För att lägga till ytterligare processlogik kan du använda dig av Event Listeners. Följande evenemangslyssnare är tillgängliga:

Namn

Förekommer

 

onCMPOenedListener

Lyssnare efter händelse när CMP öppnade

onCMPClosedListener

Lyssnare för händelse när CMP är stängt

onCMPNotOpenedListener

Lyssnare för Event när CMP inte behöver öppnas

networkErrorListener

Lyssnare för händelse när CMP har nätverksproblem

serverErrorListener

Lyssnare för Event när CMP inte kan nå Consentmanager server

customOpenListener

Lyssnare för händelse när CMP öppnas

Import/Export samtycke

För att importera eller exportera samtycket kan du använda funktionen exportCMPData() och importCMPData(Sträng cmpData). Kontrollera exemplet nedan: 

// 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()

ConsentString du behöver skicka bör vara base64-kodad.

CMP SDK-sekvensdiagram

I det här exemplet visar vi dig tre möjliga SDK-sekvensflöden för att förstå Consentmanager och där processer. 

1. När du skapar en instans med hjälp av initialisera funktion finns det två möjliga utfall. Den första är när Consentmanger API informerar SDK om att CMP inte kommer att öppnas, vilket utlöser OnCmpNotOpenedCallback. Det andra resultatet är när samtyckesskiktet öppnas, så att användaren kan interagera med det, och detta utlöser OnOpenCallback. När användaren ger sitt samtycke och samtycket behandlats, PåCmpCloseCallback kallas.

Observera att Vid feluppringning representeras av de röda streckade pillinjerna för att ge exempel på när fel kan uppstå under processen.

Initialize-Cmp-Sequence-Diagram.png

2. Skapa en instans och anropa openAndCheckConsent funktioner kommer att leda till en liknande process. Skillnaden är att genom att frikoppla skapandet av instansen och kontrollen för Consentmanger API får du möjligheten att lägga till affärslogik och interagera med bibliotekens API.

3. Skapa en instans och anropa openLayer funktionen öppnar lagret utan att markera Consentmanager, om det är nödvändigt. Om det redan finns ett samtycke kommer alternativen och inställningarna att visas för användaren. Processflödet kommer att se ut så här:

openlayer-Cmp-Sequence-Diagram-.png

 

Tillbaka till toppen