The Day a Third Reason to Hide Ads Appeared — Folding Rork App Ad-Free Logic Into One Place

// lib/adFree/store.ts
import { create } from 'zustand';
import Purchases, { CustomerInfo } from 'react-native-purchases';
import type { AdFreeState, AdFreeReason } from './types';
import { saveRewardWindow } from './rewardWindow';
 
interface AdFreeStore extends AdFreeState {
  applyCustomerInfo: (info: CustomerInfo) => void;
  grantRewardWindow: (durationMs: number) => Promise<void>;
  reevaluate: () => void;
}
 
// RevenueCat entitlement identifiers (as defined in the dashboard)
const ENT_LIFETIME = 'lifetime_adfree';
const ENT_SUBSCRIPTION = 'pro';
 
function computeReason(
  hasLifetime: boolean,
  hasSubscription: boolean,
  rewardExpiresAt: number | null,
  now: number,
): { reason: AdFreeReason; rewardExpiresAt: number | null } {
  if (hasLifetime) return { reason: 'lifetime', rewardExpiresAt: null };
  if (hasSubscription) return { reason: 'subscription', rewardExpiresAt: null };
  if (rewardExpiresAt && rewardExpiresAt > now) {
    return { reason: 'reward', rewardExpiresAt };
  }
  return { reason: null, rewardExpiresAt: null };
}
 
export const useAdFreeStore = create<AdFreeStore>((set, get) => ({
  reason: null,
  rewardExpiresAt: null,
 
  applyCustomerInfo: (info) => {
    const active = info.entitlements.active;
    const hasLifetime = ENT_LIFETIME in active;
    const hasSubscription = ENT_SUBSCRIPTION in active;
    const { rewardExpiresAt } = get();
    set(computeReason(hasLifetime, hasSubscription, rewardExpiresAt, Date.now()));
  },
 
  grantRewardWindow: async (durationMs) => {
    const expiresAt = await saveRewardWindow(durationMs);
    const info = await Purchases.getCustomerInfo();
    const active = info.entitlements.active;
    set(computeReason(
      ENT_LIFETIME in active,
      ENT_SUBSCRIPTION in active,
      expiresAt,
      Date.now(),
    ));
  },
 
  reevaluate: () => {
    const { rewardExpiresAt, reason } = get();
    // lifetime / subscription do not change with time; only reward needs re-checking
    if (reason === 'reward') {
      set(computeReason(false, false, rewardExpiresAt, Date.now()));
    }
  },
}));

// in app/_layout.tsx or your init site
useEffect(() => {
  Purchases.getCustomerInfo().then(useAdFreeStore.getState().applyCustomerInfo);
  const sub = Purchases.addCustomerInfoUpdateListener(
    useAdFreeStore.getState().applyCustomerInfo,
  );
  return () => sub.remove();
}, []);

// lib/adFree/useRewardExpiryTimer.ts
import { useEffect } from 'react';
import { AppState } from 'react-native';
import { useAdFreeStore } from './store';
 
export function useRewardExpiryTimer() {
  const reason = useAdFreeStore((s) => s.reason);
  const expiresAt = useAdFreeStore((s) => s.rewardExpiresAt);
  const reevaluate = useAdFreeStore((s) => s.reevaluate);
 
  useEffect(() => {
    if (reason !== 'reward' || !expiresAt) return;
 
    const fire = () => reevaluate();
    const msUntilExpiry = expiresAt - Date.now();
    if (msUntilExpiry <= 0) {
      fire();
      return;
    }
    const timer = setTimeout(fire, msUntilExpiry);
 
    // setTimeout may be paused in the background, so re-check on resume
    const appSub = AppState.addEventListener('change', (state) => {
      if (state === 'active') reevaluate();
    });
 
    return () => {
      clearTimeout(timer);
      appSub.remove();
    };
  }, [reason, expiresAt, reevaluate]);
}

// lib/adFree/useAdFree.ts
import { useAdFreeStore } from './store';
 
export function useAdFree() {
  const reason = useAdFreeStore((s) => s.reason);
  const expiresAt = useAdFreeStore((s) => s.rewardExpiresAt);
  return {
    isAdFree: reason !== null,
    reason,
    rewardRemainingMs: reason === 'reward' && expiresAt ? expiresAt - Date.now() : 0,
  };
}

// components/AdSlot.tsx
import { BannerAd, BannerAdSize } from 'react-native-google-mobile-ads';
import { useAdFree } from '../lib/adFree/useAdFree';
 
export function AdSlot({ unitId }: { unitId: string }) {
  const { isAdFree } = useAdFree();
  if (isAdFree) return null; // any single reason to hide ads means no render
  return <BannerAd unitId={unitId} size={BannerAdSize.ADAPTIVE_BANNER} />;
}

// lib/adFree/rewardWindow.ts
import AsyncStorage from '@react-native-async-storage/async-storage';
 
const KEY = 'reward_window_v1';
 
interface Stored {
  expiresAt: number;   // unlock expiry (epoch ms)
  savedAt: number;     // save time (for rewind detection)
}
 
export async function saveRewardWindow(durationMs: number): Promise<number> {
  const now = Date.now();
  const expiresAt = now + durationMs;
  const payload: Stored = { expiresAt, savedAt: now };
  await AsyncStorage.setItem(KEY, JSON.stringify(payload));
  return expiresAt;
}
 
export async function loadRewardWindow(): Promise<number | null> {
  const raw = await AsyncStorage.getItem(KEY);
  if (!raw) return null;
  const { expiresAt, savedAt } = JSON.parse(raw) as Stored;
  const now = Date.now();
  // device time earlier than savedAt = likely rewound. Invalidate the unlock.
  if (now < savedAt) {
    await AsyncStorage.removeItem(KEY);
    return null;
  }
  if (expiresAt <= now) {
    await AsyncStorage.removeItem(KEY);
    return null;
  }
  return expiresAt;
}