Integrazione Android

18 min

Il PubConsent SDK è l'integrazione del nostro PubConsent CMP nelle applicazioni Android.

Il punto di forza della nostra integrazione è che non richiede molti aggiornamenti poiché molte delle modifiche apportate all'interno del configuratore saranno riflesse automaticamente all'interno dell'app.

Versione SDK minimo: 21

Ogni volta che verranno introdotte modifiche rilevanti, sarete contattati via email all'indirizzo tecnico che avete configurato nel nostro dashboard per consentirvi di aggiornare la versione del SDK all'ultima che abbiamo pubblicato.

Per ulteriori API o maggiori informazioni su come funziona, non esitate a contattare il nostro supporto clienti. Se riscontrate bug o problemi durante l'integrazione per favore non esitate a contattarci, ogni vostro feedback è prezioso per noi.

Installazione

Il nostro SDK CMP è disponibile su Maven Central cliccando qui.

Per utilizzare il PubConsent SDK nel tuo progetto Android, aggiungi la seguente dipendenza al tuo file build.gradle:

implementation 'ai.pubtech.pubconsent:pubconsent-sdk:3.0.0'

Permessi

Questo SDK richiede i seguenti permessi, per favore assicurati di aggiungerli al tuoAndroidManifest.xml:

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

Come funziona

Una volta che l'SDK è integrato in un'app, l'SDK chiederà automaticamente e mostrerà l'interfaccia utente se necessario. Nel caso sia necessario mostrare l'interfaccia utente l'SDK recupererà le informazioni dal nostro server per preparare e fornire la tua CMP. L'app può chiedere all'SDK se è stato dato il consenso per lo scopo e/o il fornitore specifici attraverso le API esposte.

Kotlin Example

