App Open Ads

AppLovin SDK v11.5.0 introduces App Open Ad format. App Open Ads are similar to interstitial ads but show when the user soft launches or cold starts the app:

Cold start

creating new session of the app on device

• the app is not in device memory
• splash/loading screen required

Soft launch

bringing the app from background to foreground, or turning the phone on when the app is in foreground mode

• the app is suspended in memory
• splash/loading screen required

Note

Fire OS Applications are not supported.

Best Practices

• Use a splash/loading screen before the app open ad shows. Do this no matter how the ad is placed within the app.
  • Include a call-out to the user that tells them they will see an ad within the Splash/Loading screen.
    • For example: “Watch an ad from their sponsor while the app loads.”
  • Ensure that the user is not exposed to actual app content before the ad shows. The correct sequence is: splash/loading screen ⇒ app open ad ⇒ app content.
• Ensure that AppLovin’s SDK initializes before you load an app open ad.
• When an app open ad is not yet loaded (i.e. on cold start), load it first. Load any other ad formats later so that you avoid loading them in parallel with the app open ad.
  • Loading multiple ad formats in parallel is not good for the device’s resources or for ad demand SDKs.
• To avoid over-exposing users to App Open Ads, AppLovin suggests that you consider the following strategies:
  • Use a frequency cap that you manage outside of AppLovin. This way you have full control over when the ads will serve.
  • Implement a cool down period based on user behavior in the app. For example: don’t show an ad during soft launch for some period of time before you show one again, or show an ad only during every other soft launch.
  • Wait until new users open the app and use it a few times before you show the first App Open Ad.

Retention

Always consider retention when you implement the App Open Ad format.

For app open ads, you can choose from a variety of implementation strategies.

AppLovin recommends that you test by using one or more of the techniques described below. Each application has a unique configuration that allows it to maximize revenue without impacting retention or time spent in the app. User behavior and engagement may change over time, so AppLovin recommends that you retest your App Open Ads strategies regularly. Some implementation techniques you may use to test App Open Ads include:

• Show to the right users. Examples of this technique include:
  • Wait a variable number of days after initial install to show on cold start.
  • Only show to users that have had a session in the last several days.
  • Only show to users that have reached certain criteria in the app. For example they have completed a certain level, they have opened the app a certain number of times, or they do not engage with Rewarded offerings.
• Avoid over-exposing ads to users. Examples of this technique include:
  • Do not show an ad on every opportunity. Instead, show on every other, third, or fourth ad opportunity.
  • Only show an ad if the app is backgrounded for a certain amount of time (i.e. 30 seconds, 2 minutes, 15 minutes).
  • If you show a cold start ad, do not show soft launch app open ads or interstitials for a certain amount of time.
  • Use a frequency cap. If possible, tailor that cap according to the user cohort.
• Use a splash screen to inform the user.
  • Refer to the section on splash screens in “Best Practices” above.

Using an App Open Ad

To ensure your app open ad is ready when your application is brought to the foreground, you should preload a MaxAppOpenAd. Create a utility class and instantiate it within your Application class. Then that class can make ad requests before you need to show your ad. Create a method that shows an ad if ready. Call this method inside the Lifecycle.Event.ON_START lifecycle event.

Your app then attempts to show an ad on app open, or loads an ad if one is not preloaded.

Listen for App Foregrounding Events

To be notified of app foregrounding events, you need to register a LifecycleObserver. You may need to add a lifecycle library to your application-level build.gradle file:

implementation("androidx.lifecycle:lifecycle-process:2.2.0")

Cold Starts and Loading Screens

There is a delay between when you request an ad and when you receive an ad to show. If you do not design your app well, this can cause the user to briefly see your app and then to be surprised by an out-of-context ad. You should avoid this, as it is a bad user experience. The preferred way to handle cold starts is to display a loading screen before any app content, and then to show the ad subsequent to the loading screen. If your app shows any app content after the loading screen, do not show the ad.

You may have a loading screen under the app open ad, and that loading screen completes before the ad is dismissed. If so, you can dismiss your loading screen in the onAdHidden() method.

