[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
- Integrera SDK i appen och konfigurera SDK-inställningarna
- När SDK-enheten är sammankopplad i en app kommer SDK att tillhandahålla funktioner för apputvecklaren för att hämta samtyckesdata
- Så snart appen startar hämtar SDK automatiskt information från consentmanager servrar för att förbereda SDK för dess användning.
- 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. - 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" />
Interna applänkar och domänvitlista
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
Kontrollera för samtycke
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)
Ö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:
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:
// Importing consent data if you like
cmpManager?.importCmpString(
"yourConsentString"
) { _, message ->
coroutineScope.launch {
snackbarHostState.showSnackbar(
message = message,
actionLabel = "Action",
duration = SnackbarDuration.Short
)
}
}
// Exporting Consent data
String consentString = cmpManager.exportCmpString();
ConsentString du behöver skicka bör vara base64-kodad.
CMP SDK-sekvensdiagram
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;
#}