Premiers pas

Conformément à l'accord de l'utilisateur dans l'UE de Google Policy Controller, vous devez communiquer certaines informations à vos utilisateurs dans l'Espace économique européen (EEE), au Royaume-Uni et obtenir son consentement pour l'utilisation de cookies ou de toute autre méthode de stockage en local, lorsque la législation l'impose, et d'utiliser des données à caractère personnel (telles que les identifiants publicitaires) pour diffuser des annonces. Ces règles reflètent les exigences de la directive vie privée et communications électroniques de l'UE, ainsi que celles de la 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 (UMP). Le SDK UMP a été mis à jour pour prendre en charge les dernières normes de l'IAB. Toutes ces configurations peuvent désormais être gérées dans Ad Manager la confidentialité et messagerie.

Prérequis

• Suivez le guide de démarrage.

• Niveau d'API Android 21 ou supérieur

• Si vous travaillez sur des exigences liées au RGPD, consultez la page Impact des exigences de l'IAB sur le consentement dans l'UE messages

Créer un type de message

Créez des messages destinés aux utilisateurs avec l'une des types de messages destinés aux utilisateurs disponibles dans la section Confidentialité l'onglet "Messages" de votre Ad Manager Google Cloud. Le SDK UMP tente d'afficher un message utilisateur créé à partir de Ad Manager l'ID application dans votre projet. Si aucun message n'est configuré pour votre application, le SDK renvoie une erreur.

Pour en savoir plus, consultez À propos de la confidentialité et des messages

Installer avec Gradle

Ajoutez la dépendance du SDK Google User Messaging Platform au fichier fichier Gradle au niveau de l'application, généralement app/build.gradle:

dependencies {
  implementation("com.google.android.ump:user-messaging-platform:2.2.0")
}

Après avoir modifié le build.gradle de votre application, veillez à synchroniser votre avec les fichiers Gradle.

Ajouter l'ID application

Vous trouverez l'ID de votre application dans le Interface utilisateur d'Ad Manager. Ajoutez la pièce d'identité à votre AndroidManifest.xml à l'aide de l'extrait de code suivant:

<manifest>
  <application>
    <meta-data
        android:name="com.google.android.gms.ads.APPLICATION_ID"
        android:value="ca-app-pub-xxxxxxxxxxxxxxxx~yyyyyyyyyy"/>
  </application>
</manifest>

Demande d'informations sur le consentement

Vous devez demander la mise à jour des informations sur le consentement de l'utilisateur pour chaque application lancer, à l'aide de requestConsentInfoUpdate(). Cela permet de déterminer si votre utilisateur doit donner son consentement, s'il ne l'a pas déjà fait ; ou si son consentement a expiré.

Voici un exemple de vérification de l'état à partir de MainActivity dans le onCreate().

Java

package com.example.myapplication;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

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;

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

    // Create a ConsentRequestParameters object.
    ConsentRequestParameters params = new ConsentRequestParameters
        .Builder()
        .build();

    consentInformation = UserMessagingPlatform.getConsentInformation(this);
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        (OnConsentInfoUpdateSuccessListener) () -> {
          // TODO: Load and show the consent form.
        },
        (OnConsentInfoUpdateFailureListener) requestConsentError -> {
          // Consent gathering failed.
          Log.w(TAG, String.format("%s: %s",
              requestConsentError.getErrorCode(),
              requestConsentError.getMessage()));
        });
  }
}

Kotlin

package com.example.myapplication

import com.google.android.ump.ConsentInformation
import com.google.android.ump.ConsentInformation.OnConsentInfoUpdateFailureListener
import com.google.android.ump.ConsentInformation.OnConsentInfoUpdateSuccessListener
import com.google.android.ump.ConsentRequestParameters
import com.google.android.ump.UserMessagingPlatform

class MainActivity : AppCompatActivity() {
  private lateinit var consentInformation: ConsentInformation

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

    // Create a ConsentRequestParameters object.
    val params = ConsentRequestParameters
        .Builder()
        .build()

    consentInformation = UserMessagingPlatform.getConsentInformation(this)
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        ConsentInformation.OnConsentInfoUpdateSuccessListener {
          // TODO: Load and show the consent form.
        },
        ConsentInformation.OnConsentInfoUpdateFailureListener {
          requestConsentError ->
          // Consent gathering failed.
          Log.w(TAG, "${requestConsentError.errorCode}: ${requestConsentError.message}")
        })
  }
}

Avertissement :En utilisant d'autres moyens de vérifier l'état du consentement, comme le cache de votre ou une chaîne de consentement précédemment enregistrée, peut entraîner une Erreur du TCF 3.3 si le consentement est est arrivé à expiration.

Charger et afficher un formulaire de consentement si nécessaire

