Skip to main content

Examples

Full description of the integration example below

In this example, we'll make sure that the CMP is displayed to users when the application is launched (startup of our activity).

Here are the various steps in this example at first launch​

  1. Check SDK if already initialized (return false)
  2. Initialize the CMP by calling AppConsentSDK#initialize if not.
  3. Once the SDK has been started, record callbacks to let you know when the user has finished entering information.
  4. Call the #tryToDisplayNoticeFromUiContext(uiContext, false) method, which displays the CMP only when necessary. (in the example, it will be displayed).
  5. check the return of #tryToDisplayNoticeFromUiContext(uiContext, false) to determine whether the CMP has been displayed or not (return to true).
  6. Once the user has given their consent, the #presentConsentGiven method will be called and you can, for example, start up your PUB SDK (AdMob, Vungle, Amazon mobile Ads, etc.).

Here are the various steps in this example on the next launch (having killed the application)​

  1. Check SDK if it has already been initialized (return false)
  2. Initialize the CMP by calling AppConsentSDK#initialize, if not.
  3. Once the SDK has been started, record callbacks to let you know when the user has finished entering information.
  4. Call the #tryToDisplayNoticeFromUiContext(uiContext, false) method, which displays the CMP only if necessary.
  5. check the return of #tryToDisplayNoticeFromUiContext(uiContext, false) to determine whether or not the CMP has been displayed (result set to false).
  6. (By your own) Try to call the #checkForUpdate method to check whether the Notice has been updated from your Dashboard (unless you take action, result is false).
  7. No action is required, so you can start up your PUB SDK (AdMob, Vungle, Amazon mobile Ads, etc.).

Here are the various steps in this example on the next launch (quitting the application and bringing it forward again without killing it)​

  1. Check SDK if it has already been initialized (return to true)
  2. Recover instance for local use in our activity
  3. Call the #tryToDisplayNoticeFromUiContext(uiContext, false) method, which displays the CMP only if necessary.
  4. check the return of #tryToDisplayNoticeFromUiContext(uiContext, false) to determine whether the CMP has been displayed or not (result set to false).
  5. (By your own) Try to call the #checkForUpdate method to check whether the Notice has been updated from your Dashboard (unless you take action, result is false).
  6. No action is required, so you can start up your PUB SDK (AdMob, Vungle, Amazon mobile Ads, etc.).

Here are the various steps in this example at the next launch AND after you've modified your Notice from the Dashboard (by quitting the application and bringing it forward again without killing it)​

  1. Check SDK if it has already been initialized (return to true)
  2. Recover instance for local use in our activity
  3. Call the #tryToDisplayNoticeFromUiContext(uiContext, false) method, which displays the CMP only if necessary.
  4. check the return of #tryToDisplayNoticeFromUiContext(uiContext, false) to determine whether the CMP has been displayed or not (result set to false).
  5. (By your own) Try to call the #checkForUpdate method to check whether the Notice has been updated from your Dashboard (result is true because your Notice has been updated).
  6. Local deletion of previous user consent #clearConsent
  7. Call the #tryToDisplayNoticeFromUiContext(uiContext, false) method to display the CMP only if necessary. (return to true)
  8. Once the user has given consent, the #presentConsentGiven method will be called and you can, for example, start your PUB SDK (AdMob, Vungle, Amazon mobile Ads, etc.).
import com.sfbx.appconsentv3.AppConsent
import com.sfbx.appconsentv3.ui.AppConsentSDK
import com.sfbx.appconsentv3.ui.listener.OnPresentNoticeListener
import com.sfbx.appconsentv3.ui.model.ACConfiguration

class MainActivity : AppCompatActivity() {

