Interstitial Ads

Interstitial ads are full-screen ads that cover the interface of their host app. They're typically displayed at natural transition points in the flow of an app, such as during the pause between levels in a game. When an app shows an interstitial ad, the user has the choice to either tap on the ad and continue to its destination or close it and return to the app.

This guide explains how to integrate interstitial ads into a Unity app.

Prerequisites

Complete Get Started. Your Unity app should already have the Google Mobile Ads Unity plugin imported.

Create an interstitial ad

The first step toward displaying a interstitial is to create an InterstitialAd object in a script attached to a GameObject.

using GoogleMobileAds.Api;
…
private void RequestInterstitial()
{
    #if UNITY_ANDROID
        string adUnitId = "ca-app-pub-3940256099942544/1033173712";
    #elif UNITY_IPHONE
        string adUnitId = "ca-app-pub-3940256099942544/4411468910";
    #else
        string adUnitId = "unexpected_platform";
    #endif

    // Initialize an InterstitialAd.
    InterstitialAd interstitial = new InterstitialAd(adUnitId);
}

The constructor for InterstitialAd has the following parameter:

• adUnitId - The AdMob ad unit ID from which the InterstitialAd should load ads.

It's important to note how different ad units are used, depending on the platform. You'll need to use an iOS ad unit for making ad requests on iOS and an Android ad unit for making requests on Android.

Always test with test ads

The sample code above contains an ad unit ID and you're free to request ads with it. It's been specially configured to return test ads rather than production ads for every request, which makes it safe to use.

However, once you register an app in the AdMob UI and create your own ad unit IDs for use in your app, you'll need to explicitly configure your device as a test device when you're developing. This is extremely important. Testing with real ads (even if you never tap on them) is against AdMob policy and can cause your account to be suspended. See Test Ads for information on how you can make sure you always get test ads when developing.

Load an ad

Once the InterstitialAd is instantiated, the next step is to load an ad. That's done with the loadAd() method in the InterstitialAd class. It takes an AdRequest argument, which holds runtime information (such as targeting info) about a single ad request.

Here's an example that shows how to load an ad:

using GoogleMobileAds.Api;
…
private void RequestInterstitial()
{
    #if UNITY_ANDROID
        string adUnitId = "ca-app-pub-3940256099942544/1033173712";
    #elif UNITY_IPHONE
        string adUnitId = "ca-app-pub-3940256099942544/4411468910";
    #else
        string adUnitId = "unexpected_platform";
    #endif

    // Initialize an InterstitialAd.
    InterstitialAd interstitial = new InterstitialAd(adUnitId);
    // Create an empty ad request.
    AdRequest request = new AdRequest.Builder().Build();
    // Load the interstitial with the request.
    interstitial.LoadAd(request);
}

Note: On iOS, InterstitialAd objects are one time use objects. That means once an interstitial is shown, the InterstitialAd object can't be used to load another ad. To request another interstitial, you'll need to create a new InterstitialAd object.

Show the ad

Interstitial ads should be displayed during natural pauses in the flow of an app. Between levels of a game is a good example, or after the user completes a task. To show an interstitial, use the isLoaded() method to verify that it's done loading, then call show().

The interstitial ad from the previous code example could be shown at the end of a game, as demonstrated below.

private void GameOver()
{
  if (interstitial.IsLoaded()) {
    interstitial.Show();
  }
}

Ad events

To further customize the behavior of your ad, you can hook into a number of events in the ad's lifecycle: loading, opening, closing, and so on. Listen for these events by registering a delegate for the appropriate EventHandler, as shown below.

