PubConsent
Android Integration

17min
The PubConsent SDK is the integration of our PubConsent CMP into Android applications.
The strength of our integration is that it does not require many updates since any changes made within the configurator will be automatically reflected within the app (excluding some specific configurations that need to be done programmatically).
Minimum SDK version: 21
Every time significant changes are introduced, you will be contacted via email at the technical address you have configured in our dashboard, allowing you to update the SDK version to the latest one we have published.
For more API or more info of how it works needed don't hesitate to contact our customer support. Every bug or problems during the integration will be a great feedback for us, please don't hesitate to contact us, your satisfaction is our great reward.
Setup
To use the PubConsent SDK in your Android project, add the following dependency to your build.gradle:
Our CMP SDK is available on Maven Central here.
Text
implementation 'ai.pubtech.pubconsent:pubconsent-sdk:2.0.0'
implementation 'ai.pubtech.pubconsent:pubconsent-sdk:2.0.0'
﻿
Permissions
This SDK requires the following permissions, please ensure to add them to yourAndroidManifest.xml:
Text
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
﻿
How it works
Once the SDK is integrated into an app, it will automatically prompt and display the user interface if necessary.
The SDK will retrieve information from our server to prepare and provide your CMP, which you have configured through our dashboard.
When the app wants to process personal data, it should "ask" the SDK if consent has been given for the specific purpose and provider.
Kotlin Example
Kotlin
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)

       // Configure the fragmentContainerId if you use the Cmp inside a ActivityFragment ->> CmpUIConfig.uiType = CmpUIType.FRAGMENT
       CmpUIConfig.fragmentContainerId = android.R.id.content

       // Choose how to see the CMP
       CmpUIConfig.configureCenterScreen(this)

       val cmp = Cmp.createInstance(this)

		// Create CmpCallbacks (this is optional)
        val cmpCallbacks = CmpCallbacks(
            { consentApiInterface ->
                if (consentApiInterface.getCmpType() == CmpType.TCF_V2_GDPR) {
                    consentApiInterface as TCFGDPRConsentApi
                    CmpLogger.d("FROM MY APP consent ready and it's a TCF V2 GDPR")
                    CmpLogger.d("Vendor expo is enabled: ${consentApiInterface.isVendorConsentEnabled(1)}")
                    CmpLogger.d("Features: ${consentApiInterface.isFeatureCookiesEnabled()}")
                    CmpLogger.d("User Experience: ${consentApiInterface.isUserExperienceCookiesEnabled()}")
                    CmpLogger.d("Measurement: ${consentApiInterface.isMeasurementCookiesEnabled()}")

                    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("From CMP SDK the UI was closed")
            },
            {
                CmpLogger.d("From CMP SDK the UI showed")
            },
            {
                CmpLogger.d("From CMP SDK error: $it")
            },
            { consentMap ->
            //WARNING: This callback will be deleted in v3.0.0 use the consentApiInterface as explained before. 
                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")
            }
        )

		// Create CmpConfig
        val cmpConfig = CmpConfig("your_cmp_id", appName = "your_app_name", true, cmpCallbacks)

		// Run the Cmp by providing the CmpConfig
        cmp.run(cmpConfig)

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

        // Set a button to open the CMP so to re-ask consent to the user
        button.setOnClickListener {
            cmp.askConsent(this)
        }
    }
}

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)

       // Configure the fragmentContainerId if you use the Cmp inside a ActivityFragment ->> CmpUIConfig.uiType = CmpUIType.FRAGMENT
       CmpUIConfig.fragmentContainerId = android.R.id.content

       // Choose how to see the CMP
       CmpUIConfig.configureCenterScreen(this)

       val cmp = Cmp.createInstance(this)

		// Create CmpCallbacks (this is optional)
        val cmpCallbacks = CmpCallbacks(
            { consentApiInterface ->
                if (consentApiInterface.getCmpType() == CmpType.TCF_V2_GDPR) {
                    consentApiInterface as TCFGDPRConsentApi
                    CmpLogger.d("FROM MY APP consent ready and it's a TCF V2 GDPR")
                    CmpLogger.d("Vendor expo is enabled: ${consentApiInterface.isVendorConsentEnabled(1)}")
                    CmpLogger.d("Features: ${consentApiInterface.isFeatureCookiesEnabled()}")
                    CmpLogger.d("User Experience: ${consentApiInterface.isUserExperienceCookiesEnabled()}")
                    CmpLogger.d("Measurement: ${consentApiInterface.isMeasurementCookiesEnabled()}")

                    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("From CMP SDK the UI was closed")
            },
            {
                CmpLogger.d("From CMP SDK the UI showed")
            },
            {
                CmpLogger.d("From CMP SDK error: $it")
            },
            { consentMap ->
            //WARNING: This callback will be deleted in v3.0.0 use the consentApiInterface as explained before. 
                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")
            }
        )

		// Create CmpConfig
        val cmpConfig = CmpConfig("your_cmp_id", appName = "your_app_name", true, cmpCallbacks)

		// Run the Cmp by providing the CmpConfig
        cmp.run(cmpConfig)

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

        // Set a button to open the CMP so to re-ask consent to the user
        button.setOnClickListener {
            cmp.askConsent(this)
        }
    }
}
﻿
Java Example
Java
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;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Configure the fragmentContainerId if you use the Cmp inside an ActivityFragment ->> CmpUIConfig.uiType = CmpUIType.FRAGMENT
        CmpUIConfig.INSTANCE.fragmentContainerId = android.R.id.content;

        // Choose how to see the CMP
        CmpUIConfig.INSTANCE.configureCenterScreen(this);

        Cmp cmp = Cmp.createInstance(this);

        // Create CmpCallbacks (this is optional)
        CmpCallbacks cmpCallbacks = new CmpCallbacks(
            consentApiInterface -> {
                if (consentApiInterface.getCmpType() == CmpType.TCF_V2_GDPR) {
                    TCFGDPRConsentApi gdprConsentApi = (TCFGDPRConsentApi) consentApiInterface;
                    CmpLogger.d("Based on TCF V2 for GDPR ed consent is ready");
                    CmpLogger.d("The vendor with ID 1 is enabled: " + 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 "Not mapped in case optional types aren't used.";
                                default:
                                    return "";
                            }
                        }
                    ));

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

                } else if (consentApiInterface.getCmpType() == CmpType.GOOGLE_CONSENT_MODE) {
                    GCMConsentApi gcmConsentApi = (GCMConsentApi) consentApiInterface;
                    CmpLogger.d("Consent Ready with CMP based on Google Consent Mode only!");

                    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 "Can be enabled within the configurator.";
                                case PERSONALIZATION_STORAGE:
                                    return "Can be enabled within the configurator.";
                                case SECURITY_STORAGE:
                                    return "Can be enabled within the configurator.";
                                default:
                                    return "";
                            }
                        },
                        entry -> {
                            switch (entry.getValue()) {
                                case GRANTED:
                                    return "FirebaseAnalytics.ConsentStatus.GRANTED";
                                case DENIED:
                                    return "FirebaseAnalytics.ConsentStatus.DENIED";
                                case UNKNOWN:
                                    return "Optional types can be unknown if they aren't enabled within the configurator.";
                                default:
                                    return "";
                            }
                        }
                    ));

                    CmpLogger.INSTANCE.d("Firebase mapping " + firebaseConsentMap);
                }
            },
            () -> {
                CmpLogger.INSTANCE.d("From CMP SDK the UI was closed");
            },
            () -> {
                CmpLogger.INSTANCE.d("From CMP SDK the UI showed");
            },
            it -> {
                CmpLogger.INSTANCE.d("From CMP SDK error: " + it);
            },
            consentMap -> {
                //WARNING: This callback will be deleted in v3.0.0 use the consentApiInterface as explained before. 
                Map<String, String> firebaseConsentMap = new HashMap<>();
                for (Map.Entry<GoogleConsentModeType, GoogleConsentModeStatus> entry : consentMap.entrySet()) {
                    String firebaseConsentType = null;
                    switch (entry.getKey()) {
                        case ANALYTICS_STORAGE:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE";
                            break;
                        case AD_STORAGE:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.AD_STORAGE";
                            break;
                        case AD_USER_DATA:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.AD_USER_DATA";
                            break;
                        case AD_PERSONALIZATION:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION";
                            break;
                    }

                    String firebaseConsentStatus = null;
                    switch (entry.getValue()) {
                        case GRANTED:
                            firebaseConsentStatus = "FirebaseAnalytics.ConsentStatus.GRANTED";
                            break;
                        case DENIED:
                            firebaseConsentStatus = "FirebaseAnalytics.ConsentStatus.DENIED";
                            break;
                    }

                    if (firebaseConsentType != null && firebaseConsentStatus != null) {
                        firebaseConsentMap.put(firebaseConsentType, firebaseConsentStatus);
                    }
                }

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

        // Create CmpConfig
        CmpConfig cmpConfig = new CmpConfig("your_cmp_id", "your_app_name", true, cmpCallbacks);

        // Run the Cmp by providing the CmpConfig
        cmp.run(cmpConfig);

        Button button = findViewById(R.id.button);

        // Set a button to open the CMP so to re-ask consent to the user
        button.setOnClickListener(view -> cmp.askConsent(this));
    }
}
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;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Configure the fragmentContainerId if you use the Cmp inside an ActivityFragment ->> CmpUIConfig.uiType = CmpUIType.FRAGMENT
        CmpUIConfig.INSTANCE.fragmentContainerId = android.R.id.content;

        // Choose how to see the CMP
        CmpUIConfig.INSTANCE.configureCenterScreen(this);

        Cmp cmp = Cmp.createInstance(this);

        // Create CmpCallbacks (this is optional)
        CmpCallbacks cmpCallbacks = new CmpCallbacks(
            consentApiInterface -> {
                if (consentApiInterface.getCmpType() == CmpType.TCF_V2_GDPR) {
                    TCFGDPRConsentApi gdprConsentApi = (TCFGDPRConsentApi) consentApiInterface;
                    CmpLogger.d("Based on TCF V2 for GDPR ed consent is ready");
                    CmpLogger.d("The vendor with ID 1 is enabled: " + 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 "Not mapped in case optional types aren't used.";
                                default:
                                    return "";
                            }
                        }
                    ));

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

                } else if (consentApiInterface.getCmpType() == CmpType.GOOGLE_CONSENT_MODE) {
                    GCMConsentApi gcmConsentApi = (GCMConsentApi) consentApiInterface;
                    CmpLogger.d("Consent Ready with CMP based on Google Consent Mode only!");

                    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 "Can be enabled within the configurator.";
                                case PERSONALIZATION_STORAGE:
                                    return "Can be enabled within the configurator.";
                                case SECURITY_STORAGE:
                                    return "Can be enabled within the configurator.";
                                default:
                                    return "";
                            }
                        },
                        entry -> {
                            switch (entry.getValue()) {
                                case GRANTED:
                                    return "FirebaseAnalytics.ConsentStatus.GRANTED";
                                case DENIED:
                                    return "FirebaseAnalytics.ConsentStatus.DENIED";
                                case UNKNOWN:
                                    return "Optional types can be unknown if they aren't enabled within the configurator.";
                                default:
                                    return "";
                            }
                        }
                    ));

                    CmpLogger.INSTANCE.d("Firebase mapping " + firebaseConsentMap);
                }
            },
            () -> {
                CmpLogger.INSTANCE.d("From CMP SDK the UI was closed");
            },
            () -> {
                CmpLogger.INSTANCE.d("From CMP SDK the UI showed");
            },
            it -> {
                CmpLogger.INSTANCE.d("From CMP SDK error: " + it);
            },
            consentMap -> {
                //WARNING: This callback will be deleted in v3.0.0 use the consentApiInterface as explained before. 
                Map<String, String> firebaseConsentMap = new HashMap<>();
                for (Map.Entry<GoogleConsentModeType, GoogleConsentModeStatus> entry : consentMap.entrySet()) {
                    String firebaseConsentType = null;
                    switch (entry.getKey()) {
                        case ANALYTICS_STORAGE:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.ANALYTICS_STORAGE";
                            break;
                        case AD_STORAGE:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.AD_STORAGE";
                            break;
                        case AD_USER_DATA:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.AD_USER_DATA";
                            break;
                        case AD_PERSONALIZATION:
                            firebaseConsentType = "FirebaseAnalytics.ConsentType.AD_PERSONALIZATION";
                            break;
                    }

                    String firebaseConsentStatus = null;
                    switch (entry.getValue()) {
                        case GRANTED:
                            firebaseConsentStatus = "FirebaseAnalytics.ConsentStatus.GRANTED";
                            break;
                        case DENIED:
                            firebaseConsentStatus = "FirebaseAnalytics.ConsentStatus.DENIED";
                            break;
                    }

                    if (firebaseConsentType != null && firebaseConsentStatus != null) {
                        firebaseConsentMap.put(firebaseConsentType, firebaseConsentStatus);
                    }
                }

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

        // Create CmpConfig
        CmpConfig cmpConfig = new CmpConfig("your_cmp_id", "your_app_name", true, cmpCallbacks);

        // Run the Cmp by providing the CmpConfig
        cmp.run(cmpConfig);

        Button button = findViewById(R.id.button);

        // Set a button to open the CMP so to re-ask consent to the user
        button.setOnClickListener(view -> cmp.askConsent(this));
    }
}
﻿
Layout configuration
For configuring the layout you can use the CmpUIConfig class with different styling options. This class offers also some preset layouts like
configureHalfScreenBottom
configureHalfScreenTop
configureCenterScreen
configureSmallCenterScreen
configureLargeTopScreen
configureLargeBottomScreen
The default UI type will be the one that use the Popup Window, you can change the UI Type by setting the UIConfig parameter:
CmpUIConfig.uiType = CmpUIType.DIALOG
CmpUIConfig.uiType = CmpUIType.POPUP
CmpUIConfig.uiType = CmpUIType.FRAGMENT
CmpUIConfig.uiType = CmpUIType.ACTIVITY
Two important parameter will determine the Popup and Dialog behaviour:
Popup behaviour
Parameter
isFocusable = true
isFocusable = false
isOutsideTouchable =  true
Dismisses on outside touch. Can gain focus for input events.
Dismisses on outside touch. Does not gain focus or intercept keyboard input.
isOutsideTouchable = false
Does not dismiss on outside touch. Can gain focus and intercept input events.
Does not dismiss on outside touch. Does not gain focus or intercept keyboard input.
Dialog behaviour
Parameter
isFocusable = true
isFocusable = false
isOutsideTouchable =  true
Dismisses on outside touch (setCanceledOnTouchOutside(true)). Dialog is focusable by default.
Dialog does not dismiss on outside touch and might not behave as expected since dialogs are typically focusable.
isOutsideTouchable = false
Does not dismiss on outside touch (setCanceledOnTouchOutside(false)). Dialog remains focusable and can intercept input events.
Dialog does not dismiss on outside touch and might not behave as expected due to the lack of focusability.
Example of FragmentLayout:
R.id.cmpContainer is a Framelayout which could look like this in the activity layout xml in layout/{your_activity}.xml
Preventing the Back Action When the UI is Displayed
To prevent the closure of the UI, you need to override the onBackPressed function and check whether the CMP (Consent Management Platform) is being displayed. To verify that the CMP UI is shown, you can rely on the previously shown callbacks.
Kotlin
Inside your activity class...

