App open ads

App open ads are a special ad format for monetizing your app load screens.

Note

Examples showing how all the format types work are available in the demo project.

Alert

This ad format only supports vertical orientation. When horizontal orientation is used, these ads aren't served.

Example of creating an app open ad

AppOpenActivity

class AppOpenAdActivity : AppCompatActivity() {

    private lateinit var binding: ActivityAppOpenAdBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityAppOpenAdBinding.inflate(layoutInflater)
        setContentView(binding.root)
    }
}

public class AppOpenAdActivity extends AppCompatActivity {

    private ActivityAppOpenAdBinding binding;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = ActivityAppOpenAdBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
    }
}

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/coordinatorLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".AppOpenAdActivity">

</androidx.constraintlayout.widget.ConstraintLayout>

AppOpenManager

AppOpenManager will monitor the app status:

class DefaultProcessLifecycleObserver(
    private val onProcessCameForeground: () -> Unit
) : DefaultLifecycleObserver {

    override fun onStart(owner: LifecycleOwner) {
        onProcessCameForeground()
    }
}

interface DefaultActivityLifecycleCallbacks : Application.ActivityLifecycleCallbacks {
    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
    override fun onActivityStarted(activity: Activity) = Unit
    override fun onActivityResumed(activity: Activity) = Unit
    override fun onActivityPaused(activity: Activity) = Unit
    override fun onActivityStopped(activity: Activity) = Unit
    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
    override fun onActivityDestroyed(activity: Activity) = Unit
}

class AppOpenAdManager(application: Application) : AppOpenAdLoadListener, AppOpenAdEventListener {
    private val context: Context = application

    private val processLifecycleObserver = DefaultProcessLifecycleObserver(
        onProcessCameForeground = ::showAppOpenAd
    )
    private val appOpenAdActivityObserver = AppOpenAdActivityObserver()
    private val AD_UNIT_ID = "demo-appopenad-yandex"
    private val appOpenAdLoader = AppOpenAdLoader(application)
    private val adRequestConfiguration = AdRequestConfiguration.Builder(AD_UNIT_ID).build()
    private var loadingInProgress = AtomicBoolean(false)
    private var activityReference: WeakReference<Activity>? = null
    private var appOpenAd: AppOpenAd? = null

    init {
        ProcessLifecycleOwner.get().lifecycle.addObserver(processLifecycleObserver)
        application.registerActivityLifecycleCallbacks(appOpenAdActivityObserver)
    }

    fun initialize() {
        appOpenAdLoader.setAdLoadListener(this)
        // load first Ad
        loadAppOpenAd()
    }

    override fun onAdLoaded(appOpenAd: AppOpenAd) {
        // save appOpenAd for future use
        this.appOpenAd = appOpenAd
        loadingInProgress.set(false)
        Toast.makeText(context, "AppOpenAd loaded", Toast.LENGTH_SHORT).show()
    }

    override fun onAdFailedToLoad(adRequestError: AdRequestError) {
        loadingInProgress.set(false)
        // use your own reload logic
        // NOTE: avoid continuous reloading when load errors occur
        Toast.makeText(context, "AppOpenAd failed to load", Toast.LENGTH_SHORT).show()
    }

    private fun showAppOpenAd() {
        // show AppOpenAd when Application comes foreground if there is opened specific Activity
        activityReference?.get()
            ?.let(::showAdIfAvailable)
    }

    private fun showAdIfAvailable(activity: Activity) {
        val appOpenAd = appOpenAd
        if (appOpenAd != null) {
            appOpenAd.setAdEventListener(this@AppOpenAdManager)
            appOpenAd.show(activity)
        } else {
            loadAppOpenAd()
        }
    }

    private fun loadAppOpenAd() {
        // load new Ad if there is no loaded Ad and new ad isn't loading
        if (loadingInProgress.compareAndSet(false, true)) {
            appOpenAdLoader.loadAd(adRequestConfiguration)
        }
    }

    private fun clearAppOpenAd() {
        appOpenAd?.setAdEventListener(null)
        appOpenAd = null
    }

    private inner class AppOpenAdActivityObserver : DefaultActivityLifecycleCallbacks {

        override fun onActivityStarted(activity: Activity) {
            // example of choosing specific Activity for show AppOpenAd
            activityReference = if (activity is AppOpenAdActivity) {
                WeakReference(activity)
            } else {
                null
            }
        }
    }
    override fun onAdClicked() {}
    override fun onAdDismissed() {
        clearAppOpenAd()
        loadAppOpenAd()
    }
    override fun onAdFailedToShow(adError: AdError) {}
    override fun onAdImpression(impressionData: ImpressionData?) {}
    override fun onAdShown() {}
}

class DefaultProcessLifecycleObserver implements DefaultLifecycleObserver {
    private final Runnable onProcessCameForeground;

    public DefaultProcessLifecycleObserver(Runnable onProcessCameForeground) {
        this.onProcessCameForeground = onProcessCameForeground;
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        onProcessCameForeground.run();
    }
}

