Usar a inicialização configurável do adaptador (Alfa)

Selecione a plataforma: Android iOS Android (legada)

Por padrão, o GMA Next-Gen SDK inicializa todos os adaptadores de mediação associados ao aplicativo durante a inicialização. A inicialização de cada adaptador pode levar mais de 30 segundos, resultando em uma latência significativa antes que o primeiro anúncio seja carregado.

Para resolver esse problema, a AdMob oferece a inicialização configurável do adaptador. Com esse recurso, você controla quais adaptadores são inicializados para sua primeira impressão de anúncio e reduz a latência dessa impressão.

Observação: a inicialização configurável do adaptador está na versão Alfa.

Este guia aborda os seguintes aspectos da inicialização configurável do adaptador:

• Criar uma configuração de adaptador
• Ignorar adaptadores não inicializados
• Inicializar os adaptadores restantes

Pré-requisitos

• Importe o GMA Next-Gen SDK v0.25.0-beta01 ou versões mais recentes.
• Configure o GMA Next-Gen SDK.

• Para ativar esse recurso, adicione a anotação @ExperimentalApi à sua classe:

  Kotlin

  @OptIn(ExperimentalApi::class)
  

  Java

  import androidx.annotation.OptIn;
  // ...
  @OptIn(markerClass = ExperimentalApi.class)
  

Criar uma configuração de adaptador

Uma configuração de inicialização do adaptador instrui o GMA Next-Gen SDK a inicializar apenas os adaptadores necessários. Isso evita que adaptadores desnecessários bloqueiem sua primeira solicitação de anúncio, conservando recursos de computação e reduzindo significativamente a latência da primeira impressão de anúncio.

Para otimizar a performance do app, considere as seguintes estratégias ao criar uma configuração de inicialização do adaptador:

Priorizar um formato de anúncio ou bloco de anúncios específico

Melhore a performance de apps que mostram um anúncio imediatamente após a inicialização, como um anúncio de abertura do app, declarando o formato ou bloco de anúncios específico na configuração de inicialização do adaptador.

O exemplo a seguir cria uma configuração de inicialização do adaptador que inicializa apenas os adaptadores de mediação necessários para um bloco de anúncios de abertura do app específico com um tempo limite de cinco segundos:

Kotlin

val adapterConfig =
  AdapterInitializationConfig.Builder()
    .setAllowedAdUnitIds(setOf(AD_UNIT_ID))
    .setInitializationTimeoutMs(5000)
    .build()
ConfigurableInitSnippets.kt

Java

AdapterInitializationConfig adapterConfig =
    new AdapterInitializationConfig.Builder()
        .setAllowedAdUnitIds(Set.of(AD_UNIT_ID))
        .setInitializationTimeoutMs(5000)
        .build();
ConfigurableInitSnippets.java

O exemplo a seguir cria uma configuração de inicialização do adaptador que inicializa apenas os adaptadores de mediação necessários para todos os anúncios abertos e define um tempo limite de cinco segundos:

Kotlin

val adapterConfig =
  AdapterInitializationConfig.Builder()
    .setAllowedAdFormats(setOf(AdFormat.APP_OPEN_AD))
    .setInitializationTimeoutMs(5000)
    .build()
ConfigurableInitSnippets.kt

Java

AdapterInitializationConfig adapterConfig =
    new AdapterInitializationConfig.Builder()
        .setAllowedAdFormats(Set.of(AdFormat.APP_OPEN_AD))
        .setInitializationTimeoutMs(5000)
        .build();
ConfigurableInitSnippets.java

Inicializar adaptadores de mediação específicos

Se você souber exatamente quais parceiros de mediação normalmente preenchem sua primeira impressão de anúncio, inicialize apenas esse adaptador específico fornecendo o nome da classe do adaptador na configuração de inicialização dele. Combine isso com o pulo explícito dos adaptadores não inicializados e defina um tempo limite para GMA Next-Gen SDK para não esperar pelos adaptadores não inicializados restantes durante o leilão.

O exemplo a seguir cria uma configuração de inicialização do adaptador que inicializa um adaptador de mediação específico e define um tempo limite de cinco segundos:

Kotlin

val adapterConfig =
  AdapterInitializationConfig.Builder()
    .setAllowedAdapterClasses(setOf(ADAPTER_JAVA_CLASS_NAME))
    .setInitializationTimeoutMs(5000)
    .build()
ConfigurableInitSnippets.kt

Java

AdapterInitializationConfig adapterConfig =
    new AdapterInitializationConfig.Builder()
        .setAllowedAdapterClasses(Set.of(ADAPTER_JAVA_CLASS_NAME))
        .setInitializationTimeoutMs(5000)
        .build();
ConfigurableInitSnippets.java

É possível buscar os nomes das classes de adaptadores de maneira programática. O exemplo a seguir extrai nomes de classes de adaptadores de maneira programática:

Kotlin

ExampleMediationAdapter::class.java.name

Java

ExampleMediationAdapter.class.getName()

Excluir adaptadores de mediação específicos

Se você notar que determinados adaptadores de mediação têm latência consistentemente alta, exclua esses adaptadores e inicialize-os mais tarde.

