Users Told Me They Could Not Close a Fullscreen Ad. The Entry Points Were Scattered, So I Put the Show-or-Not Check and a Safety Net in One Place

// clock.ts — a clock you advance by hand: no real waiting, and timer order is preserved
type Task = { at: number; fn: () => void; every?: number; cancelled: boolean };
 
export class FakeClock {
  now = 0;
  private tasks: Task[] = [];
 
  after(ms: number, fn: () => void): () => void {
    const t: Task = { at: this.now + ms, fn, cancelled: false };
    this.tasks.push(t);
    return () => void (t.cancelled = true);
  }
  every(ms: number, fn: () => void): () => void {
    const t: Task = { at: this.now + ms, fn, every: ms, cancelled: false };
    this.tasks.push(t);
    return () => void (t.cancelled = true);
  }
  advanceTo(target: number): void {
    for (;;) {
      const due = this.tasks
        .filter((t) => !t.cancelled && t.at <= target)
        .sort((a, b) => a.at - b.at)[0];
      if (!due) break;
      this.now = due.at;
      if (due.every) due.at += due.every;
      else due.cancelled = true;
      due.fn();
    }
    this.now = target;
  }
}

// fake-sdk.ts — a stand-in for the interstitial SDK. It reproduces only the conditions that were present
// (It does not model SDK internals. 'The close button cannot be reached' is expressed as 'closed never arrives'.)
import type { FakeClock } from "./clock.ts";
 
export interface Env {
  active: boolean;     // is the app in the foreground?
  dialogOpen: boolean; // is an OS prompt such as a permission dialog on screen?
}
 
export class FakeInterstitial {
  visible = false;
  closable = false;
  shownCount = 0;
  closedNormally = 0;
  healthyCuts = 0;      // times the app cut off an ad that was still closable
  maxConcurrent = 0;
  onClosed: () => void = () => {};
  /** when true, closed is never delivered regardless of conditions (a dropped notification) */
  loseClose = false;
  private concurrent = 0;
  private viewed = 0;
  private env: Env;
  private viewMs: number;
 
  constructor(clock: FakeClock, env: Env, viewMs = 20_000) {
    this.env = env;
    this.viewMs = viewMs;
    // viewing time only advances while the app is in the foreground (video assumed paused)
    clock.every(1_000, () => {
      if (!this.visible || !this.closable || !this.env.active) return;
      this.viewed += 1_000;
      if (this.viewed >= this.viewMs) this.finish(true);
    });
  }
 
  show(): void {
    this.visible = true;
    this.viewed = 0;
    this.shownCount += 1;
    this.concurrent += 1;
    this.maxConcurrent = Math.max(this.maxConcurrent, this.concurrent);
    // an ad shown while backgrounded, or while a prompt is on screen, cannot be closed
    this.closable = this.env.active && !this.env.dialogOpen && !this.loseClose;
  }
 
  private finish(byUser: boolean): void {
    if (!this.visible) return;
    if (byUser) this.closedNormally += 1;
    this.visible = false;
    this.closable = false;
    this.concurrent = Math.max(0, this.concurrent - 1);
    if (byUser) this.onClosed(); // with loseClose we never get here in the first place
  }
 
  /** the app closes it by force (the safety net). No notification is sent back */
  dismiss(): void {
    if (this.closable) this.healthyCuts += 1;
    this.finish(false);
  }
}

// gate.ts — the single entry point for showing an interstitial
import type { Env } from "./fake-sdk.ts";
 
// On a device this is setInterval. Only the needed shape is extracted so a fake clock can be injected
export interface Ticker {
  every(ms: number, fn: () => void): () => void;
}
// The shape an ad SDK is plugged in as. Give dismiss a body only if you have a way to force-close
export interface AdLike {
  show(): void;
  dismiss(): void;
  onClosed: () => void;
}
 
export type Reason = "shown" | "background" | "system-dialog" | "already-showing";
export type WatchdogMode = "none" | "wall" | "foreground";
export interface Policy {
  checkEnv: boolean;        // check foreground state and whether a prompt is showing
  watchdog: WatchdogMode;   // how the safety net counts time when no close arrives
}
export const WATCHDOG_MS = 45_000;
const TICK_MS = 1_000;
 
export class AdGate {
  private showing = false;
  private elapsed = 0;
  forceReleased = 0;
  history: Reason[] = [];
 
  private env: Env;
  private ad: AdLike;
  private policy: Policy;
 
  constructor(clock: Ticker, env: Env, ad: AdLike, policy: Policy) {
    this.env = env;
    this.ad = ad;
    this.policy = policy;
    ad.onClosed = () => this.release();
    clock.every(TICK_MS, () => this.tick());
  }
 
  /** decide whether this is a moment to show an ad; if so, show it. Returns why it did not */
  request(): Reason {
    const r = this.decide();
    this.history.push(r);
    return r;
  }
 
  private decide(): Reason {
    if (this.policy.checkEnv) {
      if (!this.env.active) return "background";
      if (this.env.dialogOpen) return "system-dialog";
    }
    if (this.showing) return "already-showing";
    this.showing = true;
    this.elapsed = 0;
    this.ad.show();
    return "shown";
  }
 
  private release(): void {
    this.showing = false;
  }
 
