Obtenir le consentement avec la plate-forme de messagerie utilisateur

Prerequisites

Lire Impact des exigences de l'IAB pour les messages de consentement pour l'UE

Présentation

Conformément aux Règles de Google relatives au consentement de l'utilisateur dans l'UE, vous devez informer vos utilisateurs de l'Espace économique européen (EEE) et du Royaume-Uni, et obtenir leur consentement pour utiliser des cookies ou tout autre stockage local, lorsque la législation l'impose, et l'utilisation de données à caractère personnel (telles que les AdID) pour diffuser des annonces. Ces règles reflètent les exigences de la directive vie privée et communications électroniques de l'UE, et celles du Règlement général sur la protection des données (RGPD).

Afin d'aider les éditeurs à satisfaire aux obligations qui leur sont imposées par ce règlement, Google propose le SDK User Messaging Platform, qui remplace le précédent SDK de consentement Open Source. Le SDK UMP a été mis à jour pour être compatible avec les dernières normes de l'IAB. Nous avons également simplifié le processus de configuration des formulaires de consentement et l'affichage des fiches des partenaires publicitaires. Toutes ces configurations peuvent désormais être facilement gérées dans Confidentialité et messages d'AdMob.

Il est recommandé de charger un formulaire chaque fois que l'utilisateur lance votre application, même si vous déterminez que le consentement n'est pas nécessaire, de sorte que le formulaire soit prêt à s'afficher au cas où l'utilisateur souhaite modifier son paramètre de consentement.

Ce guide explique comment installer le SDK, implémenter les solutions de l'IAB et activer les fonctionnalités de test.

Installer avec Gradle

Incluez la bibliothèque dans votre build build.gradle dans votre application:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
    implementation 'com.google.android.ump:user-messaging-platform:2.0.0'
}

N'oubliez pas de synchroniser Gradle lorsque vous avez terminé.

Ajouter l'ID de l'application à AndroidManifest.xml

Obtenez l'ID de votre application en suivant les instructions du centre d'aide.

Ajoutez l'ID de votre application à votre AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.rewardedinterstitialexample">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <meta-data
            android:name="com.google.android.gms.ads.APPLICATION_ID"
            android:value="YOUR-APP-ID"/>
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Utiliser le SDK

Le SDK est conçu pour être utilisé de manière linéaire. Pour utiliser le SDK, procédez comme suit:

  1. Demandez les dernières informations sur le consentement.
  2. Vérifiez si le consentement est requis.
  3. Vérifiez si un formulaire est disponible et chargez-le.
  4. Présentez le formulaire.
  5. Permettre aux utilisateurs de modifier leur consentement.

Il est recommandé de demander la mise à jour des informations de consentement à chaque lancement d'application. Cela détermine si l'utilisateur doit donner son consentement ou non.

package com.example.myapplication;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import com.google.android.ump.ConsentForm;
import com.google.android.ump.ConsentInformation;
import com.google.android.ump.ConsentRequestParameters;
import com.google.android.ump.FormError;
import com.google.android.ump.UserMessagingPlatform;

public class MainActivity extends AppCompatActivity {
    private ConsentInformation consentInformation;
    private ConsentForm consentForm;

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

        // Set tag for underage of consent. false means users are not underage.
        ConsentRequestParameters params = new ConsentRequestParameters
            .Builder()
            .setTagForUnderAgeOfConsent(false)
            .build();

        consentInformation = UserMessagingPlatform.getConsentInformation(this);
        consentInformation.requestConsentInfoUpdate(
            this,
            params,
            new ConsentInformation.OnConsentInfoUpdateSuccessListener() {
                @Override
                public void onConsentInfoUpdateSuccess() {
                    // The consent information state was updated.
                    // You are now ready to check if a form is available.
                }
            },
            new ConsentInformation.OnConsentInfoUpdateFailureListener() {
                @Override
                public void onConsentInfoUpdateFailure(FormError formError) {
                    // Handle the error.
                }
            });
    }
}

Charger un formulaire si disponible

Une fois que vous avez déterminé que vous allez demander le consentement d'un utilisateur, l'étape suivante consiste à déterminer si un formulaire est disponible.

Plusieurs raisons peuvent expliquer pourquoi un formulaire n'est pas disponible, par exemple:

  • Le suivi des annonces est activé pour l'utilisateur.
  • Vous avez tagué l'utilisateur comme étant n'ayant pas atteint l'âge minimal requis.

