Aller au contenu principal

Examples

Descriptif complet de l'exemple d'intégration ci-dessous

Dans cet exemple nous nous assurons de l'affichage de la CMP aux utilisateurs au lancement de l'application (démarrage de notre activité).

Voici les différentes étapes de cet exemple au premier lancement​

  1. Vérification du SDK si celui-ci à déjà été initialisé (retour à false)
  2. Initialisation de la CMP avec l'appel de AppConsentSDK#initialize dans le cas contraire
  3. Une fois le SDK démarré, enregistrement des callbacks permettant de savoir quand l'utilisateur aura fini de saisir ses informations.
  4. Appel de la méthode #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet d'afficher la CMP seulement si c'est nécessaire. (dans l'exemple elle s'affichera)
  5. vérification du retour de #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet de savoir si la CMP c'est affiché ou non (retour à true)
  6. Une fois le consentement donnée par l'utilisateur, la méthode #presentConsentGiven sera appelé et vous pouvez par exemple démarrer votre SDK de PUB (AdMob, Vungle, Amazon mobile Ads, etc.)

Voici les différentes étapes de cet exemple au lancement suivant (en ayant tué l'application)​

  1. Vérification du SDK si celui-ci à déjà été initialisé (retour à false)
  2. Initialisation de la CMP avec l'appel de AppConsentSDK#initialize dans le cas contraire
  3. Une fois le SDK démarré, enregistrement des callbacks permettant de savoir quand l'utilisateur aura fini de saisir ses informations.
  4. Appel de la méthode #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet d'afficher la CMP seulement si c'est nécessaire.
  5. vérification du retour de #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet de savoir si la CMP c'est affiché ou non (résultat à false)
  6. (Par vous même) Essayez d'appeller la méthode #checkForUpdate pour vérifier si la Notice a été mise à jour depuis votre Dashboard (sauf action de votre part, résultat à false)
  7. Aucunes action n'est nécessaire, vous pouvez par exemple démarrer votre SDK de PUB (AdMob, Vungle, Amazon mobile Ads, etc.)

Voici les différentes étapes de cet exemple au lancement suivant (en quittant l'application et en la remettant en avant sans la tuée)​

  1. Vérification du SDK si celui-ci à déjà été initialisé (retour à true)
  2. Récupération de l'instance pour l'utiliser localement dans notre activity
  3. Appel de la méthode #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet d'afficher la CMP seulement si c'est nécessaire.
  4. vérification du retour de #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet de savoir si la CMP c'est affiché ou non (résultat à false)
  5. (Par vous même) Essayez d'appeller la méthode #checkForUpdate pour vérifier si la Notice a été mise à jour depuis votre Dashboard (sauf action de votre part, résultat à false)
  6. Aucunes action n'est nécessaire, vous pouvez par exemple démarrer votre SDK de PUB (AdMob, Vungle, Amazon mobile Ads, etc.)

Voici les différentes étapes de cet exemple au lancement suivant ET après avoir modifié votre Notice depuis le Dashboard (en quittant l'application et en la remettant en avant sans la tuée)​

  1. Vérification du SDK si celui-ci à déjà été initialisé (retour à true)
  2. Récupération de l'instance pour l'utiliser localement dans notre activity
  3. Appel de la méthode #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet d'afficher la CMP seulement si c'est nécessaire.
  4. vérification du retour de #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet de savoir si la CMP c'est affiché ou non (résultat à false)
  5. (Par vous même) Essayez d'appeller la méthode #checkForUpdate pour vérifier si la Notice a été mise à jour depuis votre Dashboard (résultat à true car votre Notice a été mise à jour)
  6. Suppression local du précédent consentement utilisateur #clearConsent
  7. Appel de la méthode #tryToDisplayNoticeFromUiContext(uiContext, false) qui permet d'afficher la CMP seulement si c'est nécessaire. (retour à true)
  8. Une fois le consentement donnée par l'utilisateur, la méthode #presentConsentGiven sera appelé et vous pouvez par exemple démarrer votre SDK de PUB (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)

        /*
        Permet de savoir si le SDK a dors et déjà été initialisé
         */
        if (!AppConsentSDK.isSdkInitialized() || AppConsentSDK.getInstance() == null) {
            initCmpModule()
        } else {
            if (appConsent == null) {
                /*
                Permet de récupérer l'instance de AppConsent ou null si elle n'a pas encore été instancié par exemple
                 */
                appConsent = AppConsentSDK.getInstance()
            }
            tryToDisplayCmpAndCheckUpdateIfNeeded()
        }
    }

    /**
     * Les seules conditions pour utiliser cette méthode serait si:
     * - vous avez configurer votre Notice en sélectionnant cette option : Lors de l'enregistrement des modifications de la notice, afficher la notice à tous les visiteurs.
     * - Vous pensez mettre à jour souvent votre Notice (plus souvent que la : Période de conservation des consentements configurable dans votre Notice)
     * - Vos utilisateurs relancent très rarement votre application
     *
     * Au quel cas, utiliser cette méthode ponctuellement peut être une solution.
     *
     * Mais nous vous encourageons à laisser le SDK gérer cette partie par lui-même.
     */
    private fun checkIfNoticeHasBeenUpdated() {
        appConsent?.checkForUpdate(
            { isNeedToPresentTheCmp ->
                // Votre Notice a été mise à jour, vous devez représenter la CMP à vos utilisateurs
                if (true == isNeedToPresentTheCmp) {
                    /*
                    Permet de supprimer localement l'ancien consentement utilisateur.
                    Cette étape n'est pas obligatoire, mais elle permet d'éviter de refaire un appel réseau
                    pour vérifier plus tard si la Notice a été mise à jour
                    car plus aucuns consentement ne sera présent sur le device de l'utilisateur.
                     */
                    appConsent?.clearConsent()

                    /*
                    Pensez à vous ré-enregistrer aux callback si vous les avez retirés précédemment,
                    sinon vous ne saurez pas quand l'utilisateur aura donné son consentement
                     */
                    registerCallbacks()
                    if (false == tryToDisplayCMP()) {
                        /*
                         A ce stade, si la CMP ne s'affiche pas il est possible, par exemple:
                         que l'utilisateur ne soit plus dans une zone géographique soumise aux RGPD
                         */
                        removeCMPCallback()
                    }
                } else {
                    /*
                    La Notice est la même que lors de la dernière vérification
                    (vous n'avez apporté aucunes modification depuis le board ou
                    celle-ci n'a pas subit de mise à jour interne par nos soins;
                    comme par exemple la mise à jour d'un vendor)
                     */
                }
            },
            { _ ->
                /*
                 Une erreur s'est produite
                 */
            })
    }

    /**
     * Essaye d'afficher la CMP
     *
     * @return true, si la CMP s'affiche, false sinon
     */
    private fun tryToDisplayCMP(): Boolean {
        /*
         Essaye d'afficher la CMP selon certaines règles.
         */
        return appConsent?.tryToDisplayNoticeFromUiContext(uiContext = this@MainActivity, false) == true
    }

    private fun tryToDisplayCmpAndCheckUpdateIfNeeded() {
        /*
         Dans un premier temps, essaye d'afficher la CMP selon certaines règles.
         */
        if (false == tryToDisplayCMP()) {
            /*
             L'utilisateur a déjà donné son consentement;
             L'utilisateur ne fait pas partie d'une zone sujet à l'application des RGPD;
             etc.
             */
            removeCMPCallback()

            /*
            La Notice ne c'est pas affiché,
            il nous reste à vérifier dans un second temps si celle-ci a subit une mise à jour
            et que celle-ci doit être de nouveau représenté aux utilisateurs.
             */
            checkIfNoticeHasBeenUpdated()
        }
    }

    private fun registerCallbacks() {
        /*
         S'enregistre au callback de la CMP pour savoir quand l'utilisateur
         aura donné son consentement, ou bien si une erreur survînt
         */
        appConsent?.setOnPresentNoticeListener(object : OnPresentNoticeListener {
            override fun presentConsentError(error: Throwable?) {
                /*
                 Une erreur s'est produite
                 */
                removeCMPCallback()
            }

            override fun presentConsentGiven() {
                /*
                L'utilisateur a donné son consentement
                */
                appConsent?.let { appConsentNN ->
                    updateFirebaseConsent(appConsentNN)
                }
                removeCMPCallback()
            }
        })
    }

    /*
     Initialise le module de plateforme de gestion des consentements, lors de la création de l'activity
     */
    private fun initCmpModule() {
        /*
        ACConfiguration permet de configurer la CMP.
        Dans l'exemple ici:
        - On défini forceApplyGDPR à true pour afficher la CMP quelque soit la région des utilisateurs.
        - On décide d'afficher la CMP en FullScreen plutôt qu'en modal.
        - On configure la CMP pour que les boutons du layer 1 s'affichent verticalement et non pas horizontalement (sauf en mode paysage)
        - On configure la CMP pour que les liens hypertextes ne soient plus affichés dans une webview et/ou que l'utilisateur soit redirigé en dehors de l'application si le lien demandé est un fichier, par exemple ; à la place, une popup présentant un code QR sera présentée à vos utilisateurs (principalement utile sur Automotive / Tablette)
         */
        val acConfiguration = ACConfiguration.Builder()
            .setForceApplyGDPR(true)
            .setFullScreenMode(true)
            .setNeedToDisplayValidationButtonsVertically(isNeedToDisplayButtonsAtVertical = true)
            .setNeedToReplaceUrlViewerByQrCode(isNeedToReplaceUrlViewerByQrCode = true)
            .build()

        AppConsentSDK.initialize(
            appKey = "VOTRE_APPKEY",
            configuration = acConfiguration
        ) { appConsentInitialized ->
            /*
             Pour éviter certains problèmes, utilisez l'instance reçue par le callback onReady
             Celle-ci a été initialisée avec succès
             */
            appConsent = appConsentInitialized

            registerCallbacks()
            tryToDisplayCmpAndCheckUpdateIfNeeded()
        }
    }

    private fun removeCMPCallback() {
        /*
        Non obligatoire, mais cela permet d'éviter de garder une référence locale au callback.
        Bien entendu, tout dépend de l'implémentation faite sur votre projet.
        Exemple avec une SOP Activity, un singleton surveillé par un flow, etc.
         */
        appConsent?.setOnPresentNoticeListener(null)
    }

    private fun updateFirebaseConsent(appConsent: AppConsent) {
        // Le consentement vient d'être donné par l'utilisateur.
        // Récupère l'état actuel du GCM (après le consentement de l'utilisateur).
        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

        /*
        * Nous ne garantissons pas que Firebase fonctionnera avec cet exemple.
        * Veuillez vous reporter à la documentation officielle pour plus de détails sur l'initialisation, la réinitialisation, le redémarrage et d'autres conditions.
        *
        * Cet exemple a pour seul but de montrer comment récupérer ConsentStatus et le définir dans votre instance Firebase.
        */
        // Mettre à jour le statut Firebase avec les informations fournies par le SDK
        Firebase.analytics.setConsent {
            analyticsStorage = newAnalyticsStorage
            adStorage = newAdStorage
            adUserData = newAdUserData
            adPersonalization = newAdPersonalization
        }
    }
}
Dernière mise à jour le