App Open Ads

App open ads resemble 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

• Display a splash/loading screen before you show the app open ad. Do this no matter how you place the ad.
  • 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 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 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 often. 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.
  • Show to users that have had a session in the last several days.
  • 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 user backgrounds the app 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 the user brings your application to the foreground, preload a MAAppOpenAd. Create a method that shows an ad if one is ready. Call that method inside applicationDidBecomeActive:.

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

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, the user may briefly see your app and then be surprised by an out-of-context ad. Prevent this bad user experience. You can handle cold starts by showing a loading screen before any app content, and then showing the ad after the loading screen. If your app shows any app content after the loading screen, do not show the ad.

If you have a loading screen under the app open ad, and that loading screen completes before the user dismisses the ad, you can dismiss your loading screen in the didHide method.

Examples

These code examples assume that app open ads show only on “soft launch” after your app is suspended in memory. They do not include the splash/loading screen. You must handle the splash/loading screen—see Best Practices.

Objective-C

@interface AppDelegate()<MAAdDelegate>
@property (nonatomic, strong) MAAppOpenAd *appOpenAd;
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  [[ALSdk shared] initializeSdkWithCompletionHandler:^(ALSdkConfiguration *configuration) {
    self.appOpenAd = [[MAAppOpenAd alloc] initWithAdUnitIdentifier: @"«ad-unit-ID»"];
    self.appOpenAd.delegate = self;
    [self.appOpenAd loadAd];
  }]

  return YES;
}

- (void)applicationDidBecomeActive:(UIApplication *)application
{
  [self showAdIfReady];
}

- (void)showAdIfReady
{
  if ( ![[ALSdk shared] isInitialized] )
  {
    return;
  }

  if ( [self.appOpenAd isReady] )
  {
    [self.appOpenAd showAdForPlacement: @"«test-placement-ID»"];
  }
  else
  {
    [self.appOpenAd loadAd];
  }
}

- (void)didLoadAd:(MAAd *)ad {}
- (void)didFailToLoadAdForAdUnitIdentifier:(NSString *)adUnitIdentifier withError:(MAError *)error {}
- (void)didDisplayAd:(MAAd *)ad {}
- (void)didClickAd:(MAAd *)ad {}

- (void)didHideAd:(MAAd *)ad
{
  [self.appOpenAd loadAd];
}

- (void)didFailToDisplayAd:(MAAd *)ad withError:(MAError *)error
{
  [self.appOpenAd loadAd];
}

@end

Swift

@UIApplicationMain
class AppDelegate: UIApplicationDelegate
{
  private lazy var appOpenAd = MAAppOpenAd(adUnitIdentifier: "«ad-unit-ID»")

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool
  {
    ALSdk.shared().initializeSdk { (configuration: ALSdkConfiguration) in
      appOpenAd.delegate = self
      appOpenAd.load()
    }

    return true
  }

  func applicationDidBecomeActive(_ application: UIApplication)
  {
    showAdIfReady()
  }

  private func showAdIfReady()
  {
    if ALSdk.shared().isInitialized
    {
      return
    }

    if appOpenAd.isReady
    {
      appOpenAd.show(forPlacement: "«test-placement-ID»")
    }
    else
    {
      appOpenAd.load()
    }
  }
}

extension AppDelegate : MAAdDelegate
{
  func didLoad(_ ad: MAAd) {}
  func didFailToLoadAd(forAdUnitIdentifier adUnitIdentifier: String, withError error: MAError) {}
  func didDisplay(_ ad: MAAd) {}
  func didClick(_ ad: MAAd) {}

  func didHide(_ ad: MAAd)
  {
    appOpenAd.load()
  }

  func didFail(toDisplay ad: MAAd, withError error: MAError)
  {
    appOpenAd.load()
  }
}

Supported Adapter Versions

Ad Network	Minimum Adapter Version
BIGO Ads	4.2.1.0
Google Bidding and Google AdMob	10.9.0.1
Liftoff Monetize	6.12.0.3
Mintegral	7.2.3.0.1
Pangle	4.6.2.2.1