34.1 Ads

Understanding Ads in Android Apps

Advertising is one of the most common ways to earn money from Android apps. As a beginner, your goal is not to become an ad-tech expert, but to understand how ads fit into an app, what main types exist, and what is involved in adding them at a basic level.

This chapter focuses on ads as a monetization strategy. Other monetization methods will be covered in their own chapters.

How Ads Fit into Your App

Ads are pieces of content provided by an ad network that you display inside your app. When a user sees, clicks, or interacts with an ad, you may earn revenue according to the rules set by the ad network.

You do not create or host the ads yourself. Instead, you integrate an ad SDK provided by an ad network. The SDK communicates with the network’s servers to load and show ads.

From an Android developer’s point of view, integrating ads usually involves four main steps. You will see the details and library-specific code in practice later, but the general flow is:

1. Add the ad SDK dependency to your app using Gradle.
2. Declare any required permissions or configuration in AndroidManifest.xml.
3. Initialize the SDK in your application or activity.
4. Load and show ad formats where appropriate in your UI.

Common Ad Formats in Android Apps

Different ad formats have different effects on user experience. Choosing the right format is crucial. As a beginner, you should understand the main categories and what they are used for.

Banner Ads

Banner ads are rectangular ads that occupy a small part of the screen, typically at the top or bottom. They stay visible while the user interacts with your app.

For example, a news app might show a banner at the bottom of each article. Banners are relatively unobtrusive, but each banner usually earns a small amount of revenue, so they are often used in apps with frequent or long usage.

A simple layout snippet that reserves space for a banner-like view might look like this:

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <!-- Your main content here -->
    <!-- Banner ad area at the bottom -->
    <FrameLayout
        android:id="@+id/ad_container"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
</LinearLayout>

In real projects, the ad network’s SDK will provide a specific view type to place in this container.

Interstitial Ads

Interstitial ads are full-screen ads that cover most or all of the app’s content. They appear at natural breaks in your app, for example after completing a game level or after finishing an article.

Because they interrupt the user flow, they can be more profitable but also more annoying if overused or shown at bad times.

A common pattern is:

1. Load an interstitial ad in the background while the user is playing or reading.
2. When the user finishes a level or other action, check if the ad is ready.
3. Show the interstitial ad, then continue to the next screen after it is closed.

Rewarded Ads

Rewarded ads allow users to choose to watch an ad in exchange for something valuable inside your app. For example, in a game, the user can watch a short video to gain extra coins or an extra life.

Users often find rewarded ads more acceptable because they are voluntary and provide a clear benefit. You must reliably grant the reward to the user after the ad finishes successfully.

A very simplified flow looks like this:

fun onGetBonusClicked() {
    // 1. Load rewarded ad (usually done earlier, not at the exact click)
    // 2. Show rewarded ad if available
    // 3. On reward callback, give the user their bonus
}

Native Ads

Native ads are designed to match the look and feel of your app’s content. Instead of using a fixed ad view, the ad network gives you components such as title, image, and call-to-action text. You then place them inside your own custom layout.

For example, in a list of news articles, you could show a sponsored article that visually matches real articles but is clearly labeled as an ad.

Native ads can lead to better engagement but require more careful layout work and strict adherence to the ad network’s design and policy guidelines.

In-App Messages and Other Formats

Some ad networks offer additional formats such as app open ads or in-app messages. These are specialized formats that show ads at specific moments, such as immediately when the app is opened.

As a beginner, you should first become comfortable with simple formats such as banners and rewarded ads before exploring these more advanced options.

Integrating an Ad SDK at a High Level

Although you will use specific code and libraries in real projects, most ad integrations follow a similar pattern. Here is what it looks like conceptually.

Adding the Dependency with Gradle

To use an ad SDK, you add a dependency in your module-level build.gradle (or build.gradle.kts) file. The actual library name and version depend on the ad network.

For example, imagine an SDK with a fictional dependency:

dependencies {
    implementation("com.example.ads:android-sdk:1.0.0")
}

After adding the dependency, you sync the project so Android Studio downloads the library.

Manifest Configuration

Some ad SDKs require specific entries in AndroidManifest.xml, such as permissions for network access or a metadata tag for your ad app ID.

You might see elements like:

<uses-permission android:name="android.permission.INTERNET" />
<application
    ...>
    <meta-data
        android:name="com.example.ads.APP_ID"
        android:value="ca-app-pub-XXXXXXXXXXXXXXXX~YYYYYYYYYY" />
</application>

You will need to follow each ad network’s official setup instructions carefully because incorrect configuration can prevent ads from loading.

Initializing the SDK

Usually, you initialize the ad SDK once when the app starts, for example in a custom Application class or in the first activity.