    private var appConsent: AppConsent? = null
    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)

        setContentView(binding.root)

        /*
        Shows whether the SDK has already been initialized
         */
        if (!AppConsentSDK.isSdkInitialized() || AppConsentSDK.getInstance() == null) {
            initCmpModule()
        } else {
            if (appConsent == null) {
                /*
                Retrieves the AppConsent instance or null if it has not yet been instantiated, for example
                 */
                appConsent = AppConsentSDK.getInstance()
            }
            tryToDisplayCmpAndCheckUpdateIfNeeded()
        }
    }

    /**
     * The only conditions for using this method would be if:
     * - you have configured your Notice by selecting this option: When saving changes to the notice, display the notice to all visitors.
     * - you plan to update your Notice often (more often than the : Consent retention period configurable in your Notice)
     * - Your users rarely restart your application.
     *
     * In which case, using this method from time to time may be a solution.
     *
     * But we encourage you to let the SDK handle this part on its own.
     */
    private fun checkIfNoticeHasBeenUpdated() {
        appConsent?.checkForUpdate(
            { isNeedToPresentTheCmp ->
                // Your Notice has been updated, you must represent the CMP to your users
                if (true == isNeedToPresentTheCmp) {
                    /*
                    Deletes old user consent locally.
                    This step is not mandatory, but it avoids the need to make another network call
                    to check whether the Notice has been updated,
                    as no consent will be present on the user's device.
                     */
                    appConsent?.clearConsent()

                    /*
                    Remember to re-register for callbacks if you have previously removed them,
                    otherwise you will not know when the user has given their consent.
                     */
                    registerCallbacks()
                    if (false == tryToDisplayCMP()) {
                        /*
                         At this stage, if the CMP is not displayed, it is possible, for example:
                         that the user is no longer in a geographical area subject to GDPR
                         */
                        removeCMPCallback()
                    }
                } else {
                    /*
                    The Notice is the same as when it was last checked
                    (you have made no changes since the board or
                    it has not been updated internally by us, e.g. by updating a vendor)
                     */
                }
            },
            { _ ->
                /*
                 An error has occurred
                 */
            })
    }

    /**
     * Try to display the CMP
     *
     * @return true, if the CMP displaying, false otherwise
     */
    private fun tryToDisplayCMP(): Boolean {
        /*
         Try to display the CMP according to certain rules.
         */
        return appConsent?.tryToDisplayNoticeFromUiContext(uiContext = this@MainActivity, false) == true
    }

    private fun tryToDisplayCmpAndCheckUpdateIfNeeded() {
        /*
         Try to display the CMP according to certain rules first.
         */
        if (false == tryToDisplayCMP()) {
            /*
             The user has already given consent;
             The user is not part of an area subject to the application of GDPR;
             etc.
             */
            removeCMPCallback()

            /*
            The Notice has not been displayed,
            so we'll have to check whether it has been updated
            and whether it needs to be shown to users again.
             */
            checkIfNoticeHasBeenUpdated()
        }
    }

    private fun registerCallbacks() {
        /*
         Registers with CMP callback to know when the user
         has given consent, or if an error has occurred
         */
        appConsent?.setOnPresentNoticeListener(object : OnPresentNoticeListener {
            override fun presentConsentError(error: Throwable?) {
                /*
                 An error has occurred
                 */
                removeCMPCallback()
            }

            override fun presentConsentGiven() {
                /*
                The user has given his consent
                */
                appConsent?.let { appConsentNN ->
                    updateFirebaseConsent(appConsentNN)
                }
                removeCMPCallback()
            }
        })
    }

    /*
     Initializes the consent management platform module when the activity is created
     */
    private fun initCmpModule() {
        /*
        ACConfiguration is used to configure the CMP.
        In this example:
        - We set forceApplyGDPR to true to display the CMP regardless of the user's region.
        - Decide to display the CMP in FullScreen rather than modal.
        - CMP is configured so that layer 1 buttons are displayed vertically and not horizontally (except in landscape mode).
        - We configure CMP so that hypertext links are no longer displayed in a webview and/or the user is redirected outside the application if the requested link is a file, for example; instead, a popup presenting a qr code will be presented to your users (mostly useful on Automotive / Tablet)
         */
        val acConfiguration = ACConfiguration.Builder()
            .setForceApplyGDPR(true)
            .setFullScreenMode(true)
            .setNeedToDisplayValidationButtonsVertically(isNeedToDisplayButtonsAtVertical = true)
            .setNeedToReplaceUrlViewerByQrCode(isNeedToReplaceUrlViewerByQrCode = true)
            .build()

        AppConsentSDK.initialize(
            appKey = "YOUR_APPKEY",
            configuration = acConfiguration
        ) { appConsentInitialized ->
            /*
             To avoid certain problems, use the instance received by the onReady callback
             This has been successfully initialized
             */
            appConsent = appConsentInitialized

            registerCallbacks()
            tryToDisplayCmpAndCheckUpdateIfNeeded()
        }
    }

    private fun removeCMPCallback() {
        /*
        Not mandatory, but avoids keeping a local reference to the callback.
        Of course, it all depends on how your project is implemented.
        For example, with an SOP Activity, a singleton monitored by a flow, etc.
         */
        appConsent?.setOnPresentNoticeListener(null)
    }

    private fun updateFirebaseConsent(appConsent: AppConsent) {
        // Consent has just been validated by the user.
        // Recovers current GCM status (following user consent).
        val gcmConsentStatus = appConsent.getGCMConsentStatus()

        val newAnalyticsStorage =
            if (gcmConsentStatus.isAnalyticsStorageGranted) GRANTED else DENIED
        val newAdStorage =
            if (gcmConsentStatus.isAdStorageGranted) GRANTED else DENIED
        val newAdUserData =
            if (gcmConsentStatus.isAdUserDataGranted) GRANTED else DENIED
        val newAdPersonalization =
            if (gcmConsentStatus.isAdPersonalizationGranted) GRANTED else DENIED

        /*
        * We do not guarantee that Firebase will work with this example.
        * Please refer to the official documentation for details of initialization, re-initialization, reboot and other conditions.
        *
        * This example is only intended to show how to retrieve ConsentStatus and set it to your Firebase instance.
        */
        // Update Firebase status with information provided by the SDK
        Firebase.analytics.setConsent {
            analyticsStorage = newAnalyticsStorage
            adStorage = newAdStorage
            adUserData = newAdUserData
            adPersonalization = newAdPersonalization
        }
    }
}
Last updated on