<br />

By default, GMA Next-Gen SDK initializes all mediation adapters associated with your application during initialization. Initializing every adapter can take more than 30 seconds, leading to significant latency before your first ad can load.

<br />

To solve this issue, AdMob provides Configurable Adapter
Initialization. This feature lets you control which adapters are
initialized for your first ad impression, and reduces latency for that
impression.

> [!NOTE]
> **Note:** Configurable Adapter Initialization is in alpha.

This guide covers the following aspects of Configurable Adapter Initialization:

- [Create an adapter configuration](https://developers.google.com/admob/android/next-gen/use-configurable-adapter-initialization.md.txt#create_an_adapter_configuration)
- [Skip uninitialized adapters](https://developers.google.com/admob/android/next-gen/use-configurable-adapter-initialization.md.txt#skip_uninitialized_adapters)
- [Initialize remaining adapters](https://developers.google.com/admob/android/next-gen/use-configurable-adapter-initialization.md.txt#initialize_remaining_adapters)

## Prerequisites

- Import GMA Next-Gen SDK v0.25.0-beta01 or higher.
- [Set up GMA Next-Gen SDK](https://developers.google.com/admob/android/next-gen/quick-start.md.txt).

<!-- -->

- Opt in to this feature by adding the [`@ExperimentalApi`](https://developers.google.com/admob/android/next-gen/reference/kotlin/com/google/android/libraries/ads/mobile/sdk/common/ExperimentalApi.md.txt) annotation to your class:

  ### Kotlin

  ```kotlin
  @OptIn(ExperimentalApi::class)
  ```

  ### Java

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

## Create an adapter configuration

An adapter initialization configuration instructs GMA Next-Gen SDK to initialize
only the required adapters. This prevents unnecessary adapters from blocking
your first ad request, conserving computation resources and significantly
reducing latency for the first ad impression.

To optimize your app's performance, consider the following strategies as you
create an adapter initialization configuration:

### Prioritize specific Ad Format or Ad Unit

Improve the performance of apps that show an ad immediately upon launch, such as
an app open ad, by declaring the specific ad format or ad unit in your adapter
initialization configuration.

The following example creates an adapter initialization configuration that
initializes only the required mediation adapters for a specific app open ad unit
with a five second timeout:

### Kotlin

```kotlin
val adapterConfig =
  AdapterInitializationConfig.Builder()
    .setAllowedAdUnitIds(setOf(AD_UNIT_ID))
    .setInitializationTimeoutMs(5000)
    .build()

```

### Java

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

<br />

The following example creates an adapter initialization configuration that
initializes only the required mediation adapters for all App Open Ads and sets a
five second timeout:

### Kotlin

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

```

### Java

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

<br />

### Initialize specific mediation adapters

If you know exactly which mediation partners typically fill your first ad
impression, you can initialize only that specific adapter by providing the
adapter class name in your adapter initialization configuration. Combine this
with explicitly [skipping the uninitialized
adapters](https://developers.google.com/admob/android/next-gen/use-configurable-adapter-initialization#skip_uninitialized_adapters) and setting a timeout for GMA Next-Gen SDK
to not wait for remaining uninitialized adapters during the auction.

The following example creates an adapter initialization configuration that
initializes a specific mediation adapter and sets a five second timeout:

### Kotlin

```kotlin
val adapterConfig =
  AdapterInitializationConfig.Builder()
    .setAllowedAdapterClasses(setOf(ADAPTER_JAVA_CLASS_NAME))
    .setInitializationTimeoutMs(5000)
    .build()

```

### Java

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

You can fetch the adapter class names programmatically. The following example
pulls adapter class names programmatically:

### Kotlin

```kotlin
ExampleMediationAdapter::class.java.name
```

### Java

```java
ExampleMediationAdapter.class.getName()
```

<br />

### Exclude specific mediation adapters

If you observe that certain mediation adapters have consistently high latency,
you can exclude these adapters and initialize them at a later time.

The following example creates an adapter initialization configuration that
excludes specific adapters from initializing, and sets a five second timeout:

### Kotlin

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

```

### Java

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

<br />

> [!TIP]
> **Tip:** Initialize adapters in groups using multiple calls, such as two separate calls for relevant adapters, to prevent a slow adapter from blocking others or their callbacks.

## Skip uninitialized adapters

If you plan to initialize or exclude specific mediation adapters, you can
configure your ad request to skip uninitialized adapters that are still present
in your waterfall.

If you don't [create an adapter
configuration](https://developers.google.com/admob/android/next-gen/use-configurable-adapter-initialization#create_an_adapter_configuration), you can still configure your
ad request to skip uninitialized adapters. GMA Next-Gen SDK issues an ad
request without waiting for adapters to time out or fail to
initialize.

> [!IMPORTANT]
> **Important:** By default, GMA Next-Gen SDK initializes all mediation adapters associated with the ad unit ID when reaching the mediation group in the ad request waterfall.

The following example initializes the SDK with an adapter initialization
configuration and creates an app open ad request that skips uninitialized
adapters:

### Kotlin

```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

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

<br />

## Initialize remaining adapters

After your time-sensitive ad opportunities have loaded, initialize your
remaining adapters to ensure full partner mediation coverage for the rest of the
app session.

The following example initializes the rest of the adapters by providing an empty
configuration:

### Kotlin

```kotlin

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

```

### Java

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

<br />

<br />