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

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. Esse recurso permite controlar quais adaptadores são inicializados para sua primeira impressão de anúncio e reduz a latência dela.

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

Pré-requisitos

  • Ative esse recurso adicionando 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 de 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 seu app, considere as seguintes estratégias ao criar uma configuração de inicialização do adaptador:

Priorizar um formato 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 de 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()

Java

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

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

Kotlin

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

Java

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

Inicializar adaptadores de mediação específicos

Se você sabe exatamente quais parceiros de mediação costumam preencher sua primeira impressão de anúncio, pode inicializar apenas esse adaptador específico informando o nome da classe dele na configuração de inicialização. 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 de 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()

Java

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

É possível buscar os nomes das classes de adaptador de forma programática. O exemplo a seguir extrai nomes de classe de adaptador de forma 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 uma 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 exclui adaptadores específicos da inicialização e define um tempo limite de cinco segundos:

Kotlin

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

Java

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

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 expirem ou falhem ao inicializar.

O exemplo a seguir inicializa o SDK com uma configuração de inicialização de 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()
          }
        },
    )
  }
}

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

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

Java

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