Info
Innehåll

[Android] 1. consentmanager SDK-integration

Smakämnen consentmanager SDK för Android-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

Sedan version 1.7.0 har SDK-förvaret flyttats till det officiella Maven-förrådet. Migrationsguiden finns här.

Hitta de kompatibla inbyggda SDK-versionerna här.

Gradle

Lägg till beroendet till dina appar build.gradle. (För att alltid få den senaste versionen använd +-symbolen för att få de senaste uppdateringarna. Du kan till exempel alltid få de senaste versionerna för mindre uppdateringar genom 1.x.+)

dependencies {
  implementation 'net.consentmanager.sdk:android:x.xx.x'
}

Maven

Lägg till beroendet till dina appar build.gradle. (För att alltid få den senaste versionen i maven kan du använda olika metoder för att avböja versionsintervallet. du kan slå upp dem här. )

<dependency>
    <groupId>net.consentmanager.sdk</groupId>
    <artifactId>android</artifactId>
    <version>x.xx.x</version>
</dependency>

Använda biblioteket

behörigheter

Denna SDK kräver följande behörigheter, se till att lägga till dem i din AndroidManifest.xml:

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />

Initiera ConsentTool

Med app-start (vanligtvis din viewDidAppear-funktion) måste du skapa en instans av klass CMPConsentTool. Detta hämtar automatiskt nödvändiga data från vår server och avgör om samtycksskärmen måste visas eller inte. Om så är fallet 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.

För att initiera ConsentTool, gå till din riktade klass och skapa en instans av CMPConsentTool som visas nedan:

class CmpDemoActivity : FragmentActivity() {

    private lateinit var cmpManager: CmpManager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val config = CmpConfig.apply {
            id ="yourid"
            domain = ConsentActivity.CMP_DOMAIN
            appName = ConsentActivity.CMP_APP_NAME
            language = ConsentActivity.LANG
        }
        cmpManager = CmpManager.createInstance(this, config)
        cmpManager.initialize(this)
    }
// Java example instantiation: 

    CmpManager cmpManager = null;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        CmpConfig cmpConfig = CmpConfig.INSTANCE;
        cmpConfig.setId("YourId");
        cmpConfig.setDomain("delivery.consentmanager.net");
        cmpConfig.setAppName("YourAppName");
        cmpConfig.setLanguage("EN");
        cmpConfig.setTimeout(4000);
        cmpManager = CmpManager.createInstance(this, cmpConfig);
      
    }

// ... open layer and asking for purpose:

        cmpManager.openConsentLayer(getApplication());
        if (cmpManager.hasPurposeConsent("PURPOSE_ID")) {
            Log.d(TAG, "has purpose");
        }

För att skapa instansen av CMPConsentTool måste du konfigurera instansen. Du måste ange CODE-ID, serverdomän, ett appnamn och ett språk. KOD-ID och serverdomän finns i din consentmanager konto under Meny> Hämta kod. Appnamnet kan användas för att distribuera olika appar i consentmanager rapportering. För språket kan du antingen använda en tom sträng ("") för automatisk upptäckt eller en två-bokstavs språkkod ("EN", "DE", "FR" och så vidare).

Konfigurationsvärdena kan sättas in på olika sätt:

a) SDK-konfiguration via CmpConfig

Lägg till följande rader i din kod:

val config = CmpConfig.apply { 
            serverDomain = CMP_DOMAIN
            appName = CMP_APP_NAME
            language = LANG
            id = CODE_ID
        }
cmpManager = CmpManager.createInstance(this, config)
b) SDK-konfiguration via createInstance()

Lägg till följande rad i din kod:

        cmpManager =
            CmpManager.createInstance(
                this,
                config.id,
                config.domain,
                config.appName,
                config.language
            )

Skapa en anpassad layout

För att skapa en anpassad layout använder CMP SDK ett fragment. Du kan antingen lägga till en behållare i vyn och ange behållar-id:t till SDK:n, eller så kan du använda hjälpfunktionen som visas nedan: 

    private suspend fun openCmp(language: String) {
        val layoutId = createFrameLayout()
        // or add the containerID here 
        CmpConfig.activateCustomLayer(layoutId)
        val consentTool = createInstance(
            context = applicationContext,
            codeId = "201",
            serverDomain = "delivery.consentmanager.net",
            appName = "Test App",
            lang = language,
            timeout = 7000,
        )

        consentTool.openConsentLayer(this)
    }

    private suspend fun createFrameLayout(): Int {
        val layoutId = CmpFrameLayoutHelper(this).createFrameLayout(Rect(0, 0, 400, 600), 0F)
        return layoutId
    }

