[Androide] 1. consentmanager Integración SDK
La consentmanager SDK para aplicaciones de Android implementa y proporciona funcionalidad para informar al usuario sobre la protección de datos y solicitar y obtener el consentimiento del usuario. Permite a los desarrolladores de aplicaciones integrar fácilmente consentmanager servicio en su aplicación.
Cómo funciona
- Integre el SDK en la aplicación y configure los ajustes del SDK
- Una vez que el SDK se integre en una aplicación, el SDK proporcionará funciones para el desarrollador de la aplicación con el fin de recuperar los datos de consentimiento
- Tan pronto como se inicie la aplicación, el SDK recuperará automáticamente la información del consentmanager servidores para preparar el SDK para su uso.
- Se recomienda que, al iniciar la aplicación, la aplicación cree una instancia de clase
CMPConsentTool
. Una vez que se crea esto, el SDK mostrará automáticamente la pantalla de consentimiento si es necesario. - Cuando la aplicación quiere procesar datos personales, debe "preguntar" al SDK si se dio el consentimiento para el propósito específico y el proveedor.
Instalación
Desde la versión 1.7.0, el repositorio del SDK se ha trasladado al repositorio oficial de Maven. La guía de migración se puede encontrar aquí
Encuentre las versiones nativas del SDK compatibles haga clic aquí
Gradle
Agregue la dependencia a sus aplicaciones build.gradle. (Para obtener siempre la última versión, utilice el símbolo + para obtener las actualizaciones más recientes. Por ejemplo, siempre puede obtener las versiones más recientes para actualizaciones menores hasta 1.x.+)
dependencies {
implementation 'net.consentmanager.sdk:android:x.xx.x'
}
Maven
Agregue la dependencia a sus aplicaciones build.gradle. (Para obtener siempre la última versión en maven, puede utilizar diferentes métodos para rechazar el rango de versiones. Puede buscarlos aquí )
<dependency>
<groupId>net.consentmanager.sdk</groupId>
<artifactId>android</artifactId>
<version>x.xx.x</version>
</dependency>
Usando la biblioteca
Permisos
Este SDK requiere los siguientes permisos, asegúrese de agregarlos a su AndroidManifest.xml:
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
Iniciar herramienta de consentimiento
Con el inicio de la aplicación (generalmente su función viewDidAppear) debe crear una instancia de la clase CMPConsentTool. Esto obtendrá automáticamente los datos necesarios de nuestro servidor y determinará si la pantalla de consentimiento debe mostrarse o no. Si es así, el SDK mostrará automáticamente la pantalla de consentimiento en este punto, recopilará los datos y proporcionará los datos a la aplicación. Luego, la instancia se puede usar para obtener detalles de consentimiento del SDK para usarlo en la aplicación.
Para iniciar ConsentTool, vaya a su clase de destino y cree una instancia de CMPConsentTool como se muestra a continuación:
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");
}
Para crear la instancia de CMPConsentTool, necesita configurar la instancia. Deberá proporcionar el CODE-ID, el dominio del servidor, el nombre de la aplicación y el idioma. El CODE-ID y el dominio del servidor se pueden encontrar en su consentmanager cuenta bajo Menú> Obtener código. El nombre de la aplicación se puede usar para distinguir diferentes aplicaciones en consentmanager informes Para el idioma, puede usar una cadena vacía ("") para la detección automática o un código de idioma de 2 letras ("EN", "DE", "FR", etc.).
Los valores de configuración se pueden insertar de diferentes maneras:
a) Configuración del SDK a través de CmpConfig
Agregue las siguientes líneas a su código:
val config = CmpConfig.apply {
serverDomain = CMP_DOMAIN
appName = CMP_APP_NAME
language = LANG
id = CODE_ID
}
cmpManager = CmpManager.createInstance(this, config)
b) Configuración de SDK a través de createInstance()
Agregue la siguiente línea a su código:
cmpManager =
CmpManager.createInstance(
this,
config.id,
config.domain,
config.appName,
config.language
)
Inicializando y abriendo la capa de consentimiento
Para comprobar si el usuario necesita dar su consentimiento y abrir la capa de consentimiento, existen varias opciones.
Por inicializar llamada
La initialize
La función está diseñada para configurar el SDK de CMP dentro del contexto de su aplicación y verificar y abrir automáticamente la capa de consentimiento si es necesario. El initialize
se puede encadenar a la creación de la instancia
cmpManager = CmpManager.createInstance(this, config).initialize(this)
Por llamada CheckAndOpen
Similar al initialize
función CheckAndOpenLayer abrirá la capa de consentimiento si es necesario.
cmpManager.checkAndOpenConsentLayer(this)
A mano
La check
La función ofrece un enfoque manual para determinar si se requiere el consentimiento del usuario. Permite un mecanismo de devolución de llamada y un mecanismo de caché opcional para reducir las solicitudes de red.
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)
Crear un diseño personalizado
Para crear un diseño personalizado, puede utilizar el CmpUIConfig
Clase con diferentes opciones de estilo. Esta clase también ofrece algunos diseños preestablecidos como
- configurar media pantalla inferior
- configurarHalfScreenTop
- configurarCenterScreen
- configurarSmallCenterScreen
- configurarLargeTopScreen
- configurar pantalla inferior grande
Para crear un diseño personalizado, CMP SDK también ofrece diferentes estrategias:
- Ventana de diálogo
- Ventana emergente
- fragmento
Puede cambiar la estrategia configurando el parámetro UIConfig:
CmpUIConfig.uiStrategy = CmpUIStrategy.DIALOG
CmpUIConfig.uiStrategy = CmpUIStrategy.POPUP
CmpUIConfig.uiStrategy = CmpUIStrategy.ACTIVITY
CmpUIConfig.uiStrategy = CmpUIStrategy.FRAGMENT
Recomendamos utilizar una ventana emergente que también está configurada como predeterminada desde la versión 2.3.0.
Dos parámetros importantes determinarán la Emergente y Diálogo comportamiento:
Comportamiento emergente
Parámetro | esEnfocable = verdadero | esEnfocable = falso |
isOutsideTouchable = verdadero | Se despide al tocar el exterior. Puede ganar foco para eventos de entrada. | Se despide al tocar el exterior. No obtiene enfoque ni intercepta la entrada del teclado. |
isOutsideTouchable = falso | No se descarta al contacto exterior. Puede ganar foco e interceptar eventos de entrada. | No se descarta al contacto exterior. No obtiene enfoque ni intercepta la entrada del teclado. |
Comportamiento del diálogo
Parámetro | esEnfocable = verdadero | esEnfocable = falso |
isOutsideTouchable = verdadero | Descarta al tocar el exterior (setCanceledOnTouchOutside(true) ). El diálogo se puede enfocar de forma predeterminada. |
El diálogo no se descarta al tocarlo desde fuera y es posible que no se comporte como se espera, ya que los diálogos normalmente se pueden enfocar. |
isOutsideTouchable = falso | No se descarta al tocar el exterior (setCanceledOnTouchOutside(false) ). El diálogo sigue siendo enfocable y puede interceptar eventos de entrada. |
El diálogo no se descarta al tocar el exterior y es posible que no se comporte como se esperaba debido a la falta de capacidad de enfoque. |
Ejemplo de fragmento:
R.id.cmpContainer
es un Framelayout que podría verse así en el xml de diseño de actividad en diseño/{tu_actividad}.xml<FrameLayout
android:id="@+id/cmpContainer"
android:layout_width="match_parent"
android:layout_height="400dp"
android:translationZ="90dp"
app:layout_constraintTop_toTopOf="parent" />
Enlaces internos de aplicaciones y lista blanca de dominios
Para implementar la funcionalidad donde ciertos dominios están en la lista blanca y, cuando se accede a ellos dentro de la plataforma de consentimiento (CMP) WebView, no se abren en un navegador externo como Chrome sino dentro del propio WebView, puede implementar un mecanismo de devolución de llamada para realizar acciones personalizadas basadas en el dominio, como abrir una actividad de Android.
// 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
}
Usando el SDK
Verificar consentimiento
Para verificar si un proveedor o propósito tiene consentimiento, puede usar los dos métodos:
cmpManager?.hasPurposeConsent(purposeTextState.value)
cmpManager?.hasVendorConsent(vendorTextState.value)
Ambos métodos hasPurposeConsent
y hasVendorConsent
requiere dos parámetros:
- id: cadena del proveedor o ID de propósito. Tenga en cuenta que las ID de proveedor pueden tener diferentes formatos ("123", "s123" y "c123"), verifique nuevamente con Menú> Proveedores y Menú> Propósitos en tu consentmanager .
- isIABVendor / isIABPurpose: si el proveedor o el propósito es un proveedor / propósito que sigue el estándar IAB TCF, deberá establecer un verdadero, de lo contrario, un falso.
Recuerde: Todos los proveedores que no pertenecen al IAB tienen ID que comienzan con una "s" o "c" (por ejemplo, "s123"); Los proveedores que pertenecen a la IAB tienen ID que no comienzan con una "s" o "c".
Reabrir la pantalla de consentimiento
Para permitir que el usuario cambie las opciones, simplemente puede llamar openCmpConsentToolView()
:
cmpManager?.openConsentLayer(context)
Pasar información de consentimiento a otras fuentes
En algunos casos, una aplicación nativa puede contener vistas web para mostrar ciertas cosas como publicidad o contenido. Para transmitir la información de consentimiento del SDK a la vista web, utilice la función:
String consentData = cmpConsentTool?.exportCmpString();
Esto exportará la información de consentimiento y todos los datos adicionales que necesita el CMP. Luego puede pasar esta información al CMP que está en su vista web agregándola a la URL que se llama en la vista web:
myWebView.loadURL("https://mywebsite.com/....#cmpimport=" + consentData);
Oyentes de eventos personalizados
Para agregar una lógica de proceso adicional, puede utilizar los detectores de eventos. Los siguientes detectores de eventos están disponibles:
Nombre |
ocurre
|
Al abrir devolución de llamada |
Oyente de evento cuando se abrió CMP |
OnCMPCoseCallback |
Oyente de evento cuando CMP está cerrado |
OnCMPNotOpenedDevolución de llamada |
Oyente para eventos cuando no es necesario abrir CMP |
Devolución de llamada en error |
Listener for Event cuando hay un error en el proceso de gestión de consentimiento. |
En botón hecho clic en devolución de llamada |
Oyente de ButtonEvent |
Consentimiento de importación/exportación
Para importar o exportar el consentimiento puede utilizar la función exportCMPData(Contexto contexto) y importCMPData(Contexto contexto, String cmpData). Mira el ejemplo a continuación:
// 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();
La cadena de consentimiento que necesita pasar debe estar codificada en base64.
Diagrama de secuencia del SDK de CMP
Inicio de sesión
Al utilizar nuestro SDK de Android, es posible que necesite depurar o analizar información de registro para diversos fines. Los registros generados por nuestro SDK están etiquetados con "CMP", lo que le permite filtrar y ver fácilmente solo los registros relevantes. Esta guía proporciona instrucciones paso a paso sobre cómo acceder a estos registros usando Logcat en Android Studio.
Busque la etiqueta: En la barra de búsqueda encima de las declaraciones de registro, escriba CMP
para filtrar los registros etiquetados con "CMP".
Opcional: habilitar el modo de depuración
In CMPConfig
establecer isDebugMode = true
.
val config = CmpConfig.apply {
// ... other settings
isDebugMode = true
}
- Habilita registros más detallados etiquetados con "CMP".
- Útil para depuración y análisis.
Solucionando Problemas
Clase no encontrada o NoSuchMethodException:
A veces, ProGuard puede ofuscar nombres de clases o eliminar métodos a los que se hace referencia dinámicamente mediante reflexión. Para solucionar este problema, debe especificar las clases y métodos que deben mantenerse intactos en el archivo de configuración de ProGuard usando el -keep
Directiva.
Ejemplo de configuración de ProGuard para mantener una clase específica y sus métodos:
# 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;
#}