import ai.pubtech.pubconsent.Cmp
import ai.pubtech.pubconsent.CmpCallbacks
import ai.pubtech.pubconsent.CmpConfig
import ai.pubtech.pubconsent.dto.GoogleConsentModeStatus
import ai.pubtech.pubconsent.dto.GoogleConsentModeType
import ai.pubtech.pubconsent.utility.CmpLogger
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

       // (Se configuri CmpUIConfig.uiType = CmpUIType.FRAGMENT) allora devi assegnare il tuo fragmentContainerId.
       CmpUIConfig.fragmentContainerId = android.R.id.content

       // Configurazione della UI della CMP.
       CmpUIConfig.configureCenterScreen(this)

       val cmp = Cmp.createInstance(this)

		// Creazione ed assegnazione della callbacks. (opzionale)
        val cmpCallbacks = CmpCallbacks(
            { if (consentApiInterface.getCmpType() == CmpType.TCF_V2_GDPR) {
                consentApiInterface as TCFGDPRConsentApi
                CmpLogger.d("La CMP è basata su TCF V2 per il GDPR ed il consenso è pronto")
                CmpLogger.d("Il vendor 1 è abilitato?: ${cmp.isVendorConsentEnabled(1)}")
                CmpLogger.d("Features: ${cmp.isFeatureCookiesEnabled()}")
                CmpLogger.d("User Experience: ${cmp.isUserExperienceCookiesEnabled()}")
                CmpLogger.d("Measurement: ${cmp.isMeasurementCookiesEnabled()}")

                // Da usare solo se il TCF mobile flag non è abilitato nel configuratore.
                    val firebaseConsentMap = consentApiInterface.getGoogleConsentMode()?.entries?.associate { entry ->
                        val firebaseConsentType = when (entry.key) {
                            GoogleConsentModeType.ANALYTICS_STORAGE -> "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE"
                            GoogleConsentModeType.AD_STORAGE -> "FirebaseAnalytics.ConsentType.AD_STORAGE"
                            GoogleConsentModeType.AD_USER_DATA -> "FirebaseAnalytics.ConsentType.AD_USER_DATA"
                            GoogleConsentModeType.AD_PERSONALIZATION -> "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION"
                            GoogleConsentModeType.FUNCTIONALITY_STORAGE -> "Opzionale"
                            GoogleConsentModeType.PERSONALIZATION_STORAGE -> "Opzionale"
                            GoogleConsentModeType.SECURITY_STORAGE -> "Opzionale"
                        }

                        val firebaseConsentStatus = when (entry.value) {
                            GoogleConsentModeStatus.GRANTED -> "FirebaseAnalytics.ConsentStatus.GRANTED"
                            GoogleConsentModeStatus.DENIED -> "FirebaseAnalytics.ConsentStatus.DENIED"
                            GoogleConsentModeStatus.UNKNOWN -> "Non mappato nel caso in cui non siano disponibili i tipi opzionali."
                        }

                        firebaseConsentType to firebaseConsentStatus
                    }

                    CmpLogger.d("Firebase mapping $firebaseConsentMap")
                }
                if (consentApiInterface.getCmpType() == CmpType.GOOGLE_CONSENT_MODE) {
                    consentApiInterface as GCMConsentApi
                    CmpLogger.d("La CMP è basata sul Google Consent Mode ed è il consenso è pronto!")

                    val firebaseConsentMap = consentApiInterface.getGoogleConsentMode()?.entries?.associate { entry ->
                        val firebaseConsentType = when (entry.key) {
                            GoogleConsentModeType.ANALYTICS_STORAGE -> "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE"
                            GoogleConsentModeType.AD_STORAGE -> "FirebaseAnalytics.ConsentType.AD_STORAGE"
                            GoogleConsentModeType.AD_USER_DATA -> "FirebaseAnalytics.ConsentType.AD_USER_DATA"
                            GoogleConsentModeType.AD_PERSONALIZATION -> "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION"
                            GoogleConsentModeType.FUNCTIONALITY_STORAGE -> "Opzionale da abilitare nel configuratore"
                            GoogleConsentModeType.PERSONALIZATION_STORAGE -> "Opzionale da abilitare nel configuratore"
                            GoogleConsentModeType.SECURITY_STORAGE -> "Opzionale da abilitare nel configuratore"
                        }

                        val firebaseConsentStatus = when (entry.value) {
                            GoogleConsentModeStatus.GRANTED -> "FirebaseAnalytics.ConsentStatus.GRANTED"
                            GoogleConsentModeStatus.DENIED -> "FirebaseAnalytics.ConsentStatus.DENIED"
                            GoogleConsentModeStatus.UNKNOWN -> "Non mappato nel caso in cui non siano disponibili i tipi opzionali."
                        }

                        firebaseConsentType to firebaseConsentStatus
                    }

                    CmpLogger.d("Firebase mapping $firebaseConsentMap")
                }
            },
            {
                CmpLogger.d("La CMP UI è stata chiusa (chiamata poco prima del consenso pronto)")
            },
            {
                CmpLogger.d("La CMP UI è stata mostrata")
            },
            {
                CmpLogger.d("Un errore è stato lanciato dalla CMP: $it")
            },
            // Esempio di utilizzo del GoogleConsentMode mapping.
            // ATTENZIONE: Questa callback è deprecata, verrà rimossa nella versione v3.0.0
            { consentMap ->
                val firebaseConsentMap = consentMap.entries.associate { entry ->
                    val firebaseConsentType = when (entry.key) {
                        GoogleConsentModeType.ANALYTICS_STORAGE -> "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE"
                        GoogleConsentModeType.AD_STORAGE -> "FirebaseAnalytics.ConsentType.AD_STORAGE"
                        GoogleConsentModeType.AD_USER_DATA -> "FirebaseAnalytics.ConsentType.AD_USER_DATA"
                        GoogleConsentModeType.AD_PERSONALIZATION -> "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION"
                    }

                    val firebaseConsentStatus = when (entry.value) {
                        GoogleConsentModeStatus.GRANTED -> "FirebaseAnalytics.ConsentStatus.GRANTED"
                        GoogleConsentModeStatus.DENIED -> "FirebaseAnalytics.ConsentStatus.DENIED"
                    }

                    firebaseConsentType to firebaseConsentStatus
                }

                CmpLogger.d("Firebase mapping $firebaseConsentMap")
            }
        )

		// Creazione della configurazione per avviare la CMP.
        val cmpConfig = CmpConfig("your_cmp_id", appName = "your_app_name", true, cmpCallbacks)

		// Avvio della CMP.
        cmp.run(this, cmpConfig)

        val button = findViewById<Button>(R.id.button)

        // Utilizzo del metodo showNotice (il precedente askConsent nella 2.0.0) per associarlo ad un bottone di riapertura della CMP.
        button.setOnClickListener {
            cmp.showNotice(this)
        }
    }
}