Exempel på Java-kod:

CmpConfig cmpConfig = CmpConfig.INSTANCE;
// your other parameters
cmpConfig.activateCustomLayer(R.id.cmpContainer);
R.id.cmpContainer är en ramlayout som kan se ut så här i aktivitetslayouten xml i layout/{din_aktivitet}.xml
<FrameLayout
    android:id="@+id/cmpContainer"
    android:layout_width="match_parent"
    android:layout_height="400dp"
    android:translationZ="90dp"
    app:layout_constraintTop_toTopOf="parent" />

Med SDK

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

cmpManager?.hasPurposeConsent(purposeTextState.value)
cmpManager?.hasVendorConsent(vendorTextState.value)                             

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

cmpManager?.openConsentLayer(context)

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:

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

Anpassade evenemangslyssnare

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

Företag

Förekommer

 

OnOpenCallback

Lyssnare efter händelse när CMP öppnade

PåCMPCloseCallback

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

OnCPMNotOpenedCallback

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

Vid feluppringning

Lyssnare för händelse när det finns ett fel i samtyckeshanteringsprocessen.

OnButtonClickedCallback

Lyssnare för ButtonEvent

Import/Export samtycke

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

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

 

CMP SDK-sekvensdiagram

Cmp-Sekvens-Diagram-(1).png


Loggning

När du använder vår Android SDK kan du behöva felsöka eller analysera logginformation för olika ändamål. Loggarna som genereras av vår SDK är taggade med "CMP", 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 med Logcat i Android Studio.

Sök efter taggen: I sökfältet ovanför loggsatserna skriver du CMP för att filtrera bort loggarna taggade med "CMP".

Valfritt: Aktivera felsökningsläge

In CMPConfig, uppsättning isDebugMode = true.

val config = CmpConfig.apply {
    // ... other settings
    isDebugMode = true
}
  • Aktiverar mer detaljerade loggar taggade med "CMP".
  • Användbar för felsökning och analys.

Felsökning

Class Not Found eller NoSuchMethodException:

ProGuard kan ibland fördunkla klassnamn eller ta bort metoder som refereras dynamiskt via reflektion. För att fixa detta måste du ange klasserna och metoderna som ska hållas intakta i ProGuard-konfigurationsfilen med -keep Direktiv.

Exempel på ProGuard-konfiguration för att behålla en specifik klass och dess metoder:

# Kotlin serialization looks up the generated serializer classes through a function on companion
# objects. The companions are looked up reflectively so we need to explicitly keep these functions.
-keepclasseswithmembers class **.*$Companion {
    kotlinx.serialization.KSerializer serializer(...);
}
# If a companion has the serializer function, keep the companion field on the original type so that
# the reflective lookup succeeds.
-if class **.*$Companion {
  kotlinx.serialization.KSerializer serializer(...);
}
-keepclassmembers class <1>.<2> {
  <1>.<2>$Companion Companion;
}

# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
-keepclassmembers class * {
    @android.webkit.JavascriptInterface <methods>;
}

-keepattributes JavascriptInterface

-keepclassmembers class net.consentmanager.sdk.common.callbacks.* {
   public *;
}

-keepclassmembers class net.consentmanager.sdk.consentlayer.ui.consentLayer.CmpWebView {
   public *;
}

-keepclassmembers class net.consentmanager.sdk.consentlayer.ui.CmpLayerAppInterface {
   public *;
}
-keep class net.consentmanager.sdk.CMPConsentTool {
                                                      *;
                                                  }

-keepclassmembers class * {
    @android.webkit.JavascriptInterface <methods>;
}

-keepattributes JavascriptInterface

# Serializer for classes with named companion objects are retrieved using `getDeclaredClasses`.
# If you have any, uncomment and replace classes with those containing named companion objects.
#-keepattributes InnerClasses # Needed for `getDeclaredClasses`.
#-if @kotlinx.serialization.Serializable class
#com.example.myapplication.HasNamedCompanion, # <-- List serializable classes with named companions.
#com.example.myapplication.HasNamedCompanion2
#{
#    static **$* *;
#}
#-keepnames class <1>$$serializer { # -keepnames suffices; class is kept when serializer() is kept.
#    static <1>$$serializer INSTANCE;
#}

 

Tillbaka till toppen