Important :Les API suivantes sont compatibles avec le SDK UMP version 2.1.0 ou ultérieure.

Une fois que vous avez reçu les toutes dernières informations concernant l'état de votre consentement, appelez loadAndShowConsentFormIfRequired() sur le ConsentForm pour charger un formulaire de consentement. Si le l'état du consentement est requis, le SDK charge un formulaire et le présente immédiatement à partir de l'adresse activityfournie. Le callback est appelé après la fermeture du formulaire. Si le consentement n'est pas requis, les callback est appelée immédiatement.

Java

public class MainActivity extends AppCompatActivity {
  private ConsentInformation consentInformation;

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

    // Create a ConsentRequestParameters object.
    ConsentRequestParameters params = new ConsentRequestParameters
        .Builder()
        .build();

    consentInformation = UserMessagingPlatform.getConsentInformation(this);
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        (OnConsentInfoUpdateSuccessListener) () -> {
          UserMessagingPlatform.loadAndShowConsentFormIfRequired(
            this,
            (OnConsentFormDismissedListener) loadAndShowError -> {
              if (loadAndShowError != null) {
                // Consent gathering failed.
                Log.w(TAG, String.format("%s: %s",
                    loadAndShowError.getErrorCode(),
                    loadAndShowError.getMessage()));
              }

              // Consent has been gathered.
            }
          );
        },
        (OnConsentInfoUpdateFailureListener) requestConsentError -> {
          // Consent gathering failed.
          Log.w(TAG, String.format("%s: %s",
              requestConsentError.getErrorCode(),
              requestConsentError.getMessage()));
        });
  }
}

Kotlin

class MainActivity : AppCompatActivity() {
  private lateinit var consentInformation: ConsentInformation

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

    // Create a ConsentRequestParameters object.
    val params = ConsentRequestParameters
        .Builder()
        .build()

    consentInformation = UserMessagingPlatform.getConsentInformation(this)
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        ConsentInformation.OnConsentInfoUpdateSuccessListener {
          UserMessagingPlatform.loadAndShowConsentFormIfRequired(
            this@MainActivity,
            ConsentForm.OnConsentFormDismissedListener {
              loadAndShowError ->
              if (loadAndShowError != null) {
                // Consent gathering failed.
                Log.w(TAG, "${loadAndShowError.errorCode}: ${loadAndShowError.message}")
              }

              // Consent has been gathered.
            }
          )
        },
        ConsentInformation.OnConsentInfoUpdateFailureListener {
          requestConsentError ->
          // Consent gathering failed.
          Log.w(TAG, "${requestConsentError.errorCode}: ${requestConsentError.message}")
        })
  }
}

Si vous devez effectuer des actions après que l'utilisateur a choisi ou ignoré dans le formulaire, placez cette logique dans callback pour votre formulaire.

Demander des annonces

Avant de demander des annonces dans votre application, vérifiez si vous avez obtenu le consentement des utilisateurs de l'utilisateur via canRequestAds(). Il y a deux endroits où vérifier le consentement des utilisateurs:

1. Une fois que le consentement a été recueilli dans la session en cours.
2. Immédiatement après avoir appelé requestConsentInfoUpdate(). Il est possible que le consentement ait été obtenu lors de la session précédente. En tant que latence nous vous recommandons de ne pas attendre la fin du rappel commencer à charger des annonces dès que possible après le lancement de votre application.

Remarque: canRequestAds() renvoie toujours false jusqu'à ce que vous ayez appelé requestConsentInfoUpdate()

Si une erreur se produit lors du processus de collecte du consentement, vous devez pour tenter de demander des annonces. Le SDK UMP utilise l'état de consentement de l'autorisation session.

Java

public class MainActivity extends AppCompatActivity {
  private ConsentInformation consentInformation;
  // Use an atomic boolean to initialize the Google Mobile Ads SDK and load ads once.
  private final AtomicBoolean isMobileAdsInitializeCalled = new AtomicBoolean(false);
  
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // Create a ConsentRequestParameters object.
    ConsentRequestParameters params = new ConsentRequestParameters
        .Builder()
        .build();