Java Example

import ai.pubtech.pubconsent.Cmp;
import ai.pubtech.pubconsent.CmpCallbacks;
import ai.pubtech.pubconsent.CmpConfig;
import ai.pubtech.pubconsent.dto.GoogleConsentModeStatus;
import ai.pubtech.pubconsent.dto.GoogleConsentModeType;
import ai.pubtech.pubconsent.utility.CmpLogger;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.Button;
import java.util.Map;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // (Se configuri CmpUIConfig.uiType = CmpUIType.FRAGMENT) allora devi assegnare il tuo fragmentContainerId.
        CmpUIConfig.fragmentContainerId = android.R.id.content;

        // Configurazione della UI della CMP.
        CmpUIConfig.INSTANCE.configureCenterScreen(this);

        // Creazione dell'istanza CMP.
        Cmp cmp = Cmp.INSTANCE.createInstance(this);

        // Creazione ed assegnazione della callbacks. (opzionale)
        CmpCallbacks cmpCallbacks = new CmpCallbacks(
            consentApiInterface -> {
                if (consentApiInterface.getCmpType() == CmpType.TCF_V2_GDPR) {
                    TCFGDPRConsentApi gdprConsentApi = (TCFGDPRConsentApi) consentApiInterface;
                    CmpLogger.d("La CMP è basata su TCF V2 per il GDPR ed il consenso è pronto");
                    CmpLogger.d("Il vendor 1 è abilitato?: " + cmp.isVendorConsentEnabled(1));
                    CmpLogger.d("Features: " + cmp.isFeatureCookiesEnabled());
                    CmpLogger.d("User Experience: " + cmp.isUserExperienceCookiesEnabled());
                    CmpLogger.d("Measurement: " + cmp.isMeasurementCookiesEnabled());

                    Map<String, String> firebaseConsentMap = gdprConsentApi.getGoogleConsentMode().entrySet().stream().collect(Collectors.toMap(
                        entry -> {
                            switch (entry.getKey()) {
                                case ANALYTICS_STORAGE:
                                    return "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE";
                                case AD_STORAGE:
                                    return "FirebaseAnalytics.ConsentType.AD_STORAGE";
                                case AD_USER_DATA:
                                    return "FirebaseAnalytics.ConsentType.AD_USER_DATA";
                                case AD_PERSONALIZATION:
                                    return "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION";
                                case FUNCTIONALITY_STORAGE:
                                    return "Opzionale";
                                case PERSONALIZATION_STORAGE:
                                    return "Opzionale";
                                case SECURITY_STORAGE:
                                    return "Opzionale";
                                default:
                                    return "";
                            }
                        },
                        entry -> {
                            switch (entry.getValue()) {
                                case GRANTED:
                                    return "FirebaseAnalytics.ConsentStatus.GRANTED";
                                case DENIED:
                                    return "FirebaseAnalytics.ConsentStatus.DENIED";
                                case UNKNOWN:
                                    return "Non mappato nel caso in cui non siano disponibili i tipi opzionali.";
                                default:
                                    return "";
                            }
                        }
                    ));

                    CmpLogger.d("Firebase mapping " + firebaseConsentMap);

                } else if (consentApiInterface.getCmpType() == CmpType.GOOGLE_CONSENT_MODE) {
                    GCMConsentApi gcmConsentApi = (GCMConsentApi) consentApiInterface;
                    CmpLogger.d("La CMP è basata sul Google Consent Mode ed è il consenso è pronto!");

                    Map<String, String> firebaseConsentMap = gcmConsentApi.getGoogleConsentMode().entrySet().stream().collect(Collectors.toMap(
                        entry -> {
                            switch (entry.getKey()) {
                                case ANALYTICS_STORAGE:
                                    return "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE";
                                case AD_STORAGE:
                                    return "FirebaseAnalytics.ConsentType.AD_STORAGE";
                                case AD_USER_DATA:
                                    return "FirebaseAnalytics.ConsentType.AD_USER_DATA";
                                case AD_PERSONALIZATION:
                                    return "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION";
                                case FUNCTIONALITY_STORAGE:
                                    return "Opzionale da abilitare nel configuratore";
                                case PERSONALIZATION_STORAGE:
                                    return "Opzionale da abilitare nel configuratore";
                                case SECURITY_STORAGE:
                                    return "Opzionale da abilitare nel configuratore";
                                default:
                                    return "";
                            }
                        },
                        entry -> {
                            switch (entry.getValue()) {
                                case GRANTED:
                                    return "FirebaseAnalytics.ConsentStatus.GRANTED";
                                case DENIED:
                                    return "FirebaseAnalytics.ConsentStatus.DENIED";
                                case UNKNOWN:
                                    return "Non mappato nel caso in cui non siano disponibili i tipi opzionali.";
                                default:
                                    return "";
                            }
                        }
                    ));

                    CmpLogger.INSTANCE.d("Firebase mapping " + firebaseConsentMap);
                }
            },
            () -> {
                CmpLogger.INSTANCE.d("La CMP UI è stata chiusa (chiamata poco prima del consenso pronto)");
            },
            () -> {
                CmpLogger.INSTANCE.d("La CMP UI è stata mostrata");
            },
            error -> {
                CmpLogger.INSTANCE.d("Un errore è stato lanciato dalla CMP: " + error);
            },
            consentMap -> {
                Map<String, String> firebaseConsentMap = consentMap.entrySet().stream().collect(Collectors.toMap(
                    entry -> {
                        switch (entry.getKey()) {
                            case ANALYTICS_STORAGE:
                                return "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE";
                            case AD_STORAGE:
                                return "FirebaseAnalytics.ConsentType.AD_STORAGE";
                            case AD_USER_DATA:
                                return "FirebaseAnalytics.ConsentType.AD_USER_DATA";
                            case AD_PERSONALIZATION:
                                return "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION";
                            default:
                                return "";
                        }
                    },
                    entry -> {
                        switch (entry.getValue()) {
                            case GRANTED:
                                return "FirebaseAnalytics.ConsentStatus.GRANTED";
                            case DENIED:
                                return "FirebaseAnalytics.ConsentStatus.DENIED";
                            default:
                                return "";
                        }
                    }
                ));

                CmpLogger.INSTANCE.d("Firebase mapping " + firebaseConsentMap);
            }
        );

        // Creazione della configurazione per avviare la CMP.
        CmpConfig cmpConfig = new CmpConfig("your_cmp_id", "your_app_name", true, cmpCallbacks);

        // Avvio della CMP.
        cmp.run(this, cmpConfig);

        // Pulsante di apertura CMP.
        Button button = findViewById(R.id.button);
        button.setOnClickListener(v -> cmp.showNotice(this));
    }
}

