I’m having an issue with App Open Ads in my Android Kotlin application. The ad loads successfully but doesn’t show immediately on the first launch of the app. However, if I exit the app and reopen it, the ad displays without any problems.

Even though the ad is successfully loaded (Ad was loaded.), the showAdIfAvailable method logs Ad not ready or already showing. instead of displaying the ad. What could be causing this issue? How can I ensure the ad shows immediately after loading?

My Application Class:

@HiltAndroidApp
class KdvApplication : Application(), Application.ActivityLifecycleCallbacks, LifecycleObserver {

    private var currentActivity: Activity? = null
    private lateinit var appOpenAdManager: AppOpenAdManager

    override fun onCreate() {
        super.onCreate()
        MobileAds.initialize(this) {}
        registerActivityLifecycleCallbacks(this)
        ProcessLifecycleOwner.get().lifecycle.addObserver(this)
        appOpenAdManager = AppOpenAdManager(this)
    }

    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
        if (activity is MainActivity) {
            this.currentActivity = activity
        }
    }

    override fun onActivityStarted(activity: Activity) {
        if (!appOpenAdManager.isShowingAd && activity is MainActivity) {
            currentActivity = activity
        }
    }

    override fun onActivityResumed(activity: Activity) {}
    override fun onActivityPaused(activity: Activity) {}
    override fun onActivityStopped(activity: Activity) {}
    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
    override fun onActivityDestroyed(activity: Activity) {}

    @OnLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_START)
    fun onMoveToForeground() {
        currentActivity?.let {
            appOpenAdManager.showAdIfAvailable(it)
        }
    }

    inner class AppOpenAdManager(private val myApplication: KdvApplication) {

        private var appOpenAd: AppOpenAd? = null
        private var loadTime: Long = 0
        var isShowingAd = false
            private set

        private val isAdAvailable: Boolean
            get() = appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4)

        fun loadAd() {
            if (isAdAvailable) return

            val adRequest = AdRequest.Builder().build()
            AppOpenAd.load(
                myApplication,
                "ca-app-pub-3940256099942544/9257395921", //TEST ID, NOT PUBLIC
                adRequest,
                AppOpenAd.APP_OPEN_AD_ORIENTATION_PORTRAIT,
                object : AppOpenAd.AppOpenAdLoadCallback() {
                    override fun onAdLoaded(ad: AppOpenAd) {
                        appOpenAd = ad
                        loadTime = Date().time
                        Log.d("AppOpenAdManager", "Ad was loaded.")
                    }

                    override fun onAdFailedToLoad(loadAdError: LoadAdError) {
                        Log.d("AppOpenAdManager", loadAdError.message)
                    }
                }
            )
        }

        fun showAdIfAvailable(activity: Activity) {
            if (isShowingAd || !isAdAvailable) {
                Log.d("AppOpenAdManager", "Ad not ready or already showing.")
                loadAd()  // Load the next ad
                return
            }

            appOpenAd?.fullScreenContentCallback = object : FullScreenContentCallback() {
                override fun onAdDismissedFullScreenContent() {
                    appOpenAd = null
                    isShowingAd = false
                    Log.d("AppOpenAdManager", "Ad dismissed fullscreen content.")
                    loadAd()
                }

                override fun onAdFailedToShowFullScreenContent(adError: com.google.android.gms.ads.AdError) {
                    appOpenAd = null
                    isShowingAd = false
                    Log.d("AppOpenAdManager", adError.message)
                    loadAd()
                }

                override fun onAdShowedFullScreenContent() {
                    isShowingAd = true
                    Log.d("AppOpenAdManager", "Ad showed fullscreen content.")
                }
            }
            isShowingAd = true
            appOpenAd?.show(activity)
        }

        private fun wasLoadTimeLessThanNHoursAgo(numHours: Long): Boolean {
            val dateDifference = Date().time - loadTime
            val numMilliSecondsPerHour = 3600000L
            return dateDifference < numMilliSecondsPerHour * numHours
        }
    }
}

My Gradle:

dependencies {

    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.appcompat)
    implementation(libs.material)
    implementation(libs.androidx.activity)
    implementation(libs.androidx.constraintlayout)
    implementation(libs.androidx.lifecycle.process)
    testImplementation(libs.junit)
    androidTestImplementation(libs.androidx.junit)
    androidTestImplementation(libs.androidx.espresso.core)

    implementation("androidx.fragment:fragment-ktx:1.8.2")

    implementation("com.google.dagger:hilt-android:2.48")
    kapt("com.google.dagger:hilt-android-compiler:2.48")

    implementation("androidx.room:room-runtime:2.6.1")
    kapt("androidx.room:room-compiler:2.6.1")
    implementation("androidx.room:room-ktx:2.6.1")

    implementation("com.google.android.gms:play-services-ads:23.3.0")

    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.1")
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1")
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.6.1")
    kapt("androidx.lifecycle:lifecycle-compiler:2.6.1")
}