    consentInformation = UserMessagingPlatform.getConsentInformation(this);
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        (OnConsentInfoUpdateSuccessListener) () -> {
          UserMessagingPlatform.loadAndShowConsentFormIfRequired(
            this,
            (OnConsentFormDismissedListener) loadAndShowError -> {
              if (loadAndShowError != null) {
                // Consent gathering failed.
                Log.w(TAG, String.format("%s: %s",
                    loadAndShowError.getErrorCode(),
                    loadAndShowError.getMessage()));
              }

              // Consent has been gathered.
              if (consentInformation.canRequestAds()) {
                initializeMobileAdsSdk();
              }
            }
          );
        },
        (OnConsentInfoUpdateFailureListener) requestConsentError -> {
          // Consent gathering failed.
          Log.w(TAG, String.format("%s: %s",
              requestConsentError.getErrorCode(),
              requestConsentError.getMessage()));
        });
    
    // Check if you can initialize the Google Mobile Ads SDK in parallel
    // while checking for new consent information. Consent obtained in
    // the previous session can be used to request ads.
    if (consentInformation.canRequestAds()) {
      initializeMobileAdsSdk();
    }
  }
  
  private void initializeMobileAdsSdk() {
    if (isMobileAdsInitializeCalled.getAndSet(true)) {
      return;
    }

    new Thread(
            () -> {
              // Initialize the Google Mobile Ads SDK on a background thread.
              
              MobileAds.initialize(this, initializationStatus -> {});
              runOnUiThread(
                  () -> {
                    // TODO: Request an ad.
                    // loadInterstitialAd();
                  });
              
            })
        .start();
  }
}

Kotlin

class MainActivity : AppCompatActivity() {
  private lateinit var consentInformation: ConsentInformation
  // Use an atomic boolean to initialize the Google Mobile Ads SDK and load ads once.
  private var isMobileAdsInitializeCalled = AtomicBoolean(false)
  
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    // Create a ConsentRequestParameters object.
    val params = ConsentRequestParameters
        .Builder()
        .build()

    consentInformation = UserMessagingPlatform.getConsentInformation(this)
    consentInformation.requestConsentInfoUpdate(
        this,
        params,
        ConsentInformation.OnConsentInfoUpdateSuccessListener {
          UserMessagingPlatform.loadAndShowConsentFormIfRequired(
            this@MainActivity,
            ConsentForm.OnConsentFormDismissedListener {
              loadAndShowError ->
              if (loadAndShowError != null) {
                // Consent gathering failed.
                Log.w(TAG, "${loadAndShowError.errorCode}: ${loadAndShowError.message}")
              }

              // Consent has been gathered.
              if (consentInformation.canRequestAds()) {
                initializeMobileAdsSdk()
              }
            }
          )
        },
        ConsentInformation.OnConsentInfoUpdateFailureListener {
          requestConsentError ->
          // Consent gathering failed.
          Log.w(TAG, "${requestConsentError.errorCode}: ${requestConsentError.message}")
        })
    
    // Check if you can initialize the Google Mobile Ads SDK in parallel
    // while checking for new consent information. Consent obtained in
    // the previous session can be used to request ads.
    if (consentInformation.canRequestAds()) {
      initializeMobileAdsSdk()
    }
  }
  
  private fun initializeMobileAdsSdk() {
    if (isMobileAdsInitializeCalled.getAndSet(true)) {
      return
    }

    val backgroundScope = CoroutineScope(Dispatchers.IO)
    backgroundScope.launch {
      
      MobileAds.initialize(this@MainActivity) {}
      runOnUiThread {
        // TODO: Request an ad.
        // loadInterstitialAd()
      }
      
    }
  }
}

Options de confidentialité

Certains formulaires de consentement nécessitent que l'utilisateur modifie son consentement à tout moment. Respecter les étapes suivantes pour ajouter un bouton d'options de confidentialité, si nécessaire.

Pour cela, les opérations suivantes sont nécessaires :

1. Implémentez un élément d'interface utilisateur, comme un bouton sur la page des paramètres de votre application, qui peut déclencher un formulaire d'options de confidentialité.
2. Une fois loadAndShowConsentFormIfRequired() l'opération terminée, vérifiez privacyOptionsRequirementStatus() pour déterminer s'il faut afficher l'élément d'interface utilisateur pouvant présenter le formulaire d'options de confidentialité.
3. Lorsqu'un utilisateur interagit avec votre élément d'interface utilisateur, appelez showPrivacyOptionsForm() pour afficher le formulaire afin que l'utilisateur puisse mettre à jour leurs options de confidentialité à tout moment.

L'exemple suivant montre comment présenter le formulaire d'options de confidentialité un MenuItem.

Java

private final ConsentInformation consentInformation;