Pour vérifier si un formulaire est disponible, utilisez la méthode isConsentFormAvailable() sur l'instance ConsentInformation. Ajoutez une méthode de wrapper pour charger un formulaire:

...
       consentInformation.requestConsentInfoUpdate(
           this,
           params,
           new ConsentInformation.OnConsentInfoUpdateSuccessListener() {
               @Override
               public void onConsentInfoUpdateSuccess() {
                   // The consent information state was updated.
                   // You are now ready to check if a form is available.
                   if (consentInformation.isConsentFormAvailable()) {
                       loadForm();
                   }
               }
           },
           new ConsentInformation.OnConsentInfoUpdateFailureListener() {
               @Override
               public void onConsentInfoUpdateFailure(FormError formError) {
                   // Handle the error.

               }
            });
    }

    public void loadForm() {

    }
}

Pour charger le formulaire, vous devez utiliser la méthode statique loadConsentForm() sur la classe UserMessagingPlatform. Cette méthode ne doit être appelée qu'à partir du thread principal. Modifiez votre méthode loadForm() comme suit:

public void loadForm() {
    UserMessagingPlatform.loadConsentForm(
        this,
        new UserMessagingPlatform.OnConsentFormLoadSuccessListener() {
            @Override
            public void onConsentFormLoadSuccess(ConsentForm consentForm) {
                MainActivity.this.consentForm = consentForm;
            }
        },
        new UserMessagingPlatform.OnConsentFormLoadFailureListener() {
            @Override
            public void onConsentFormLoadFailure(FormError formError) {
                // Handle the error
            }
        }
    );
}

Présentez le formulaire si nécessaire.

Pour présenter le formulaire, utilisez la méthode show() sur l'instance ConsentForm. Vous devez déterminer si l'utilisateur a besoin du consentement avant de présenter le formulaire. Pour vérifier si le consentement est requis, consultez la méthode getConsentStatus() sur l'objet ConsentInformation, qui renvoie une énumération de type ConsentInformation.ConsentStatus. Quatre valeurs sont possibles:

  • ConsentStatus.UNKNOWN: état de consentement inconnu.
  • ConsentStatus.REQUIRED : consentement de l'utilisateur requis, mais pas encore obtenu.
  • ConsentStatus.NOT_REQUIRED: autorisation non requise pour l'utilisateur. Par exemple, l'utilisateur ne se trouve pas dans l'EEE ni au Royaume-Uni.
  • ConsentStatus.OBTAINED: consentement de l'utilisateur obtenu. Personnalisation non définie.

Modifiez votre méthode loadForm() comme suit:

public void loadForm(){
    UserMessagingPlatform.loadConsentForm(
        this,
        new UserMessagingPlatform.OnConsentFormLoadSuccessListener() {
            @Override
            public void onConsentFormLoadSuccess(ConsentForm consentForm) {
                MainActivity.this.consentForm = consentForm;
                if(consentInformation.getConsentStatus() == ConsentInformation.ConsentStatus.REQUIRED) {
                    consentForm.show(
                        MainActivity.this,
                            new ConsentForm.OnConsentFormDismissedListener() {
                                @Override
                                public void onConsentFormDismissed(@Nullable FormError formError) {
                                    // Handle dismissal by reloading form.
                                    loadForm();
                                }
                            });

                }

            }
        },
        new UserMessagingPlatform.OnConsentFormLoadFailureListener() {
            @Override
            public void onConsentFormLoadFailure(FormError formError) {
                /// Handle Error.
            }
        }
   );
}

Si aucune autorisation n'est requise, vous pouvez conserver une référence au formulaire afin que l'utilisateur puisse modifier son état de consentement.

Tests

Forcer une zone géographique

Le SDK UMP permet de tester le comportement de votre application comme si l'appareil était situé dans l'EEE à l'aide de la méthode setDebugGeography()ConsentDebugSettings.Builder.

Pour utiliser la fonctionnalité de débogage, vous devez fournir l'ID haché de votre appareil de test dans les paramètres de débogage de votre application. Si vous appelez requestConsentInfoUpdate() sans définir cette valeur, votre application consignera le hachage de l'ID requis lors de son exécution.

ConsentDebugSettings debugSettings = new ConsentDebugSettings.Builder(this)
    .setDebugGeography(ConsentDebugSettings
    .DebugGeography
    .DEBUG_GEOGRAPHY_EEA)
    .addTestDeviceHashedId("TEST-DEVICE-HASHED-ID")
    .build();