using GoogleMobileAds.Api;
…
private void RequestInterstitial()
{
    #if UNITY_ANDROID
        string adUnitId = "ca-app-pub-3940256099942544/1033173712";
    #elif UNITY_IPHONE
        string adUnitId = "ca-app-pub-3940256099942544/4411468910";
    #else
        string adUnitId = "unexpected_platform";
    #endif

     // Initialize an InterstitialAd.
    InterstitialAd interstitial = new InterstitialAd(adUnitId);

    // Called when an ad request has successfully loaded.
    interstitial.OnAdLoaded += HandleOnAdLoaded;
    // Called when an ad request failed to load.
    interstitial.OnAdFailedToLoad += HandleOnAdFailedToLoad;
    // Called when an ad is shown.
    interstitial.OnAdOpening += HandleOnAdOpened;
    // Called when the ad is closed.
    interstitial.OnAdClosed += HandleOnAdClosed;
    // Called when the ad click caused the user to leave the application.
    interstitial.OnAdLeavingApplication += HandleOnAdLeavingApplication;

    // Create an empty ad request.
    AdRequest request = new AdRequest.Builder().Build();
    // Load the interstitial with the request.
    interstitial.LoadAd(request);

    public void HandleOnAdLoaded(object sender, EventArgs args)
    {
        MonoBehaviour.print("HandleAdLoaded event received");
    }

    public void HandleOnAdFailedToLoad(object sender, AdFailedToLoadEventArgs args)
    {
        MonoBehaviour.print("HandleFailedToReceiveAd event received with message: "
                            + args.Message);
    }

    public void HandleOnAdOpened(object sender, EventArgs args)
    {
        MonoBehaviour.print("HandleAdOpened event received");
    }

    public void HandleOnAdClosed(object sender, EventArgs args)
    {
        MonoBehaviour.print("HandleAdClosed event received");
    }

    public void HandleOnAdLeftApplication(object sender, EventArgs args)
    {
        MonoBehaviour.print("HandleAdLeftApplication event received");
    }
}

The OnAdFailedToLoad event contains special event arguments. It passes an instance of HandleAdFailedToLoadEventArgs with a Message describing the error:

public void HandleOnAdFailedToLoad(object sender, AdFailedToLoadEventArgs args)
{
  print("Interstitial failed to load: " + args.Message);
  // Handle the ad failed to load event.
};

Ad event	Description
OnAdLoaded	The OnAdLoaded event is executed when an ad has finished loading.
OnAdFailedToLoad	The OnAdFailedToLoad event is invoked when an ad fails to load. The Message parameter describes the type of failure that occurred.
OnAdOpening	This method is invoked when the ad is displayed, covering the device's screen. If you're using an analytics package to track clickthroughs, this is a good place to record one.
OnAdClosed	This method is invoked when when the interstitial ad is closed due to the user tapping on the close icon or using the back button. If your app paused its audio output or game loop, this is a great place to resume it.
OnAdLeavingApplication	This method is invoked after OnAdOpened, when a user click opens another app (such as the Google Play store), backgrounding the current app.

Clean up interstitial ads

When you are finished with a InterstitialAd, make sure to call the Destroy() method before dropping your reference to it:

interstitial.Destroy();

This notifies the plugin that the object is no longer used and the memory it occupies can be reclaimed. Failure to call this method results in memory leaks.

Some best practices

Consider whether interstitial ads are the right type of ad for your app.

Interstitial ads work best in apps with natural transition points. The conclusion of a task within an app, such as sharing an image or completing a game level, creates such a point. Because the user is expecting a break in the action, it's easy to present an interstitial ad without disrupting their experience. Make sure you consider at which points in your app's workflow you'll display interstitial ads and how the user is likely to respond.

Remember to pause the action when displaying an interstitial ad.

There are a number of different types of interstitial ads: text, image, video, and more. It's important to make sure that when your app displays an interstitial ad, it also suspends its use of some resources to allow the ad to take advantage of them. For example, when you make the call to display an interstitial ad, be sure to pause any audio output being produced by your app. You can resume playing sounds in the onAdClosed() event handler, which will be invoked when the user has finished interacting with the ad. In addition, consider temporarily halting any intense computation tasks (such as a game loop) while the ad is being displayed. This will make sure the user doesn't experience slow or unresponsive graphics or stuttered video.

Allow for adequate loading time.

Just as it's important to make sure you display interstitial ads at an appropriate time, it's also important to make sure the user doesn't have to wait for them to load. Loading the ad in advance by calling loadAd() before you intend to call show() can ensure that your app has a fully loaded interstitial ad at the ready when the time comes to display one.

Don't flood the user with ads.

While increasing the frequency of interstitial ads in your app might seem like a great way to increase revenue, it can also degrade the user experience and lower clickthrough rates. Make sure that users aren't so frequently interrupted that they're no longer able to enjoy the use of your app.

Additional resources

Samples

• HelloWorld example — a minimal implementation of all ad formats

Next steps

• Create your own interstitial ad unit in the AdMob UI.
• Try another ad format:
  • Banner
  • Rewarded Video