interface DefaultActivityLifecycleCallbacks extends Application.ActivityLifecycleCallbacks {
    @Override default void onActivityCreated(Activity activity, Bundle savedInstanceState) {}
    @Override default void onActivityStarted(Activity activity) {}
    @Override default void onActivityResumed(Activity activity) {}
    @Override default void onActivityPaused(Activity activity) {}
    @Override default void onActivityStopped(Activity activity) {}
    @Override default void onActivitySaveInstanceState(Activity activity, Bundle outState) {}
    @Override default void onActivityDestroyed(Activity activity) {}
}

public class AppOpenAdManager implements AppOpenAdLoadListener, AppOpenAdEventListener {

    private final Context context;
    private final String AD_UNIT_ID = "demo-appopenad-yandex";
    private final AppOpenAdLoader appOpenAdLoader;
    private final AdRequestConfiguration adRequestConfiguration;
    private final AtomicBoolean loadingInProgress = new AtomicBoolean(false);
    private WeakReference<Activity> activityReference = null;
    private AppOpenAd appOpenAd = null;

    public AppOpenAdManager(Application application) {
        this.context = application;
        this.appOpenAdLoader = new AppOpenAdLoader(application);
        this.adRequestConfiguration = new AdRequestConfiguration.Builder(AD_UNIT_ID).build();

        // Observer for process lifecycle (foreground)
        DefaultProcessLifecycleObserver processLifecycleObserver =
                new DefaultProcessLifecycleObserver(new Runnable() {
                    @Override
                    public void run() {
                        showAppOpenAd();
                    }
                });
        ProcessLifecycleOwner.get().getLifecycle().addObserver(processLifecycleObserver);

        // Observer for activity lifecycle
        application.registerActivityLifecycleCallbacks(new AppOpenAdActivityObserver());
    }

    public void initialize() {
        appOpenAdLoader.setAdLoadListener(this);
        // load first Ad
        loadAppOpenAd();
    }

    @Override
    public void onAdLoaded(AppOpenAd appOpenAd) {
        this.appOpenAd = appOpenAd;
        loadingInProgress.set(false);
        Toast.makeText(context, "AppOpenAd loaded", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onAdFailedToLoad(AdRequestError adRequestError) {
        loadingInProgress.set(false);
        Toast.makeText(context, "AppOpenAd failed to load", Toast.LENGTH_SHORT).show();
    }

    private void showAppOpenAd() {
        Activity activity = (activityReference != null) ? activityReference.get() : null;
        if (activity != null) {
            showAdIfAvailable(activity);
        }
    }

    private void showAdIfAvailable(Activity activity) {
        if (appOpenAd != null) {
            appOpenAd.setAdEventListener(this);
            appOpenAd.show(activity);
        } else {
            loadAppOpenAd();
        }
    }

    private void loadAppOpenAd() {
        if (loadingInProgress.compareAndSet(false, true)) {
            appOpenAdLoader.loadAd(adRequestConfiguration);
        }
    }

    private void clearAppOpenAd() {
        if (appOpenAd != null) {
            appOpenAd.setAdEventListener(null);
            appOpenAd = null;
        }
    }

    private class AppOpenAdActivityObserver implements DefaultActivityLifecycleCallbacks {
        @Override
        public void onActivityStarted(Activity activity) {
            if (activity instanceof AppOpenAdActivity) {
                activityReference = new WeakReference<>(activity);
            } else {
                activityReference = null;
            }
        }
    }
    @Override
    public void onAdClicked() {}
    @Override
    public void onAdDismissed() {
        clearAppOpenAd();
        loadAppOpenAd();
    }
    @Override
    public void onAdFailedToShow(AdError adError) {}
    @Override
    public void onAdImpression(ImpressionData impressionData) {}
    @Override
    public void onAdShown() {}
}

In the root directory of your app, initialize the AppOpenAdManager entity:

class MyApplication: Application() {
    lateinit var appOpenAdManager: AppOpenAdManager
    private val initListener = InitializationListener({print("sdk listener initialized")})

    override fun onCreate() {
        super.onCreate()
        MobileAds.initialize(this, initListener)
        appOpenAdManager = AppOpenAdManager(this)
        appOpenAdManager.initialize()
    }
}

public class MyApplication extends Application {
    public AppOpenAdManager appOpenAdManager;

    private final InitializationListener initListener = new InitializationListener() {
        @Override
        public void onInitializationCompleted() {
            System.out.println("sdk listener initialized");
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        MobileAds.initialize(this, initListener);
        appOpenAdManager = new AppOpenAdManager(this);
        appOpenAdManager.initialize();
    }
}

Checking integration

Build and run your project. You can check if the integration is successful by searching the YandexAds keyword in Logcat:

[Integration] Ad type App Open was integrated successfully
Previous
Changelog
Next
Rewarded ads