Inizia

Secondo le Norme relative al consenso degli utenti dell'UE di Google, è obbligatorio informare gli utenti nello Spazio economico europeo (SEE) e nel Regno Unito e ricevere il loro consenso per l'utilizzo dei cookie o di altri tipi di archiviazione locale, laddove richiesto dalla legge, nonché per utilizzare i dati personali (ad esempio l'ID pubblicità) per pubblicare gli annunci. Queste norme riflettono i requisiti della direttiva e-Privacy e del Regolamento generale sulla protezione dei dati (GDPR) dell'UE.

Per supportare gli editori nell'adempimento degli obblighi previsti da queste norme, Google offre l'SDK UMP (User Messaging Platform). L'SDK UMP è stato aggiornato per supportare gli standard IAB più recenti. Tutte queste configurazioni ora possono essere gestite comodamente nella AdMob privacy e nei messaggi.

Prerequisiti

• Completa la Guida introduttiva.
• Configura i tuoi messaggi nella scheda Privacy e messaggi del tuo AdMob account. Per ulteriori dettagli, consulta Informazioni su privacy e messaggi,
• Se stai lavorando ai requisiti relativi al GDPR, leggi In che modo i requisiti IAB influiscono sui messaggi per il consenso degli utenti dell'UE.

Tipi di messaggi per gli utenti

Vedi Tipi di messaggi per gli utenti per un elenco completo dei messaggi supportati. Per istruzioni specifiche sull'implementazione di ciascun tipo di messaggio, consulta la barra di navigazione a sinistra.

Installazione con Gradle

Se utilizzi l'SDK Google Mobile Ads versione 19.8.0 o successiva, puoi saltare questo passaggio di installazione di Gradle. In caso contrario, includi l'SDK UMP nell'build.gradle dell'app nel seguente modo:

dependencies {
    // This dependency is automatically included by Google Mobile Ads SDK 19.8.0
    // or higher.
    implementation 'com.google.android.ump:user-messaging-platform:2.0.0'
}

Dopo aver apportato le modifiche al build.gradle della tua app, assicurati di sincronizzare il tuo progetto con i file Gradle.

Aggiorna manifest

A questo punto, trova l'ID app e aggiungilo al tuo 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">
        <!-- Sample app ID: ca-app-pub-3940256099942544~3347511713 -->
        <meta-data
            android:name="com.google.android.gms.ads.APPLICATION_ID"
            android:value="ca-app-pub-xxxxxxxxxxxxxxxx~yyyyyyyyyy"/>
        <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>

Determina se un messaggio deve essere visualizzato

Devi richiedere un aggiornamento delle informazioni sul consenso dell'utente a ogni lancio dell'app, utilizzando requestConsentInfoUpdate() prima di caricare un modulo. In questo modo puoi determinare se l'utente deve o meno fornire il consenso se non l'ha già fatto o se il consenso è scaduto.

Utilizza le informazioni memorizzate nell'oggetto consentInformation quando presenti il modulo quando necessario.

Avviso: l'utilizzo di metodi alternativi per controllare lo stato del consenso, ad esempio per controllare una cache utilizzata dall'app o per cercare una stringa per il consenso nello spazio di archiviazione, è vivamente sconsigliato, in quanto l'insieme di partner di tecnologia pubblicitaria potrebbe essere cambiato dall'ultimo consenso dell'utente.

Ecco un esempio di come controllare lo stato all'avvio dell'app:

Java

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 under age of consent. false means users are not under
    // age.
    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

package com.example.myapplication

import com.google.android.ump.ConsentForm
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
  private lateinit var consentForm: ConsentForm

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

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

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

Carica un modulo, se disponibile

Prima di visualizzare un modulo, devi determinare se è disponibile. I moduli non disponibili possono essere dovuti all'attivazione da parte dell'utente del monitoraggio degli annunci limitato o all'uso di tag sotto l'età del consenso.

Per verificare la disponibilità di un modulo, utilizzathe isConsentFormAvailable() method on the ConsentInformation instance creato in precedenza.

Successivamente, aggiungi un metodo di wrapper per caricare il modulo:

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,
        OnConsentInfoUpdateSuccessListener {
          // The consent information state was updated.
          // You are now ready to check if a form is available.
          if (consentInformation.isConsentFormAvailable) {
            loadForm()
          }
        },
        OnConsentInfoUpdateFailureListener {
          // Handle the error.
        })
  }

  fun loadForm() {

  }
}

