ConsentManager GDPR / CCPA SDK för iOS

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)

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 consentmanager 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 XCFramework

Vi rekommenderar starkt att du installerar och använder biblioteket med Cocoapod. Utan det blir det svårare att underhålla för både användaren och utvecklaren. På detta sätt måste uppdateringar integreras manuellt och det finns vissa versionskontrollproblem. Därför planerar vi att stoppa den aktiva tjänsten för detta bibliotek. 

Ladda ner SDK

Ladda ner den senaste versionen av SDK här:

XC -ramverk: https://bitbucket.org/consentmanager/consentmanager-xcframework/src/master/

SDK är konfigurerad för iOS version 10 och högre.

Integration

Följ dessa steg för att integrera SDK: n i ditt befintliga projekt:

1. Dra filerna från mappen ConsentManager.framework i huvudmappen i din app:
   

   
   
   

2. Klicka på ditt projekt och gå till fliken Allmänt och utöka delen under Ramverk, bibliotek och inbäddat innehåll:
   

   

    

3. Om modulen inte är inbäddad ännu, klicka på + (Plus)> Lägg till annat> Lägg till filer ...:
   

   

4. Välj ConsentManager.framework mapp från detta projekt och klicka på Öppen:
   

   

5. Du bör nu se ramverket som "Bädda in & underteckna" i listan:
   

   

6. Navigera till din huvudvykontroller för din app och importera ramverket med hjälp av:
   

   #import <ConsentManager/CmpConsentTool.h>

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.

#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

Exempel för Swift:

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

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.

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

Använder den senaste versionen av SDK

För att ta reda på vilken version av SDK som är den senaste, kontrollera taggarna i vår repro:

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 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 openCmpConsentToolView():

consentTool.openCmpConsentToolView();

Snabb:

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 = CMPStorageConsentManager.exportCMPData(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);

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:

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.

Kompilering / uppladdning till AppStore

För att kompilera SDK för AppStore kanske du vill använda följande skript för att rengöra arbetskatalogen:

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

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:

changelog

Ändringslogg kan hittas här i vårt förråd.

NSUserDefaults-inställningar

SDK kommer att ställas in NSUserDefaults värden för IAB TCF v1, IAB TCF v2, IAB USPrivacy och Google AC String.

Följande nycklar definieras:

API-översikt