Obtenir le consentement avec la plate-forme de messagerie utilisateur

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Conditions préalables

Impact des exigences de l'IAB sur les messages demandant le consentement des utilisateurs de l'UE

Introduction

Conformément aux Règles de Google relatives au consentement de l'utilisateur dans l'UE, vous devez divulguer certaines informations à vos utilisateurs situés dans l'Espace économique européen (EEE) et au Royaume-Uni. Vous devez également obtenir leur consentement pour utiliser des cookies ou un autre stockage local, lorsque la législation l'impose, et pour utiliser des données à caractère personnel (comme 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).

Pour aider les éditeurs à satisfaire aux obligations qui leur sont imposées par ce règlement, Google propose le SDK User Messaging Platform (UMP), qui remplace l'ancien SDK Consent. 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 d'autorisation et de référencement des partenaires publicitaires. Toutes ces configurations peuvent désormais être facilement gérées dans Confidentialité et messages AdMob.

Nous vous recommandons de charger un formulaire chaque fois que l'utilisateur lance votre application, même si vous déterminez que le consentement n'est pas requis, afin que le formulaire soit prêt à s'afficher si l'utilisateur souhaite modifier ses paramètres de consentement.

Ce guide vous 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 le fichier build.gradle de 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

Pour obtenir votre ID d'application, suivez 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, le cas échéant, chargez-en un.
  4. Présentez le formulaire.
  5. Donner aux utilisateurs un moyen de modifier leur consentement.

Nous vous recommandons de demander une mise à jour des informations de consentement à chaque lancement de l'application. Cela déterminera si l'utilisateur doit donner son autorisation.

Java

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. Here 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.
          }
        });
  }
}

Kotlin

import android.os.Bundle
import com.google.android.ump.*

class MainActivity : AppCompactActivity() {
  private lateinit var consentInformation: ConsentInformation
  private var consentForm: ConsentForm? = null

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

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

    consentInformation = UserMessagingPlatform.getConsentInformation(this)
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        {
          // The consent information state was updated.
          // You are now ready to check if a form is available.
        },
        { 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.

Un formulaire peut ne pas être disponible pour plusieurs raisons:

  • Le suivi des annonces est activé pour l'utilisateur.
  • Vous avez tagué l'utilisateur comme 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:

Java

...
    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() {

}

Kotlin

...
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        {
          // The consent information state was updated.
          // You are now ready to check if a form is available.
          if (consentInformation.isConsentFormAvailable) {
            loadForm()
          }
        },
        { formError ->
          // Handle the error.
        }
    )
}

private fun loadForm() {

}

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

Java

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.
        }
      });
}

Kotlin

private fun loadForm() {
  UserMessagingPlatform.loadConsentForm(
      this,
      { consentForm ->
        this.consentForm = consentForm
      },
      { formError ->
        // Handle the error.
      }
  )
}

Présenter 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 de votre autorisation pour présenter le formulaire. Pour savoir si une autorisation est requise, vérifiez 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 : consentement de l'utilisateur non requis. 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:

Java

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 the error.
        }
      });
}

Kotlin

private fun loadForm() {
  UserMessagingPlatform.loadConsentForm(
      this,
      { consentForm ->
        this.consentForm = consentForm
        if (consentInformation.consentStatus == ConsentInformation.ConsentStatus.REQUIRED) {
          consentForm.show(this) { formError ->
            // Handle dismissal by reloading form.
            loadForm()
          }
        }
      },
      { formError ->
        // Handle the error.
      }
  )
}

Si le consentement n'est pas obligatoire, 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() sur 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, l'application consigne le hachage de l'ID requis lors de son exécution.

Java

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.
      }
    });

Kotlin

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

val params = ConsentRequestParameters
    .Builder()
    .setConsentDebugSettings(debugSettings)
    .build()

consentInformation = UserMessagingPlatform.getConsentInformation(this)
consentInformation.requestConsentInfoUpdate(
    this,
    params,
    {
      // The consent information state was updated.
      // You are now ready to check if a form is available.
    },
    { formError ->
      // Handle the error.
    }
  )

Pour forcer le SDK à traiter l'appareil comme s'il ne se trouve pas dans l'EEE ou 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. Il n'est pas nécessaire d'ajouter les émulateurs à la liste des ID d'appareil, car les tests sont activés par défaut.

Lorsque vous testez votre application avec le SDK UMP, il peut être utile de réinitialiser l'état du SDK afin de simuler la première installation d'un utilisateur. Pour ce faire, le SDK fournit la méthode reset.

Java

consentInformation.reset();

Kotlin

consentInformation.reset()

Retarder la mesure dans l'application (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 au démarrage de l'application. Ce comportement d'initialisation vous permet d'activer les métriques utilisateur AdMob sans modifier le code.

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

Pour retarder les mesures dans 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 de vos partenaires de médiation différemment en fonction du framework de consentement que vous choisissez pour votre application. Google est compatible avec le framework de consentement de l'IAB, mais vous permet également de disposer de votre propre solution de consentement personnalisé. Vous trouverez ci-dessous des détails sur la gestion de la médiation pour chacune de ces options. En savoir plus sur notre solution de consentement

Ni le SDK UMP ni le SDK Mobile Ads ne transfère les informations de consentement aux partenaires de médiation. En revanche, lorsque vous utilisez la solution IAB, le SDK UMP écrit les informations sur l'état de consentement dans le stockage local. Chaque SDK de partenaire de médiation est tenu de lire les clés appropriées. Vérifiez auprès de chaque réseau tiers s'il est compatible avec la solution IAB.

Si vous utilisez une solution de consentement personnalisé, il est de votre responsabilité d'informer les SDK tiers de l'état de consentement de votre application. Pour en savoir plus sur la manière de transmettre les informations de consentement aux tiers concernés, veuillez consulter le guide d'intégration de chaque partenaire de médiation.

Le code de cette section peut être utilisé avec n'importe quelle version du SDK Google Mobile Ads. Vous pouvez également l'utiliser, que vous ayez utilisé le SDK Consent pour recueillir le consentement.

Par défaut, le SDK Google Mobile Ads diffuse des annonces personnalisées. Si un utilisateur a accepté de ne recevoir que des annonces non personnalisées, vous pouvez configurer un objet AdRequest pour spécifier que seules les annonces 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:

Java

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

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

Kotlin

val extras = Bundle()
extras.putString("npa", "1")

val request = AdRequest.Builder()
    .addNetworkExtrasBundle(AdMobAdapter::class.java, extras)
    .build()

Si des annonces non personnalisées sont demandées, l'URL de demande d'annonce inclut actuellement &npa=1. Notez toutefois que les détails de la mise en œuvre interne du SDK Google Mobile Ads sont susceptibles de changer.