Per caricare il modulo, utilizza the static loadConsentForm() method on the UserMessagingPlatform class.

Java

public void loadForm() {
  // Loads a consent form. Must be called on the main thread.
  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

fun loadForm() {
  // Loads a consent form. Must be called on the main thread.
  UserMessagingPlatform.loadConsentForm(
      this,
      UserMessagingPlatform.OnConsentFormLoadSuccessListener {
        this.consentForm = consentForm
      },
      UserMessagingPlatform.OnConsentFormLoadFailureListener {
        // Handle the error.
      }
  )
}

Presenta il modulo se necessario

Dopo aver determinato la disponibilità del modulo e averlo caricato, utilizza il metodoshow() sull'istanzaConsentForm per presentare il modulo.

Utilizza l'consentInformation oggetto precedente per controllareconsent status e aggiornare il tuo metodoloadForm() :

Java

public void loadForm() {
  // Loads a consent form. Must be called on the main thread.
  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) {
                    if (consentInformation.getConsentStatus() == ConsentInformation.ConsentStatus.OBTAINED) {
                      // App can start requesting ads.
                    }

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

Kotlin

fun loadForm() {
  // Loads a consent form. Must be called on the main thread.
  UserMessagingPlatform.loadConsentForm(
      this,
      UserMessagingPlatform.OnConsentFormLoadSuccessListener {
        this.consentForm = consentForm
        if (consentInformation.consentStatus == ConsentInformation.ConsentStatus.REQUIRED) {
          consentForm.show(
              this,
              ConsentForm.OnConsentFormDismissedListener {
                if (consentInformation.consentStatus == ConsentInformation.ConsentStatus.OBTAINED) {
                  // App can start requesting ads.
                }

                // Handle dismissal by reloading form.
                loadForm()
              }
          )
        }
      },
      UserMessagingPlatform.OnConsentFormLoadFailureListener {
        // Handle the error.
      }
  )
}

Se devi eseguire azioni dopo che l'utente ha scelto o ignorato il modulo, inserisci questa logica nel gestore o nel callback di completamento del modulo.

Test

Forza un'area geografica

L'SDK UMP consente di testare il comportamento della tua app come se il dispositivo si trovasse nel SEE o nel Regno Unito utilizzando the setDebugGeography method on ConsentDebugSettings.Builder.

Per poter usare la funzionalità di debug, devi fornire l'ID sottoposto ad hashing del tuo dispositivo di test nelle impostazioni di debug dell'app. Se chiami requestConsentInfoUpdate() senza impostare questo valore, l'app registra l'hash dell'ID richiesto quando viene eseguito.

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,
        OnConsentInfoUpdateSuccessListener {
          // The consent information state was updated.
          // You are now ready to check if a form is available.
        },
        OnConsentInfoUpdateFailureListener {
          // Handle the error.
        })
}

Con DebugGeography, puoi scegliere di forzare l'area geografica su una di queste opzioni:

Regioni di debug	Descrizione
DEBUG_GEOGRAPHY_DISABLED	Regione di debug disabilitata.
DEBUG_GEOGRAPHY_EEA	Per i dispositivi di debug, l'area geografica viene visualizzata come SEE.
DEBUG_GEOGRAPHY_NOT_EEA	Per i dispositivi di debug, l'area geografica risulta non appartenente allo Spazio economico europeo.

Tieni presente che le impostazioni di debug funzionano solo su dispositivi di test. Non è necessario aggiungere gli emulatori all'elenco degli ID dispositivo in quanto sono già abilitati i test per impostazione predefinita.

Reimposta stato del consenso

Durante i test della tua app con l'SDK UMP, potrebbe essere utile reimpostare lo stato dell'SDK in modo da poter simulare la prima esperienza di installazione di un utente. L'SDK fornisce il reset() metodo per farlo.

Java

consentInformation.reset();

Kotlin

consentInformation.reset()

Dovresti anche chiamare reset() se decidi di rimuovere completamente l'SDK UMP dal progetto.