ConsentRequestParameters params = new ConsentRequestParameters
    .Builder()
    .setConsentDebugSettings(debugSettings)
    .build();

consentInformation = UserMessagingPlatform.getConsentInformation(this);
consentInformation.requestConsentInfoUpdate(this, params,
    new ConsentInformation.OnConsentInfoUpdateSuccessListener() {
        @Override
        public void onConsentInfoUpdateSuccess() {
            // The consent information state was updated.
            // You are now ready to check if a form is available.
        }
    },
    new ConsentInformation.OnConsentInfoUpdateFailureListener() {
        @Override
        public void onConsentInfoUpdateFailure(FormError formError) {
            // Handle the error.
        }
    });

Pour forcer le SDK à traiter l'appareil comme s'il ne se trouve pas dans l'EEE ni au Royaume-Uni, utilisez DebugGeography.DEBUG_GEOGRAPHY_NOT_EEA. Notez que les paramètres de débogage ne fonctionnent que sur les appareils de test. Les émulateurs n'ont pas besoin d'être ajoutés à la liste des ID d'appareil, car les tests sont activés par défaut.

Il peut être utile de tester l'application du SDK UMP pour réinitialiser l'état du SDK afin de simuler une expérience d'installation initiale pour un utilisateur. Pour ce faire, le SDK fournit la méthode reset.

consentInformation.reset();

Différer la mesure des applications (facultatif)

Par défaut, le SDK Google Mobile Ads initialise la mesure des applications et commence à envoyer des données d'événements au niveau de l'utilisateur à Google dès le démarrage de l'application. Ce comportement d'initialisation vous permet d'activer les métriques utilisateur AdMob sans modifier le code supplémentaire.

Toutefois, si votre application nécessite le consentement de l'utilisateur pour envoyer ces événements, vous pouvez retarder la mesure de l'application jusqu'à ce que vous initialisiez le SDK Mobile Ads ou chargeiez une annonce.

Pour retarder les mesures de l'application, ajoutez la balise <meta-data> suivante à votre AndroidManifest.xml.

<manifest>
     <application>
        <!-- Delay app measurement until MobileAds.initialize() is called. -->
        <meta-data
            android:name="com.google.android.gms.ads.DELAY_APP_MEASUREMENT_INIT"
            android:value="true"/>
    </application>
</manifest>

Médiation

Si vous utilisez la médiation, vous devez gérer le consentement pour vos partenaires de médiation différemment en fonction du framework de consentement que vous choisissez pour votre application. Google accepte le framework de consentement de l'IAB, mais vous permet également d'avoir votre propre solution de consentement personnalisé. Vous trouverez ci-dessous les détails de la gestion de chacune de ces options. En savoir plus sur notre solution de consentement

.

Le SDK UMP ni le SDK Mobile Ads ne transfèrent pas les informations de consentement aux partenaires de médiation. Lorsqu'il utilise la solution IAB, le SDK UMP écrit les informations d'état de consentement dans le stockage local. Il est de la responsabilité de chaque SDK de médiation de lire les clés appropriées. Vérifiez auprès de chaque réseau tiers s'il propose une solution IAB.

Si vous utilisez une solution de consentement personnalisé, il est de votre responsabilité d'informer vos SDK tiers de l'état de consentement de votre application. Pour savoir comment transmettre des informations sur le consentement aux tiers concernés, veuillez consulter le guide d'intégration de chaque partenaire de médiation pour en savoir plus sur l'implémentation.

Le code de cette section peut être utilisé avec n'importe quelle version du SDK Google Mobile Ads. Il peut également être utilisé que vous ayez ou non utilisé le SDK de consentement pour recueillir le consentement.

Le comportement par défaut du SDK Google Mobile Ads consiste à diffuser des annonces personnalisées. Si un utilisateur a consenti à ne recevoir que des publicités non personnalisées, vous pouvez configurer un objet AdRequest pour spécifier que seules les publicités non personnalisées doivent être demandées. Le code suivant entraîne la demande d'annonces non personnalisées, que l'utilisateur se trouve ou non dans l'EEE :

Bundle extras = new Bundle();
extras.putString("npa", "1");

AdRequest request = new AdRequest.Builder()
    .addNetworkExtrasBundle(AdMobAdapter.class, extras)
    .build();

Si des annonces non personnalisées sont demandées, l'URL de demande d'annonce inclut actuellement &npa=1 . Toutefois, notez qu'il s'agit d'un détail de mise en œuvre interne du SDK Google Mobile Ads et qu'il est susceptible d'être modifié.