override fun onBackPressed() {
   if (isCmpOpen) {
      return
   }
   super.onBackPressed()
}
Inside your activity class...

override fun onBackPressed() {
   if (isCmpOpen) {
      return
   }
   super.onBackPressed()
}
﻿
SDK APIs
Cmp class
Constructors
 Cmp(Context context)
Description: Initializes the CMP with the specified context and the ID of the content view.
Parameters:
context: The context of the application/activity.
Public Methods
 run(CmpConfig cmpConfig)
Description: Runs the CMP with the provided configuration.
Parameters:
cmpConfig: The configuration object for the CMP.
Usage: This method initializes and starts the CMP with the specified configuration.
 askConsent(Activity activity)
Description: Displays the CMP window to ask for user consent.
Parameters:
activity: The activity context where the CMP window will be displayed.
Usage: Call this method to prompt the user for consent using the CMP window.
 isVendorConsentEnabled(vendorId: Int): Boolean
Description: Checks if consent is enabled for a specific vendor.
Parameters:
vendorId: The ID of the vendor to check consent for.
Returns: true if consent is enabled for the specified vendor,  otherwise.
Usage: Use this method to determine if consent is granted for a particular vendor.
 isPurposeConsentEnabled(purposeId: Int): Boolean
Description: Checks if consent is enabled for a specific vendor.
Parameters:
purposeId: The ID of the purpose to check consent for.
Returns: true  if consent is enabled for the specified purpose,  otherwise.
Usage: Use this method to determine if consent is granted for a particular purpose.
 isFeatureCookiesEnabled(): Boolean