Condivisione consenso con una WebView

Se hai bisogno di riutilizzare il consenso collezionato attraverso la nostra SDK ad una WebView che punta al tuo sito web puoi consultare la documentazione Condivisione consensi alle WebView .

Configurazione del layout

Per configurare il layout puoi usare la classe CmpUIConfig con diverse opzioni di stile. Questa classe offre anche alcuni layout preimpostati come

configureHalfScreenBottom

configureHalfScreenTop

configureCenterScreen

configureSmallCenterScreen

configureLargeTopScreen

configureLargeBottomScreen

Il tipo di interfaccia utente predefinito sarà quello che utilizza la finestra popup. Puoi cambiare il tipo di interfaccia utente impostando il parametro UIConfig:

CmpUIConfig.uiType = CmpUIType.DIALOG

CmpUIConfig.uiType = CmpUIType.POPUP

CmpUIConfig.uiType = CmpUIType.FRAGMENT

CmpUIConfig.uiType = CmpUIType.ACTIVITY

Due importanti parametri determineranno il comportamento del popup e del dialogo:

Parametro	isFocusable = true	isFocusable = false
isOutsideTouchable = true	Rimuove toccando all'esterno. Può acquisire il focus per eventi di input.	Rimuove toccando all'esterno. Non acquisisce il focus o intercetta l'input della tastiera.
isOutsideTouchable = false	Non viene rimosso toccando all'esterno. Può acquisire il focus e intercettare eventi di input.	Non viene rimosso toccando all'esterno. Non acquisisce il focus o intercetta l'input della tastiera.

