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
            )

Initiera och öppna samtyckeslagret

För att kontrollera om användaren behöver ge samtycke och för att öppna samtyckeslagret finns det olika alternativ. 

Genom att initiera samtal

Smakämnen initialize funktionen är utformad för att ställa in CMP SDK i ditt programsammanhang och automatiskt kontrollera och öppna samtyckeslagret om det behövs. De initialize kan kopplas till instansskapandet

cmpManager = CmpManager.createInstance(this, config).initialize(this)
Genom CheckAndOpen-samtal

Liknande som initialize funktion kommer CheckAndOpenLayer att öppna samtyckeslagret om det behövs. 

 cmpManager.checkAndOpenConsentLayer(this)
Manuellt

Smakämnen check Funktionen erbjuder en manuell metod för att avgöra om användarens samtycke krävs. Det möjliggör en återuppringningsmekanism och en valfri cachemekanism för att minska nätverksförfrågningar.

        cmpManager.check({ isConsentRequired ->
            if (isConsentRequired) {
                // Consent is required, handle accordingly
                runOnUiThread {
                    // Update UI or show consent dialog
                    cmpManager.openLayer()
                }
            } else {
                // Consent is not required, proceed with application logic
            }
        }, isCached = true)

Skapa en anpassad layout

För att skapa en anpassad layout kan du använda CmpUIConfig klass med olika stylingalternativ. Den här klassen erbjuder också vissa förinställda layouter som 

  • konfigurera HalfScreenBottom
  • konfigurera HalfScreenTop
  • konfigureraCenterScreen
  • konfigureraSmallCenterScreen
  • configureLargeTopScreen
  • configureLargeBottomScreen

För att skapa en anpassad layout erbjuder CMP SDK också olika strategier:

  • Dialogfönster
  • Pop-up fönster
  • fragment

Du kan ändra strategin genom att ställa in UIConfig-parametern: 

CmpUIConfig.uiStrategy = CmpUIStrategy.DIALOG
CmpUIConfig.uiStrategy = CmpUIStrategy.POPUP
CmpUIConfig.uiStrategy = CmpUIStrategy.ACTIVITY
CmpUIConfig.uiStrategy = CmpUIStrategy.FRAGMENT

Vi rekommenderar att du använder ett popup-fönster som också är inställt som standard sedan version 2.3.0

Två viktiga parametrar kommer att avgöra Popup och dialog beteende: 

Popup-beteende
Parameter är Fokuserbar = sant är Fokuserbar = falskt
isOutsideTouchable = sant Avvisar vid yttre beröring. Kan få fokus för input-händelser. Avvisar vid yttre beröring. Får inte fokus eller fångar tangentbordsinmatning.
isOutsideTouchable = falskt Avvisar inte vid yttre beröring. Kan få fokus och fånga upp ingångshändelser. Avvisar inte vid yttre beröring. Får inte fokus eller fångar tangentbordsinmatning.

 

 

 

Dialogbeteende
Parameter är Fokuserbar = sant är Fokuserbar = falskt
isOutsideTouchable = sant Avvisar vid yttre beröring (setCanceledOnTouchOutside(true)). Dialogrutan är fokuserbar som standard. Dialogen avvisar inte vid beröring utifrån och kanske inte beter sig som förväntat eftersom dialoger vanligtvis kan fokuseras.
isOutsideTouchable = falskt Avvisar inte vid yttre beröring (setCanceledOnTouchOutside(false)). Dialogen förblir fokuserbar och kan fånga upp ingångshändelser. Dialog avvisar inte vid beröring utifrån och kanske inte beter sig som förväntat på grund av bristen på fokusbarhet.
Exempel på fragment:
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" />

För att implementera funktionen där vissa domäner är vitlistade och, när de nås inom samtyckesplattformen (CMP) WebView, inte öppnas i en extern webbläsare som Chrome utan inom själva WebView, kan du implementera en återuppringningsmekanism för att utföra anpassade åtgärder baserat på domän, som att öppna en Android-aktivitet.

// apply the domains to be whitelisted
CmpConfig.apply {
            id = cmpId
            domain = cmpDomain
            appName = cmpAppName
            language = cmpLanguage
            domainWhitelist = cmpDomainWhitelist
        }


// implement the callback: CmpOnClickLinkCallback
    override fun onClickLink(url: String): Boolean {
        Log.d("CMP", url)
        // Business logic
        return true // return handleWebViewInteraction boolean
    }

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