  private tick(): void {
    if (!this.showing || this.policy.watchdog === "none") return;
    // wall: count real time / foreground: count only while the app is in the foreground
    if (this.policy.watchdog === "foreground" && !this.env.active) return;
    this.elapsed += TICK_MS;
    if (this.elapsed >= WATCHDOG_MS) {
      this.forceReleased += 1;
      this.ad.dismiss(); // close the ad whose closed never came, and release the entry lock
      this.release();
    }
  }
}

// scenarios.ts — run the same sequence of events through three entry-point designs
import { FakeClock } from "./clock.ts";
import { FakeInterstitial, type Env } from "./fake-sdk.ts";
import { AdGate, type Policy, type Reason } from "./gate.ts";
 
const POLICIES: Record<string, Policy> = {
  "lock only (original)": { checkEnv: false, watchdog: "none" },
  "checks + wall-clock net": { checkEnv: true, watchdog: "wall" },
  "checks + foreground net": { checkEnv: true, watchdog: "foreground" },
};
 
interface Result {
  trapped: boolean;      // at 240 s, is an ad that cannot be closed still on screen?
  healthyCuts: number;   // times the safety net cut off a healthy ad
  closedNormally: number;
  firstRequest: Reason;  // result of the first request
  forceReleased: number; // times the safety net fired
  lastRequest: Reason;   // result of a request at 250 s (environment back to normal)
}
 
type Script = (c: FakeClock, env: Env, ad: FakeInterstitial, gate: AdGate) => void;
 
function run(script: Script, policy: Policy): Result {
  const clock = new FakeClock();
  const env: Env = { active: true, dialogOpen: false };
  const ad = new FakeInterstitial(clock, env);
  const gate = new AdGate(clock, env, ad, policy);
  script(clock, env, ad, gate);
  clock.advanceTo(240_000);
  const trapped = ad.visible && !ad.closable;
  clock.advanceTo(250_000);
  const lastRequest = gate.request();
  clock.advanceTo(300_000);
  return { firstRequest: gate.history[0], forceReleased: gate.forceReleased, trapped, healthyCuts: ad.healthyCuts, closedNormally: ad.closedNormally, lastRequest };
}
 
const scenarios: Record<string, Script> = {
  // A: a save-complete ad is requested while the photo permission dialog is up
  "A during permission dialog": (c, env, _ad, gate) => {
    env.dialogOpen = true;
    c.after(500, () => void gate.request());
    c.after(2_000, () => (env.dialogOpen = false));
  },
  // B: a download finishes while the app is in the background, and an ad is requested
  "B app in background": (c, env, _ad, gate) => {
    env.active = false;
    c.after(1_000, () => void gate.request());
    c.after(20_000, () => (env.active = true));
  },
  // C: the ad showed normally, but the closed notification was dropped
  "C dropped notification": (c, _env, ad, gate) => {
    ad.loseClose = true;
    c.after(0, () => void gate.request());
  },
  // D: the app goes to the background for two minutes mid-ad, then a request arrives on return
  "D backgrounded mid-ad": (c, env, _ad, gate) => {
    c.after(0, () => void gate.request());
    c.after(10_000, () => (env.active = false));
    c.after(130_000, () => {
      env.active = true;
      gate.request();
    });
  },
};
 
export function runAll(): void {
  for (const [sname, script] of Object.entries(scenarios)) {
    console.log(`\n== ${sname}`);
    for (const [pname, policy] of Object.entries(POLICIES)) {
      const r = run(script, policy);
      console.log(
        `${pname.padEnd(16)} first=${r.firstRequest.padEnd(15)} net-fired=${r.forceReleased} stuck=${String(r.trapped).padEnd(5)} healthy-cuts=${r.healthyCuts} closed-ok=${r.closedNormally} req@250s=${r.lastRequest}`,
      );
    }
  }
}
runAll();

// ad-entry.ts — wiring for a real device (untested; check on a device)
import { AppState } from "react-native";
import { InterstitialAd, AdEventType } from "react-native-google-mobile-ads";
import { AdGate } from "./gate";
 
const env = { active: AppState.currentState === "active", dialogOpen: false };
AppState.addEventListener("change", (s) => (env.active = s === "active"));
 
const interstitial = InterstitialAd.createForAdRequest("<unit id>");
const adLike = {
  onClosed: () => {},
  show: () => interstitial.show(),
  // If your version has no API to close the ad by force, leave this empty.
  // The safety net then goes only as far as releasing the lock.
  dismiss: () => {},
};
interstitial.addAdEventListener(AdEventType.CLOSED, () => adLike.onClosed());
interstitial.addAdEventListener(AdEventType.ERROR, () => adLike.onClosed());
 
const realTicker = {
  every: (ms: number, fn: () => void) => {
    const id = setInterval(fn, ms);
    return () => clearInterval(id);
  },
};
export const gate = new AdGate(realTicker, env, adLike, {
  checkEnv: true,
  watchdog: "foreground",
});
 
// Wrap any action that shows a permission dialog with these two
export async function withSystemDialog<T>(run: () => Promise<T>): Promise<T> {
  env.dialogOpen = true;
  try {
    return await run();
  } finally {
    env.dialogOpen = false;
  }
}

grep -rnE "\.show\(\)|showAd|presentAd|interstitial" app src --include="*.ts" --include="*.tsx" | wc -l