// Show a privacy options button if required.
public boolean isPrivacyOptionsRequired() {
  return consentInformation.getPrivacyOptionsRequirementStatus()
      == PrivacyOptionsRequirementStatus.REQUIRED;
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  // ...

  consentInformation = UserMessagingPlatform.getConsentInformation(this);
  consentInformation.requestConsentInfoUpdate(
      this,
      params,
      (OnConsentInfoUpdateSuccessListener) () -> {
        UserMessagingPlatform.loadAndShowConsentFormIfRequired(
          this,
          (OnConsentFormDismissedListener) loadAndShowError -> {
            // ...

            // Consent has been gathered.

            if (isPrivacyOptionsRequired()) {
              // Regenerate the options menu to include a privacy setting.
              invalidateOptionsMenu();
            }
          }
        )
      }
      // ...
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
  getMenuInflater().inflate(R.menu.action_menu, menu);
  MenuItem moreMenu = menu.findItem(R.id.action_more);
  moreMenu.setVisible(isPrivacyOptionsRequired());
  return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
  // ...

  popup.setOnMenuItemClickListener(
      popupMenuItem -> {
        if (popupMenuItem.getItemId() == R.id.privacy_settings) {
          // Present the privacy options form when a user interacts with
          // the privacy settings button.
          UserMessagingPlatform.showPrivacyOptionsForm(
              this,
              formError -> {
                if (formError != null) {
                  // Handle the error.
                }
              }
          );
          return true;
        }
        return false;
      });
  return super.onOptionsItemSelected(item);
}

Kotlin

private val consentInformation: ConsentInformation =
  UserMessagingPlatform.getConsentInformation(context)

// Show a privacy options button if required.
val isPrivacyOptionsRequired: Boolean
  get() =
    consentInformation.privacyOptionsRequirementStatus ==
      ConsentInformation.PrivacyOptionsRequirementStatus.REQUIRED

override fun onCreate(savedInstanceState: Bundle?) {
  ...
  consentInformation = UserMessagingPlatform.getConsentInformation(this)
  consentInformation.requestConsentInfoUpdate(
      this,
      params,
      ConsentInformation.OnConsentInfoUpdateSuccessListener {
        UserMessagingPlatform.loadAndShowConsentFormIfRequired(
          this@MainActivity,
          ConsentForm.OnConsentFormDismissedListener {
            // ...

            // Consent has been gathered.

            if (isPrivacyOptionsRequired) {
              // Regenerate the options menu to include a privacy setting.
              invalidateOptionsMenu();
            }
          }
        )
      }
      // ...
}

override fun onCreateOptionsMenu(menu: Menu?): Boolean {
  menuInflater.inflate(R.menu.action_menu, menu)
  menu?.findItem(R.id.action_more)?.apply {
    isVisible = isPrivacyOptionsRequired
  }
  return super.onCreateOptionsMenu(menu)
}

override fun onOptionsItemSelected(item: MenuItem): Boolean {
  // ...

  popup.setOnMenuItemClickListener { popupMenuItem ->
    when (popupMenuItem.itemId) {
      R.id.privacy_settings -> {
        // Present the privacy options form when a user interacts with
        // the privacy settings button.
        UserMessagingPlatform.showPrivacyOptionsForm(this) { formError ->
          formError?.let {
            // Handle the error.
          }
        }
        true
      }
      else -> false
    }
  }
  return super.onOptionsItemSelected(item)
}

Tests

Si vous souhaitez tester l'intégration dans votre application pendant le développement, suivez suivez ces étapes pour enregistrer votre appareil de test de manière programmatique. Veillez à supprimer le qui définit ces ID d'appareils de test avant de publier votre application.

Remarque: À partir de la version 2.2.0, les émulateurs n'ont pas besoin d'être ajoutés à la liste des ID d'appareils, appareils par défaut.

1. Appelez le requestConsentInfoUpdate().

2. Recherchez dans la sortie du journal un message semblable à l'exemple suivant, affiche l'ID de votre appareil et explique comment l'ajouter en tant qu'appareil de test:

   Use new ConsentDebugSettings.Builder().addTestDeviceHashedId("33BE2250B43518CCDA7DE426D04EE231") to set this as a debug device.
   

3. Copiez l'ID de votre appareil de test dans votre presse-papiers.

4. Modifiez votre code pour appeler DebugGeography.TestDeviceHashedIds et transmettre la liste de vos ID d'appareils de test.

Forcer une zone géographique

Le SDK UMP permet de tester le comportement de votre application comme si l'appareil était situées dans l'EEE ou au Royaume-Uni par le biais de the setDebugGeography method which takes a DebugGeography on ConsentDebugSettings.Builder. Notez que Les paramètres de débogage ne fonctionnent que sur les appareils de test.

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);
// Include the ConsentRequestParameters in your consent request.
consentInformation.requestConsentInfoUpdate(
    this,
    params,
    ...
);

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)
// Include the ConsentRequestParameters in your consent request.
consentInformation.requestConsentInfoUpdate(
    this,
    params,
    ...
)

Réinitialiser l'état du consentement

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

Java

consentInformation.reset();

Kotlin

consentInformation.reset()

Attention :Cette méthode est destinée uniquement à être utilisée à des fins de test. Toi ne doit pas appeler reset() dans le code de production.

Exemples sur GitHub

Exemples d'intégration du SDK UMP: Java | Kotlin