This might look like:

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        // Initialize the ad SDK here
        // Example: AdsSdk.initialize(this)
    }
}

After initialization, you can start loading ad formats in your activities and fragments.

Loading and Showing Ads

Each ad format typically has two main steps. First you load an ad, which contacts the network and prepares an ad to be shown. Then you show it at the right time in your UI.

For example, a very simplified pseudocode for an interstitial ad might be:

class MainActivity : AppCompatActivity() {
    private var interstitialAd: InterstitialAd? = null
    private fun loadInterstitial() {
        // Request an interstitial ad from the SDK
        // SDK will call back when it is loaded or fails
    }
    private fun showInterstitialIfReady() {
        if (interstitialAd != null) {
            interstitialAd?.show()
        } else {
            // Ad not ready, continue app flow normally
        }
    }
}

The exact API and lifecycle methods will differ per SDK. What matters at this stage is that you understand the separation between loading and showing ads and the need to handle both success and failure gracefully.

User Experience and Ad Placement

Ads can easily ruin an app if used poorly. It is important to think about the user’s experience before choosing where and how often to show ads.

You should place ads where they are visible but not misleading or excessively disruptive. For example, a banner at the bottom of a list screen is usually acceptable. Showing an interstitial every few seconds is not.

For rewarded ads, make the reward clear before the user chooses to watch. For example, the button might say “Watch a short video to get 100 coins” so the user knows exactly what to expect.

You should avoid placing ads too close to important buttons or interactive elements, because accidental clicks can frustrate users and may be considered a policy violation by ad networks.

Basic Metrics and Revenue Concepts

Although you will not implement the metrics yourself in your app code, it is useful to know how ad performance is typically measured. Ad networks often use terms such as impressions, clicks, and revenue per thousand impressions.

An impression occurs when an ad is shown to the user. Clicks are when a user taps the ad. Revenue is usually calculated based on impressions or clicks, or sometimes both, depending on the ad campaign.

A common abbreviation is eCPM, which means effective cost per mille or cost per thousand impressions. The basic idea can be expressed as:

$$
\text{eCPM} = \frac{\text{Total revenue}}{\text{Total impressions}} \times 1000
$$

You will usually see these values in the ad network’s online dashboard, not in your app code. Understanding them helps you evaluate how effective your ad placements are.

Testing Ads During Development

Ad networks typically provide test ad units or special settings that show fake ads during development. This is very important to avoid accidentally clicking real ads while you build and debug your app.

During development, you use the test ad unit IDs and sometimes register your development device as a test device in the SDK configuration. When you are ready to publish, you switch to your real ad unit IDs provided by the network.

You should also test on multiple devices and configurations to verify that ads load correctly, do not hide important UI elements, and behave correctly on different screen sizes and orientations.

Common Pitfalls and Best Practices

Beginners often make similar mistakes when working with ads. Being aware of them early can save you time and prevent policy violations.

One common mistake is showing too many interstitial ads. This often leads to negative reviews and uninstalls. A more sustainable approach is to show them at natural breaks and not every time the user performs an action.

Another mistake is blocking the app’s flow if an ad fails to load. Your app should always function normally even if no ad is available. For example, if an interstitial is not ready, simply continue to the next screen without showing it.

You should also keep the ad SDK updated in your Gradle dependencies. Old versions might break, show lower performance, or fail policy checks.

Finally, always read and follow the ad network’s policies carefully. Violations such as encouraging users to click ads, modifying ad layouts in unsupported ways, or placing ads in notification areas can lead to your ad account being disabled.

Privacy and Compliance Considerations

Ads often involve user data, such as device identifiers or approximate location. Because of this, you may need to show consent dialogs or update your privacy policy, especially for users in certain regions or age groups.

On Android, modern privacy requirements also affect how ad SDKs behave with permissions and tracking features. Some ad networks provide tools to help handle consent and preferences.

You must make sure that any data collection done by ad SDKs is clearly explained in your app’s privacy policy. While advanced legal details are beyond this chapter, you should remember that integrating ads is not only a technical task but also a compliance responsibility.

When to Choose Ads as a Monetization Strategy

Ads can be a good choice when your app is free, used frequently, and does not have obvious digital goods to sell. For example, simple utilities, casual games, or content-based apps often rely on ads.

In some apps, you can combine ads with other monetization methods. For example, you might offer ads by default, but provide an in-app purchase to remove ads completely.

As you build more experience, you can experiment with the balance between user satisfaction and revenue. You may try different ad formats, positions, and frequencies while carefully measuring user engagement and reviews.

In this chapter you learned what ad formats exist, how they conceptually integrate into an Android app, and what to consider in terms of user experience and policies. Later, when you work on real projects, you will apply these ideas using a concrete ad SDK and follow its exact implementation steps.