O exemplo a seguir cria uma configuração de inicialização do adaptador que impede a inicialização de adaptadores específicos e define um tempo limite de cinco segundos:

Kotlin

val adapterConfig =
  AdapterInitializationConfig.Builder()
    .setExcludedAdapterClasses(setOf(ADAPTER_JAVA_CLASS_NAME))
    .setInitializationTimeoutMs(5000)
    .build()
ConfigurableInitSnippets.kt

Java

AdapterInitializationConfig adapterConfig =
    new AdapterInitializationConfig.Builder()
        .setExcludedAdapterClasses(Set.of(ADAPTER_JAVA_CLASS_NAME))
        .setInitializationTimeoutMs(5000)
        .build();
ConfigurableInitSnippets.java

Dica: inicialize adaptadores em grupos usando várias chamadas, como duas chamadas separadas para adaptadores relevantes, para evitar que um adaptador lento bloqueie outros ou os callbacks deles.

Ignorar adaptadores não inicializados

Se você planeja inicializar ou excluir adaptadores de mediação específicos, configure sua solicitação de anúncio para ignorar adaptadores não inicializados que ainda estão presentes na hierarquia.

Se você não criar uma configuração de adaptador, ainda poderá configurar sua solicitação de anúncio para ignorar adaptadores não inicializados. GMA Next-Gen SDK emite uma solicitação de anúncio sem esperar que os adaptadores atinjam o tempo limite ou não sejam inicializados.

Importante: por padrão, o GMA Next-Gen SDK inicializa todos os adaptadores de mediação associados ao ID do bloco de anúncios ao alcançar o grupo de mediação na hierarquia de solicitações de anúncios.

O exemplo a seguir inicializa o SDK com uma configuração de inicialização do adaptador e cria uma solicitação de anúncio de abertura do app que ignora adaptadores não inicializados:

Kotlin

val initConfig =
  InitializationConfig.Builder(appId)
    .setAdapterInitializationConfig(adapterInitializationConfig)
    .build()

// Initialize the GMA Next-Gen SDK with a config containing your adapter initialization
// settings.
val backgroundScope = CoroutineScope(Dispatchers.IO)
backgroundScope.launch {
  MobileAds.initialize(context = context, initConfig) {

    // Make your ad request after adapter initialization completes.
    AppOpenAd.load(
      AdRequest.Builder(adUnitId = adUnitId)
        // Set this to guarantee that the ad request
        // doesn't wait for any other uninitialized adapters.
        .skipUninitializedAdapters()
        .build(),
      adLoadCallback =
        object : AdLoadCallback<AppOpenAd> {

          override fun onAdLoaded(ad: AppOpenAd) {
            // TODO: Your ad logic here
            // ....

            // Execute non-time-sensitive tasks after ad load completes.
            performPostLaunchSetup()
          }

          override fun onAdFailedToLoad(adError: LoadAdError) {
            // TODO: Handle load error.
            // ....

            // Ensure non-time-sensitive post-launch tasks execute even if ad load fails.
            performPostLaunchSetup()
          }
        },
    )
  }
}
ConfigurableInitSnippets.kt

Java

InitializationConfig initConfig =
    new InitializationConfig.Builder(appId)
        .setAdapterInitializationConfig(adapterInitializationConfig)
        .build();

// Initialize the GMA Next-Gen SDK with a config containing your adapter initialization
// settings.
MobileAds.initialize(
    context,
    initConfig,
    initializationStatus -> {
      // Make your ad request after adapter initialization completes.
      AppOpenAd.load(
          new AdRequest.Builder(adUnitId)
              // Set this to guarantee that the ad request
              // doesn't wait for any other uninitialized adapters.
              .skipUninitializedAdapters()
              .build(),
          new AdLoadCallback<AppOpenAd>() {
            @Override
            public void onAdLoaded(@NonNull AppOpenAd ad) {
              // TODO: Your ad logic here
              // ....

              // Execute non-time-sensitive tasks after ad load completes.
              performPostLaunchSetup();
            }

            @Override
            public void onAdFailedToLoad(@NonNull LoadAdError error) {
              // TODO: Handle load error.
              // ....

              // Ensure non-time-sensitive post-launch tasks execute even if ad load fails.
              performPostLaunchSetup();
            }
          });
    });
ConfigurableInitSnippets.java

Inicializar os adaptadores restantes

Depois que as oportunidades de anúncios sensíveis ao tempo forem carregadas, inicialize os adaptadores restantes para garantir a cobertura total da mediação de parceiros durante o restante da sessão do app.

O exemplo a seguir inicializa o restante dos adaptadores fornecendo uma configuração vazia:

Kotlin

// Provide initializeAdapters with an empty configuration to initialize
// any adapters not initialized with configurable initialization.
MobileAds.initializeAdapters(AdapterInitializationConfig.Builder().build())
ConfigurableInitSnippets.kt

Java

// Provide initializeAdapters with an empty configuration to initialize
// any adapters not initialized with configurable initialization.
MobileAds.initializeAdapters(new AdapterInitializationConfig.Builder().build());
ConfigurableInitSnippets.java