Comportamento del Dialog

Parametro	isFocusable = true	isFocusable = false
isOutsideTouchable = true	Rimuove con un tocco all'esterno (setCanceledOnTouchOutside(true)). Il dialogo è di default focusabile.	Il dialogo non viene chiuso toccando all'esterno e potrebbe non comportarsi come previsto poiché i dialoghi sono tipicamente focusabili.
isOutsideTouchable = false	Non viene rimosso toccando all'esterno (setCanceledOnTouchOutside(false)). Il dialogo rimane focusabile e può intercettare eventi di input.	Il dialogo non viene chiuso toccando all'esterno e potrebbe non comportarsi come previsto a causa della mancanza di focusabilità.

Esempio per il FragmentLayout:

R.id.cmpContainer è un Framelayout che potrebbe apparire così nel file xml del layout dell'attività in layout/{tua_attività}.xml.

Prevenire l'azione back quando la UI è mostrata

Per evitare la chiusura dell'interfaccia utente (UI), è necessario eseguire l'override della funzione onBackPressed e verificare che la CMP non sia mostrata. Per controllare se la UI della CMP è visualizzata, potete affidarvi alle callback precedentemente illustrate.

Inside your activity class...

override fun onBackPressed() {
   if (isCmpOpen) {
      return
   }
   super.onBackPressed()
}

Google Consent Mode ti permette di regolare il comportamento dei tag Google e del Firebase SDK in base allo stato del consenso dell'utente. Per conformarsi alla policy aggiornata di Google (EU user consent policy), il PubTech CMP supporta i quattro parametri obbligatori: ad_storage, analytics_storage, ad_user_data, e ad_personalization.

1. Imposta gli stati di consenso predefiniti (Default States) Prima che il CMP venga inizializzato, dovresti definire gli stati di consenso predefiniti nei file di configurazione della tua app.

Android (AndroidManifest.xml):Aggiungi i seguenti tag <meta-data> all'interno del tag <application>:

<meta-data android:name="google_analytics_default_allow_analytics_storage" android:value="false" />
<meta-data android:name="google_analytics_default_allow_ad_storage" android:value="false" />
<meta-data android:name="google_analytics_default_allow_ad_user_data" android:value="false" />
<meta-data android:name="google_analytics_default_allow_ad_personalization_signals" android:value="false" />

2. Sincronizzazione del consenso con Firebase SDK Devi aggiornare il Firebase SDK ogni volta che la CMP cattura o aggiorna il consenso dell'utente. Usa la callback onConsentReady per mappare i tipi di consenso di PubTech su Firebase.

import com.google.firebase.analytics.FirebaseAnalytics

val cmpCallbacks = CmpCallbacks(
    onConsentReadyCallback = { consentApi ->
        val gcm = consentApi.getGoogleConsentMode()
        val consentMap = mutableMapOf<FirebaseAnalytics.ConsentType, FirebaseAnalytics.ConsentStatus>()

        gcm?.forEach { (type, status) ->
            val firebaseType = when(type) {
                GoogleConsentModeType.ANALYTICS_STORAGE -> FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE
                GoogleConsentModeType.AD_STORAGE -> FirebaseAnalytics.ConsentType.AD_STORAGE
                GoogleConsentModeType.AD_USER_DATA -> FirebaseAnalytics.ConsentType.AD_USER_DATA
                GoogleConsentModeType.AD_PERSONALIZATION -> FirebaseAnalytics.ConsentType.AD_PERSONALIZATION
                else -> null
            }
            val firebaseStatus = if (status == GoogleConsentModeStatus.GRANTED) 
                FirebaseAnalytics.ConsentStatus.GRANTED else FirebaseAnalytics.ConsentStatus.DENIED

            firebaseType?.let { consentMap[it] = firebaseStatus }
        }
        FirebaseAnalytics.getInstance(context).setConsent(consentMap)
    }
)

