Banner ads are rectangular ads that occupy a portion of an app's layout. They stay on screen while users are interacting with the app, either anchored at the top or bottom of the screen or inline with content as the user scrolls. Banner ads can refresh automatically after a certain period of time. See Overview of banner ads for more information.
This guide shows you how to get started with anchored adaptive banner ads, which maximizes performance by optimizing the ad size for each device using an ad width you specify.
Anchored adaptive banner ads are fixed aspect ratio ads rather than the regular fixed size ads. The aspect ratio is similar to 320x50 industry standard. Once you specify the full width available, it will return you an ad with optimal height for that width. The optimal height doesn't change across requests from the same device, and the surrounding views don't need to move when the ad refreshes.
Prerequisites
- Complete the Get started guide.
Always test with test ads
When building and testing your apps, make sure you use test ads rather than live, production ads. Failure to do so can lead to suspension of your account.
The easiest way to load test ads is to use our dedicated test ad unit ID for Android banners:
ca-app-pub-3940256099942544/9214589741
It's been specially configured to return test ads for every request, and you can use it in your own apps while coding, testing, and debugging. Just make sure you replace it with your own ad unit ID before publishing your app.
For more information about how the Mobile Ads SDK's test ads work, see Test Ads.
Add AdView to the layout
The first step toward displaying a banner is to place AdView
in your app's layout:
Java
// Create a new ad view.
adView = new AdView(this);
adView.setAdUnitId(AD_UNIT_ID);
adView.setAdSize(getAdSize());
// Replace ad container with new ad view.
adContainerView.removeAllViews();
adContainerView.addView(adView);
Kotlin
// Create a new ad view.
val adView = AdView(this)
adView.adUnitId = AD_UNIT_ID
adView.setAdSize(adSize)
this.adView = adView
// Replace ad container with new ad view.
binding.adViewContainer.removeAllViews()
binding.adViewContainer.addView(adView)
Load an ad
Once the AdView is in place, the next step is to
load an ad. That's done with the loadAd()
method in the AdView class. It takes an AdRequest
parameter, which holds runtime information, such as targeting info, about a
single ad request.
Here's an example that shows how to load an ad:
Java
// Start loading the ad in the background.
AdRequest adRequest = new AdRequest.Builder().build();
adView.loadAd(adRequest);
Kotlin
// Start loading the ad in the background.
val adRequest = AdRequest.Builder().build()
adView.loadAd(adRequest)
If successful, your app is ready to display banner ads.
Refresh an ad
If you configured your ad unit to refresh, you don't need to request another ad when the ad fails to load. The Google Mobile Ads SDK respects any refresh rate you specified in the AdMob UI. If you haven't enabled refresh, issue a new request. For more details on ad unit refresh, such as setting a refresh rate, see Use automatic refresh for Banner ads.
Ad events
You can listen for a number of events in the ad's lifecycle, including loading, ad impression and click, as well as ad open and close events. It is recommended to set the callback before loading the banner.Java
adView.setAdListener(new AdListener() {
@Override
public void onAdClicked() {
// Code to be executed when the user clicks on an ad.
}
@Override
public void onAdClosed() {
// Code to be executed when the user is about to return
// to the app after tapping on an ad.
}
@Override
public void onAdFailedToLoad(LoadAdError adError) {
// Code to be executed when an ad request fails.
}
@Override
public void onAdImpression() {
// Code to be executed when an impression is recorded
// for an ad.
}
@Override
public void onAdLoaded() {
// Code to be executed when an ad finishes loading.
}
@Override
public void onAdOpened() {
// Code to be executed when an ad opens an overlay that
// covers the screen.
}
});
Kotlin
adView.adListener = object: AdListener() {
override fun onAdClicked() {
// Code to be executed when the user clicks on an ad.
}
override fun onAdClosed() {
// Code to be executed when the user is about to return
// to the app after tapping on an ad.
}
override fun onAdFailedToLoad(adError : LoadAdError) {
// Code to be executed when an ad request fails.
}
override fun onAdImpression() {
// Code to be executed when an impression is recorded
// for an ad.
}
override fun onAdLoaded() {
// Code to be executed when an ad finishes loading.
}
override fun onAdOpened() {
// Code to be executed when an ad opens an overlay that
// covers the screen.
}
}
Each of the overridable methods in
AdListener
corresponds to an event in the lifecycle of an ad.
| Overridable methods | |
|---|---|
onAdClicked() |
The onAdClicked()
method is invoked when a click is recorded for an ad.
|
onAdClosed() |
The onAdClosed()
method is invoked when a user returns to the app after viewing an ad's
destination URL. Your app can use it to resume suspended activities or
perform any other work necessary to make itself ready for interaction.
Refer to the AdMob
AdListener example for an implementation of the ad listener methods in the
Android API Demo app.
|
onAdFailedToLoad() |
The onAdFailedToLoad()
method is the only one that includes a parameter. The error parameter of type
LoadAdError describes what error occurred. For more information,
refer to the Debugging Ad Load Errors
documentation.
|
onAdImpression() |
The onAdImpression()
method is invoked when an impression is recorded for an ad.
|
onAdLoaded() |
The onAdLoaded()
method is executed when an ad has finished loading. If you want to delay
adding the AdView
to your activity or fragment until you're sure an ad will be loaded, for
example, you can do so here.
|
onAdOpened() |
The onAdOpened()
method is invoked when an ad opens an overlay that covers the screen.
|
Hardware acceleration for video ads
In order for video ads to show successfully in your banner ad views, hardware acceleration must be enabled.
Hardware acceleration is enabled by default, but some apps may choose to disable
it. If this applies to your app, we recommend enabling hardware acceleration for
Activity classes that use ads.
Enabling hardware acceleration
If your app does not behave properly with hardware acceleration turned on
globally, you can control it for individual activities as well. To enable or
disable hardware acceleration, you can use the android:hardwareAccelerated
attribute for the
<application>
and
<activity>
elements in your AndroidManifest.xml. The following example enables hardware
acceleration for the entire app but disables it for one activity:
<application android:hardwareAccelerated="true">
<!-- For activities that use ads, hardwareAcceleration should be true. -->
<activity android:hardwareAccelerated="true" />
<!-- For activities that don't use ads, hardwareAcceleration can be false. -->
<activity android:hardwareAccelerated="false" />
</application>
See the Hardware acceleration guide for more information about options for controlling hardware acceleration. Note that individual ad views cannot be enabled for hardware acceleration if the activity is disabled, so the activity itself must have hardware acceleration enabled.
Additional resources
Examples on GitHub
Next steps
Collapsible banners
Collapsible banner ads are banner ads that are initially presented as a larger overlay, with a button to collapse the ad to a smaller size. Consider using it to further optimize your performance. See collapsible banner ads for more details.
Inline adaptive banners
Inline adaptive banners are larger, taller banners compared to anchored adaptive banners. They are of variable height, and can be as tall as the device screen. Inline adaptive banners are recommended over anchored adaptive banner ads for apps that place banner ads in scrollable content. See inline adaptive banners for more details.