Description: Checks if consent is enabled for feature cookies.
Returns:  true if consent is enabled for feature cookies,  otherwise.
Usage: Use this method to determine if consent is granted for feature cookies.
 isUserExperienceCookiesEnabled(): Boolean
Description: Checks if consent is enabled for user experience cookies.
Returns: true  if consent is enabled for user experience cookies,  otherwise.
Usage: Use this method to determine if consent is granted for user experience cookies.
 isMeasurementCookiesEnabled(): Boolean
Description: Checks if consent is enabled for measurement cookies.
Returns: true  if consent is enabled for measurement cookies,  otherwise.
Usage: Use this method to determine if consent is granted for measurement cookies.
CmpConfig Class
Constructors
 CmpConfig(id: String, appName: String, callbacks: CmpCallbacks, debug: Boolean, retryConfig: RetryConfig)
Description: Constructs a configuration object for the CMP.
Parameters:
id: The ID of the CMP.
appName: The name of the application.
callbacks: Callback functions for CMP events.
debug: For debugging purpose.
retryConfig: For configuring the parameters available by the retry mechanism.
RetryConfig Class
Constructors
 RetryConfig(maxRetries: Int, retryDelay: Int, retriesBackOffFactor: Double, timeout: Long)
Description: Constructs a configuration object for the retry mechanism that fetch the CMP.
Parameters:
maxRetries:  The maximum number of retry attempts. Default is 3.
retryDelay: The delay (in milliseconds) between consecutive retry attempts. Default is 200.
retriesBackOffFactor: The factor by which the retry delay should be multiplied for exponential backoff. Default is 1.3.
timeout: The maximum duration (in milliseconds) within which the retry attempts must complete. Default is 7500.
CmpCallbacks Interface
Methods
 onConsentReadyCallback()