3. Verifica Per verificare che i segnali vengano inviati correttamente:

Esegui adb shell setprop log.tag.FA-SVC VERBOSE e controlla Logcat cercando la stringa "Setting consent".

SDK & APIs Documentation

Cmp class

Constructors

Cmp(Context context)

Descrizione: Inizializza il CMP con il contesto specificato e l'ID della vista del contenuto.

Parametri:

context: Il context della tua application/activity.

Public Methods

run(Context context, CmpConfig cmpConfig)

Descrizione: Avvia il CMP con la configurazione fornita.

Parametri:

context: Il context della tua application/activity.

cmpConfig: L'oggetto di configurazione per il CMP.

Uso: Questo metodo inizializza e avvia il CMP con la configurazione specificata.

showNotice(Activity activity)

Descrizione: Visualizza la finestra del CMP per chiedere il consenso dell'utente.

Parametri:

activity: Il contesto dell'attività dove verrà visualizzata la finestra del CMP.

Uso: Chiama questo metodo per richiedere il consenso dell'utente utilizzando la finestra del CMP (per implementare il bottone di riapertura).

CmpConfig Class

Constructors

CmpConfig(id: String, appName: String, callbacks: CmpCallbacks, debug: Boolean, retryConfig: RetryConfig)

Descrizione: Constructs a configuration object for the CMP.

Parametri:

id: L'ID del CMP.

appName: Il nome dell'applicazione.

callbacks: Funzioni di callback per gli eventi del CMP.

debug: Per scopi di debug.

retryConfig: Per configurare i parametri disponibili dal meccanismo di riprova.

RetryConfig Class

Constructors

RetryConfig(maxRetries: Int, retryDelay: Int, retriesBackOffFactor: Double, timeout: Long)

Descrizione: Oggetto per il meccanismo di retry di apertura della CMP nel caso di problemi con la rete.

Parametri:

maxRetries: Il numero massimo di tentativi di riprova. Il valore predefinito è 3.

retryDelay: Il ritardo (in millisecondi) tra i tentativi di riprova consecutivi. Il valore predefinito è 200.

retriesBackOffFactor: Il fattore con cui il ritardo di riprova dovrebbe essere moltiplicato per il ritardo esponenziale. Il valore predefinito è 1.3.

timeout: La durata massima (in millisecondi) entro la quale i tentativi di riprova devono essere completati. Il valore predefinito è 7500.

CmpCallbacks Interface

Methods

onConsentReadyCallback(consentApiInterface: ConsentApiInterface)

Descrizione: Callback function chiamata quando il consenso è presente.

Nota: In seguito trovate la documentazione sulle implementazioni disponibili dell'interfaccia ConsentApiInterface

onCmpUIClosedCallback()

Descrizione: Callback function chiamata quando la UI della CMP viene chiusa.

onCmpUIOpenCallback()

Descrizione: Callback function chiamata quando la UI della CMP viene mostrata all'utente.

onErrorCallback(error: String)

Descrizione: Callback function chiamata quando accade un errore.

Parametri:

error: Descrizione dell'errore.

onGoogleConsentModeCallback(consentMap: Map<Int, Int>)

Descrizione: Callback function chiamata quando il mapping per il Google Consent Mode è pronto.

Parametri:

consentMap: contiente il mapping dei consensi per Google Consent Mode.

PubConsent ConsentApiInterface

Utilizzando l'API esposta tramite onConsentReadyCallback potete verificare tramite il metodo getCmpType() quali delle seguenti implementazioni avete a disposizione (questa scelta dipende dalla configurazione salvata attraverso il configuratore PubConsent). Di seguito vi mostriamo le API per ogni CMP Type che offriamo seguenti metodi sono accessibili tramite l'istanza consentApiInstance: any PubConsent.ConsentApiInterface disponibile come parametro alla callback: onConsentReadyCallback

API per il CmpType.TCF_V2_GDPR

Quando il consenso è relativo alla CMP TCF (ovvero consentApiInterface.getCmpType() == CmpType.TCF_V2_GDPR) avrete a disposizione le seguenti API:

isVendorConsentEnabled(vendorId: Int): Boolean