Example

This code example assumes that app open ads are shown only on “soft launch,” when your app is suspended in memory. It does not include the splash/loading screen. The App Developer must handle the splash/loading screen—see Best Practices.

Java

public class MyApplication extends Application
{
  private final ExampleAppOpenManager appOpenManager;

  @Override
  public void onCreate()
  {
    super.onCreate();

    AppLovinSdk.initializeSdk( this, new AppLovinSdk.SdkInitializationListener()
    {
      @Override
      public void onSdkInitialized(final AppLovinSdkConfiguration configuration)
      {
        appOpenManager = new ExampleAppOpenManager( this );
      }
    } );
  }
}

public class ExampleAppOpenManager
       implements LifecycleObserver, MaxAdListener
{
  private final MaxAppOpenAd appOpenAd;
  private final Context context;

  public AppOpenManager(final Context context)
  {
    ProcessLifecycleOwner.get().getLifecycle().addObserver( this );

    this.context = context;

    appOpenAd = new MaxAppOpenAd( "«ad-unit-ID»", context);
    appOpenAd.setListener( this );
    appOpenAd.loadAd();
  }

  private void showAdIfReady()
  {
    if ( appOpenAd == null || !AppLovinSdk.getInstance( context ).isInitialized() ) return;

    if ( appOpenAd.isReady() )
    {
      appOpenAd.showAd( "«test_placement»" );
    }
    else
    {
      appOpenAd.loadAd();
    }
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_START)
  public void onStart()
  {
    showAdIfReady();
  }

  @Override
  public void onAdLoaded(final MaxAd ad) {}
  @Override
  public void onAdLoadFailed(final String adUnitId, final MaxError error) {}
  @Override
  public void onAdDisplayed(final MaxAd ad) {}
  @Override
  public void onAdClicked(final MaxAd ad) {}

  @Override
  public void onAdHidden(final MaxAd ad)
  {
    appOpenAd.loadAd();
  }

  @Override
  public void onAdDisplayFailed(final MaxAd ad, final MaxError error)
  {
    appOpenAd.loadAd();
  }
}

Kotlin

class MyApplication : Application()
{
  private lateinit var appOpenManager: ExampleAppOpenManager

  override fun onCreate()
  {
    super.onCreate()

    AppLovinSdk.getInstance( this ).initializeSdk({ configuration: AppLovinSdkConfiguration ->
    {
      appOpenManager = ExampleAppOpenManager(applicationContext)
    })
  }
}

class ExampleAppOpenManager(applicationContext: Context?) : LifecycleObserver, MaxAdListener
{
  private lateinit var appOpenAd: MaxAppOpenAd
  private lateinit var context: Context

  init
  {
    ProcessLifecycleOwner.get().lifecycle.addObserver(this)

    context = applicationContext

    appOpenAd = MaxAppOpenAd("«ad-unit-ID»", applicationContext!!)
    appOpenAd.setListener(this)
    appOpenAd.loadAd()
  }

  private fun showAdIfReady()
  {
    if (appOpenAd == null || !AppLovinSdk.getInstance(context).isInitialized) return

    if (appOpenAd.isReady)
    {
      appOpenAd.showAd("«test_placement»")
    }
    else
    {
      appOpenAd.loadAd()
    }
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_START)
  fun onStart()
  {
    showAdIfReady()
  }

  override fun onAdLoaded(ad: MaxAd) {}
  override fun onAdLoadFailed(adUnitId: String, error: MaxError) {}
  override fun onAdDisplayed(ad: MaxAd) {}
  override fun onAdClicked(ad: MaxAd) {}

  override fun onAdHidden(ad: MaxAd)
  {
    appOpenAd.loadAd()
  }

  override fun onAdDisplayFailed(ad: MaxAd, error: MaxError)
  {
    appOpenAd.loadAd()
  }
}

Supported Adapter Versions

Ad Network	Minimum Adapter Version
Google Bidding and Google AdMob	22.2.0.2
Liftoff Monetize	6.12.0.2
Pangle	4.6.0.4.0