Description: Callback function invoked when consent is ready.
 onCmpUIClosedCallback()
Description: Callback function invoked when the CMP window is closed.
 onCmpUIOpenCallback()
Description: Callback function invoked when the CMP window is opened.
 onErrorCallback(error: String)
Description: Callback function invoked when an error occurs.
Parameters:
error: Description of the error.
 onGoogleConsentModeCallback(consentMap: Map<Int, Int>)
Description: Callback function invoked when the google consent mapping is ready.
Parameters:
consentMap: Map containing consent mappings.
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.
Parameter	isFocusable = true	isFocusable = false
isOutsideTouchable = true	Dismisses on outside touch. Can gain focus for input events.	Dismisses on outside touch. Does not gain focus or intercept keyboard input.
isOutsideTouchable = false	Does not dismiss on outside touch. Can gain focus and intercept input events.	Does not dismiss on outside touch. Does not gain focus or intercept keyboard input.
Parameter	isFocusable = true	isFocusable = false
isOutsideTouchable = true	Dismisses on outside touch (setCanceledOnTouchOutside(true)). Dialog is focusable by default.	Dialog does not dismiss on outside touch and might not behave as expected since dialogs are typically focusable.
isOutsideTouchable = false	Does not dismiss on outside touch (setCanceledOnTouchOutside(false)). Dialog remains focusable and can intercept input events.	Dialog does not dismiss on outside touch and might not behave as expected due to the lack of focusability.
Updated 24 Sep 2024
Did this page help you?
AMP Integration
iOS Integration