Descrizione: Verifica se il consenso è abilitato per un fornitore specifico.

Parametri:

vendorId: L'ID del fornitore per cui verificare il consenso.

Returns: true se il consenso è abilitato per il fornitore specificato, altrimenti false.

Uso: Utilizza questo metodo per determinare se il consenso è stato concesso per un particolare fornitore.

isPurposeConsentEnabled(purposeId: Int): Boolean

Descrizione: Verifica se il consenso è abilitato per un fornitore specifico.

Parametri:

purposeId: L'ID dello scopo per il quale verificare il consenso.

Returns: true se il consenso è abilitato per lo scopo specificato, altrimenti false.

Uso: Utilizza questo metodo per determinare se il consenso è stato concesso per uno scopo particolare.

isFeatureCookiesEnabled(): Boolean

Descrizione: Verifica se il consenso è abilitato per i cookie delle funzionalità.

Returns: true se il consenso è abilitato per i cookie delle funzionalità, altrimenti false.

Uso: Utilizza questo metodo per determinare se il consenso è stato concesso per i cookie delle funzionalità.

isUserExperienceCookiesEnabled(): Boolean

Descrizione: Verifica se il consenso è abilitato per i cookie dell'esperienza utente.

Returns: true Se il consenso è abilitato per i cookie dell'esperienza utente, altrimenti false.

Uso: Utilizza questo metodo per determinare se il consenso è stato concesso per i cookie dell'esperienza utente.

isMeasurementCookiesEnabled(): Boolean

Descrizione: Verifica se il consenso è abilitato per i cookie di misurazione.

Returns: true se il consenso è abilitato per i cookie di misurazione, altrimenti.

Uso: Utilizza questo metodo per determinare se il consenso è stato concesso per i cookie di misurazione.

getGoogleConsentMode() : Map<GoogleConsentModeType, GoogleConsentModeStatus>?

Descrizione: Recupera lo stato del Google Consent Mode per i vari tipi di consenso supportati.

Returns: Una mappa contenente i tipi di consenso (GoogleConsentModeType) e il relativo stato (GoogleConsentModeStatus). Restituisce null se nessuna configurazione è disponibile.

Uso: Utilizza questo metodo per ottenere lo stato dei consensi associati al Google Consent Mode e determinare se il consenso è stato concesso, negato o è sconosciuto per ciascun tipo di consenso.

API per il CmpType.GOOGLE_CONSENT_MODE

Quando il consenso è relativo alla CMP basata solo su Google Consent Mode (ovvero consentApiInterface.getCmpType() == CmpType.GOOGLE_CONSENT_MODE) avrete a disposizione le seguenti API:

getGoogleConsentMode() : Map<GoogleConsentModeType, GoogleConsentModeStatus>?

Descrizione: Recupera lo stato del Google Consent Mode per i vari tipi di consenso supportati.

Returns: Una mappa contenente i tipi di consenso (GoogleConsentModeType) e il relativo stato (GoogleConsentModeStatus). Restituisce null se nessuna configurazione è disponibile.

Uso: Utilizza questo metodo per ottenere lo stato dei consensi associati al Google Consent Mode e determinare se il consenso è stato concesso, negato o è sconosciuto per ciascun tipo di consenso.

Troubleshooting

ProGuard bugs

ProGuard può talvolta offuscare i nomi delle classi o rimuovere i metodi che vengono richiamati dinamicamente tramite reflection. Per risolvere questo problema, è necessario specificare le classi e i metodi che devono rimanere intatti nel file di configurazione di ProGuard utilizzando la direttiva -keep.

Integrazione Android

Installazione

Come funziona

Kotlin Example

Java Example

Condivisione consenso con una WebView

Configurazione del layout

Comportamento del Popup

Comportamento del Dialog

Esempio per il FragmentLayout:

Prevenire l'azione back quando la UI è mostrata

Integrazione Google Consent Mode (v2)

SDK & APIs Documentation

Cmp class

CmpConfig Class

RetryConfig Class

CmpCallbacks Interface

PubConsent ConsentApiInterface

API per il CmpType.TCF_V2_GDPR

API per il CmpType.GOOGLE_CONSENT_MODE

Troubleshooting

ProGuard bugs