The App Open Ad Antigravity Wrote for Me Fires Every Time I Return From My Own Paywall or Rewarded Video

// A single arbiter that owns the "reason" for a foreground return
object ForegroundArbiter {
    // Showing our own full-screen content (ad, purchase sheet, full-screen dialog)
    @Volatile var isShowingFullScreenContent = false
    // Intentionally moved to Custom Tabs or an external app (don't show on return)
    @Volatile var isEnteringInternalFlow = false
    // Process has not yet finished a single organic foregrounding
    @Volatile var isColdStart = true
 
    /** The one and only entry point deciding whether this return may show the ad */
    fun shouldShowAppOpenAd(): Boolean {
        if (isColdStart) return false
        if (isShowingFullScreenContent) return false
        if (isEnteringInternalFlow) return false
        return true
    }
 
    /** Call right before opening any full-screen ad or purchase sheet */
    fun beginFullScreenContent() { isShowingFullScreenContent = true }
    fun endFullScreenContent() { isShowingFullScreenContent = false }
 
    /** Call right before an external transition such as Custom Tabs */
    fun beginInternalFlow() { isEnteringInternalFlow = true }
    fun endInternalFlow() { isEnteringInternalFlow = false }
}

class AppOpenAdManager(private val app: Application) {
    private var appOpenAd: AppOpenAd? = null
    private var isLoading = false
    private var loadTimeMs = 0L
    private val adUnitId = "ca-app-pub-XXXXXXXX/XXXXXXXX" // replace with your real ad unit ID
 
    fun loadAd() {
        if (isLoading || isAdAvailable()) return
        isLoading = true
        val request = AdRequest.Builder().build()
        AppOpenAd.load(app, adUnitId, request,
            object : AppOpenAd.AppOpenAdLoadCallback() {
                override fun onAdLoaded(ad: AppOpenAd) {
                    appOpenAd = ad
                    isLoading = false
                    loadTimeMs = System.currentTimeMillis()
                }
                override fun onAdFailedToLoad(error: LoadAdError) {
                    isLoading = false // retry on the next opportunity
                }
            })
    }
 
    // Within the 4-hour validity window?
    private fun isAdAvailable(): Boolean {
        val fourHours = 4 * 60 * 60 * 1000L
        return appOpenAd != null &&
            (System.currentTimeMillis() - loadTimeMs) < fourHours
    }
 
    fun showAdIfAvailable(activity: Activity?) {
        // Delegate the display decision to the arbiter; the manager only checks readiness
        if (!ForegroundArbiter.shouldShowAppOpenAd()) { loadAd(); return }
        if (activity == null || !isAdAvailable()) { loadAd(); return }
 
        appOpenAd?.fullScreenContentCallback = object : FullScreenContentCallback() {
            override fun onAdShowedFullScreenContent() {
                // While we show full screen, don't re-show on the return
                ForegroundArbiter.beginFullScreenContent()
            }
            override fun onAdDismissedFullScreenContent() {
                ForegroundArbiter.endFullScreenContent()
                appOpenAd = null
                loadAd() // preload the next one
            }
            override fun onAdFailedToShowFullScreenContent(e: AdError) {
                ForegroundArbiter.endFullScreenContent()
                appOpenAd = null
                loadAd()
            }
        }
        appOpenAd?.show(activity)
    }
}

class MyApp : Application(), DefaultLifecycleObserver {
    private lateinit var appOpenAdManager: AppOpenAdManager
    private var currentActivity: Activity? = null
 
    override fun onCreate() {
        super<Application>.onCreate()
        MobileAds.initialize(this) {}
        appOpenAdManager = AppOpenAdManager(this)
        appOpenAdManager.loadAd()
        ProcessLifecycleOwner.get().lifecycle.addObserver(this)
 
        registerActivityLifecycleCallbacks(object : SimpleActivityLifecycleCallbacks() {
            override fun onActivityResumed(activity: Activity) { currentActivity = activity }
        })
    }
 
    override fun onStart(owner: LifecycleOwner) {
        if (ForegroundArbiter.isColdStart) {
            // Swallow the first foregrounding after launch (avoid colliding with the splash)
            ForegroundArbiter.isColdStart = false
            return
        }
        appOpenAdManager.showAdIfAvailable(currentActivity)
    }
}

@Test
fun rewarded_dismiss_does_not_show_app_open() {
    ForegroundArbiter.isColdStart = false
    ForegroundArbiter.beginFullScreenContent()      // rewarded video shown
    assertFalse(ForegroundArbiter.shouldShowAppOpenAd())
    ForegroundArbiter.endFullScreenContent()         // just dismissed
    assertTrue(ForegroundArbiter.shouldShowAppOpenAd())
}