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, turning the phone on when the app is in foreground mode

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

FireOS Applications are not supported.

Best Practices

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

Using an App Open Ad

To ensure your app open ad is ready when your application is brought to the foreground, you need to preload a MAAppOpenAd. Create a method that shows an ad (if ready) and call that method inside applicationDidBecomeActive:. Your app then attempts to show an ad on app open, or loads one if one is not not preloaded. If you have a loading screen under the app open ad, and your loading screen completes loading before the ad is dismissed, you may want to dismiss your loading screen in the didHide method.

Cold Starts and Loading Screens

The delay between when you request an ad and receive an ad to show can cause the user to briefly see your app before being 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 use a loading screen to precede any initial app content, and to show the ad from the loading screen. If the app shows any of your app content after the loading screen, do not show the ad.

Examples

These code examples assume that app open ads are only shown on “soft lauch” when your app is suspended in memory, and do not include the splash/loading screen. The App Developer must handle the splash/loading screen—see Best Practices.

• @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

• @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