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 theInterstitialAd
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); }
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 callshow()
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: