[iOS] 1. consentmanager SDK-integration

Smakämnen 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.

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.

Installation via Swift Package Manager

1. Öppna Swift Package Manager

Gå till File > Swift Packages > Add Package Dependency.

2. Lägg till URL:en för SDK-arkivet

Du kommer nu att se ett nytt fönster där du kan ange URL:en till SDK:s arkiv. De flesta SDK:er finns på GitHub, så webbadressen kommer ofta att se ut som https://github.com/iubenda/cm-sdk-xcframework.git. När du har angett webbadressen klickar du Next.

3. Välj SDK-versionen

SPM kommer nu att hämta arkivet och ber dig välja en version.

Du kan välja att lägga till paketet genom att välja en versionsregel:

• Up to Next Major: Detta kommer att uppdatera paketet till nästa större version. Det är det rekommenderade alternativet eftersom det lägger till uppdateringar som inte har brytande ändringar.
• Up to Next Minor: Detta kommer att uppdatera paketet till nästa mindre version.
• Exact: Detta låser paketet till en specifik version. Inga uppdateringar kommer att installeras.

Välj den version du vill använda och klicka Next.

4. Lägg till SDK:n till ditt mål

På nästa skärm väljer du de mål som du vill lägga till paketberoendet till. Mål är vanligtvis din app och eventuella tester som du kan ha.
Klicka Finish för att slutföra processen.

5. Importera SDK:n 

Nu när SDK:n har lagts till i ditt projekt måste du importera den för att kunna använda den. Gå till filen där du vill använda SDK:n och lägg till följande importsats överst:

import CmpSdk

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 initiera SDK:n i viewDidLoad-metoden. Annars kanske vyn inte är redo att användas och SDK:n 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 äpple dokumentation. 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 = "delivery.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

Kontrollera för samtycke

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

Överlåta samtyckeinformation till andra källor

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

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

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:

Import/Export samtycke

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

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

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.

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:

Dynamisk innehållsblockering med platshållare UIView

Den här funktionen är utfasad och kommer att tas bort i framtiden. Använd enableVendorList API

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. 

Loggning

När du använder vår iOS SDK kan du behöva felsöka eller analysera logginformation för olika ändamål. Loggarna som genereras av vår SDK är taggade under "CmpConfig", vilket gör att du enkelt kan filtrera och bara visa relevanta loggar. Den här guiden ger steg-för-steg-instruktioner om hur du kommer åt dessa loggar i Xcode.

Sök efter taggen

I Xcodes felsökningskonsol kan du söka efter loggar specifikt taggade med "Consent" eller "CMP" för att isolera loggarna som genereras av vår SDK.

Valfritt: Justera Verbose Level

In CmpConfig, kan du justera den utförliga nivån för mer detaljerade loggar. Maxnivån är 4.

CmpConfig.setVerboseLevel(4)

• Aktiverar mer detaljerade loggar
• Användbar för felsökning och analys.

Genom att justera den utförliga nivån kan du få mer omfattande logginformation, vilket underlättar felsökning och analys av vår SDK:s beteende i din applikation.