Running iOS and Android Simultaneously with Rork Max — A Dual-Store Revenue Strategy

class AdManager {
    static let shared = AdManager()
    
    private var interstitialAd: GADInterstitialAd?
    
    // The only rule: never show ads to premium users
    var shouldShowAds: Bool {
        return !AppState.shared.isPremium
    }
    
    func loadInterstitialIfNeeded() {
        guard shouldShowAds else { return }
        
        let request = GADRequest()
        GADInterstitialAd.load(
            withAdUnitID: adUnitId,
            request: request
        ) { [weak self] ad, error in
            if let error = error {
                print("Interstitial load failed: \(error.localizedDescription)")
                return
            }
            self?.interstitialAd = ad
        }
    }
    
    func showInterstitialIfReady(from viewController: UIViewController, completion: (() -> Void)? = nil) {
        guard shouldShowAds, let ad = interstitialAd else {
            completion?()
            return
        }
        
        ad.fullScreenContentDelegate = self
        ad.present(fromRootViewController: viewController)
        interstitialAd = nil
        loadInterstitialIfNeeded()  // Pre-load the next ad
    }
}
 
// Ad unit IDs on the iOS native side.
// Swift has no os(Android) compilation condition, so Android IDs cannot be
// selected here — see the React Native snippet below.
struct AdConfig {
    #if DEBUG
    // Always use test IDs in development
    static let interstitialId = "ca-app-pub-3940256099942544/4411468910"
    static let bannerId = "ca-app-pub-3940256099942544/2934735716"
    #else
    // Production IDs — separate for each platform
    #if os(iOS)
    static let interstitialId = "ca-app-pub-XXXX/YOUR_IOS_INTERSTITIAL_ID"
    static let bannerId = "ca-app-pub-XXXX/YOUR_IOS_BANNER_ID"
    #else  // Android (in React Native, check with Platform.OS)
    static let interstitialId = "ca-app-pub-XXXX/YOUR_ANDROID_INTERSTITIAL_ID"
    static let bannerId = "ca-app-pub-XXXX/YOUR_ANDROID_BANNER_ID"
    #endif
    #endif
}

import { Platform } from 'react-native';
 
const PROD_AD_UNITS = {
  ios: {
    banner: 'ca-app-pub-XXXX/YOUR_IOS_BANNER_ID',
    interstitial: 'ca-app-pub-XXXX/YOUR_IOS_INTERSTITIAL_ID',
  },
  android: {
    banner: 'ca-app-pub-XXXX/YOUR_ANDROID_BANNER_ID',
    interstitial: 'ca-app-pub-XXXX/YOUR_ANDROID_INTERSTITIAL_ID',
  },
} as const;
 
// Google's published test IDs — separate values for iOS and Android
const TEST_AD_UNITS = {
  ios: {
    banner: 'ca-app-pub-3940256099942544/2934735716',
    interstitial: 'ca-app-pub-3940256099942544/4411468910',
  },
  android: {
    banner: 'ca-app-pub-3940256099942544/6300978111',
    interstitial: 'ca-app-pub-3940256099942544/1033173712',
  },
} as const;
 
const platform = Platform.OS === 'android' ? 'android' : 'ios';
export const adUnits = __DEV__ ? TEST_AD_UNITS[platform] : PROD_AD_UNITS[platform];

import AppTrackingTransparency
import AdSupport
 
func requestTrackingIfNeeded() async {
    // Do nothing if the user already decided
    guard ATTrackingManager.trackingAuthorizationStatus == .notDetermined else {
        return
    }
    // Present the system dialog
    let status = await ATTrackingManager.requestTrackingAuthorization()
    switch status {
    case .authorized:
        // IDFA is available — hand it to the ad SDK
        let idfa = ASIdentifierManager.shared().advertisingIdentifier
        AdManager.shared.configureTracking(idfa: idfa)
    default:
        // Ads still serve in non-tracking mode (at lower CPM)
        AdManager.shared.configureNonPersonalized()
    }
}

# revenue_store.py — store RevenueCat webhook events, then aggregate by store
# Setup: register this endpoint as the webhook target in the RevenueCat dashboard
import os
import sqlite3
from datetime import datetime
from flask import Flask, request, abort
 
DB = "revenue.sqlite3"
WEBHOOK_AUTH = os.environ["REVENUECAT_WEBHOOK_AUTH"]  # the Authorization header you set in the dashboard
 
app = Flask(__name__)
 
 
def init_db() -> None:
    with sqlite3.connect(DB) as con:
        con.execute("""
            CREATE TABLE IF NOT EXISTS rc_event (
                event_id        TEXT PRIMARY KEY,  -- idempotent: webhooks get retried
                event_type      TEXT NOT NULL,
                store           TEXT NOT NULL,     -- APP_STORE / PLAY_STORE
                app_user_id     TEXT NOT NULL,
                product_id      TEXT,
                purchased_at_ms INTEGER,
                price_usd       REAL               -- what the customer paid, before store commission
            )
        """)
 
 
@app.post("/revenuecat/webhook")
def receive():
    if request.headers.get("Authorization") != WEBHOOK_AUTH:
        abort(401)
 
    event = request.get_json(force=True)["event"]
    if event["type"] not in ("INITIAL_PURCHASE", "RENEWAL", "NON_RENEWING_PURCHASE"):
        return "", 204  # cancellation notices are not revenue
 
    with sqlite3.connect(DB) as con:
        con.execute(
            "INSERT OR IGNORE INTO rc_event VALUES (?, ?, ?, ?, ?, ?, ?)",
            (
                event["id"],
                event["type"],
                event["store"],
                event["app_user_id"],
                event.get("product_id"),
                event.get("purchased_at_ms"),
                event.get("price"),
            ),
        )
    return "", 204
 
 
def monthly_subscription_usd(year: int, month: int) -> dict:
    """Subscription revenue by store, in USD. Refunds arrive as separate events."""
    start = int(datetime(year, month, 1).timestamp() * 1000)
    next_year = year + (1 if month == 12 else 0)
    next_month = 1 if month == 12 else month + 1
    end = int(datetime(next_year, next_month, 1).timestamp() * 1000)
 
    with sqlite3.connect(DB) as con:
        rows = con.execute(
            """
            SELECT store, COALESCE(SUM(price_usd), 0)
              FROM rc_event
             WHERE purchased_at_ms >= ? AND purchased_at_ms < ?
          GROUP BY store
            """,
            (start, end),
        ).fetchall()
 
    totals = {store: round(amount, 2) for store, amount in rows}
    return {
        "ios_subscription_usd": totals.get("APP_STORE", 0.0),
        "android_subscription_usd": totals.get("PLAY_STORE", 0.0),
    }
 
 
def build_monthly_report(year: int, month: int,
                         admob_ios_jpy: int, admob_android_jpy: int,
                         usd_jpy: float) -> dict:
    """Subscriptions (USD) and ads (JPY) in one report"""
    sub = monthly_subscription_usd(year, month)
    ios_sub_jpy = int(sub["ios_subscription_usd"] * usd_jpy)
    android_sub_jpy = int(sub["android_subscription_usd"] * usd_jpy)
    return {
        "period": f"{year}-{month:02d}",
        "ios": {"subscription": ios_sub_jpy, "admob": admob_ios_jpy,
                "total": ios_sub_jpy + admob_ios_jpy},
        "android": {"subscription": android_sub_jpy, "admob": admob_android_jpy,
                    "total": android_sub_jpy + admob_android_jpy},
    }

# Fetch monthly ad revenue split by platform via the AdMob Reporting API
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
 
def get_admob_revenue(account_id: str, start: dict, end: dict) -> dict:
    """
    account_id: "pub-XXXXXXXXXXXXXXXX"
    start / end: {"year": 2026, "month": 4, "day": 1} format
    """
    creds = Credentials.from_authorized_user_file("admob_token.json")
    service = build("admob", "v1", credentials=creds)
 
    report_spec = {
        "dateRange": {"startDate": start, "endDate": end},
        "dimensions": ["PLATFORM"],          # split by iOS / ANDROID
        "metrics": ["ESTIMATED_EARNINGS", "IMPRESSIONS"],
    }
 
    response = service.accounts().networkReport().generate(
        parent=f"accounts/{account_id}",
        body={"reportSpec": report_spec},
    ).execute()
 
    result = {"ios_micros": 0, "android_micros": 0}
    for row in response:
        r = row.get("row")
        if not r:
            continue
        platform = r["dimensionValues"]["PLATFORM"]["value"]
        earnings = int(r["metricValues"]["ESTIMATED_EARNINGS"]["microsValue"])
        if platform == "IOS":
            result["ios_micros"] += earnings
        elif platform == "ANDROID":
            result["android_micros"] += earnings
    return result
 
# ESTIMATED_EARNINGS is returned in micros (1,000,000 = 1 currency unit)
raw = get_admob_revenue(
    "pub-XXXXXXXXXXXXXXXX",
    {"year": 2026, "month": 4, "day": 1},
    {"year": 2026, "month": 4, "day": 30},
)
admob_ios_jpy = raw["ios_micros"] // 1_000_000
admob_android_jpy = raw["android_micros"] // 1_000_000
print(f"AdMob iOS: ¥{admob_ios_jpy:,} / Android: ¥{admob_android_jpy:,}")

def calculate_platform_ltv(platform: str, metrics: dict) -> dict:
    """
    Calculate LTV for each platform separately
    
    metrics = {
        "monthly_arpu":          Average revenue per paying user per month
        "monthly_churn_rate":    Fraction of subscribers canceling each month
        "ad_revenue_per_dau":    Monthly ad revenue per active user (non-subscriber)
        "trial_conversion_rate": Fraction of trial users who convert to paid
        "cpi":                   Cost per install (from your ad campaigns)
    }
    """
    arpu = metrics["monthly_arpu"]
    churn = metrics["monthly_churn_rate"]
    ad_rev = metrics.get("ad_revenue_per_dau", 0)
    conversion = metrics["trial_conversion_rate"]
    cpi = metrics["cpi"]
    
    # Subscriber LTV
    avg_retention_months = 1 / churn
    subscription_ltv = arpu * avg_retention_months
    
    # Ad user LTV (non-converting users)
    ad_user_ltv = ad_rev * avg_retention_months
    
    # Blended LTV (weighted by conversion rate)
    blended_ltv = (
        subscription_ltv * conversion +
        ad_user_ltv * (1 - conversion)
    )
    
    # ROI: every install costs CPI, generates blended_ltv
    roi_multiple = blended_ltv / cpi if cpi > 0 else float('inf')
    
    return {
        "platform": platform,
        "subscription_ltv_jpy": int(subscription_ltv),
        "ad_user_ltv_jpy": int(ad_user_ltv),
        "blended_ltv_jpy": int(blended_ltv),
        "avg_retention_months": round(avg_retention_months, 1),
        "roi_multiple": round(roi_multiple, 2)
    }
 
# Placeholder inputs — replace every one with your own measured values
ios_result = calculate_platform_ltv("iOS", {
    "monthly_arpu": 1200,
    "monthly_churn_rate": 0.08,
    "ad_revenue_per_dau": 120,
    "trial_conversion_rate": 0.09,
    "cpi": 800
})
 
android_result = calculate_platform_ltv("Android", {
    "monthly_arpu": 880,
    "monthly_churn_rate": 0.11,
    "ad_revenue_per_dau": 160,
    "trial_conversion_rate": 0.05,
    "cpi": 200   # Android CPI is typically much lower
})
 
for r in [ios_result, android_result]:
    print(f"{r['platform']}: Blended LTV ¥{r['blended_ltv_jpy']:,} / "
          f"ROI {r['roi_multiple']}x / "
          f"Avg retention {r['avg_retention_months']} months")
 
# Output for the placeholder inputs above:
# iOS:     Blended LTV ¥2,715 / ROI 3.39x / Avg retention 12.5 months
# Android: Blended LTV ¥1,781 / ROI 8.91x / Avg retention 9.1 months

// ❌ This gets apps rejected
Button("Buy on our website — better price!") {
    UIApplication.shared.open(URL(string: "https://yoursite.com/subscribe")!)
}
 
// ✅ StoreKit only
Button("Upgrade to Pro") {
    Task { try await PurchaseManager.shared.purchase(packageId: "pro_monthly") }
}

// Provide a cancel subscription link inside the app
func openManageSubscriptions() {
    #if os(iOS)
    // iOS: Opens Settings → Apple ID → Subscriptions
    UIApplication.shared.open(
        URL(string: "https://apps.apple.com/account/subscriptions")!
    )
    #else
    // Android: Opens Play Store subscription management
    // In React Native: Linking.openURL(...)
    let packageId = "your.android.package.id"
    UIApplication.shared.open(
        URL(string: "https://play.google.com/store/account/subscriptions?sku=pro_monthly&package=\(packageId)")!
    )
    #endif
}

// Proactive value delivery during trial
class TrialOnboardingManager {
    let userId: String
    
    func runDayThreeCheck() async {
        let completedCoreAction = await hasCompletedCoreAction(userId: userId)
        
        if !completedCoreAction {
            // User is 3 days in and hasn't used the main feature
            // Intervene before they lose interest
            await sendPushNotification(
                to: userId,
                title: "3 days in — have you tried \(CoreFeature.displayName)?",
                body: "Takes 2 minutes. Here's what it does: [specific value statement]",
                deepLink: "/core-feature/guided-tour"
            )
            
            await Analytics.log("trial_day3_intervention_sent", userId: userId)
        }
    }
    
    func runDayTwelveCheck() async {
        let subscriptionValue = await calculateValueDelivered(userId: userId)
        
        // Two days before trial ends — personalized value reminder
        await sendEmail(
            to: userId,
            subject: "Your trial ends in 2 days",
            template: "trial_ending",
            data: [
                "tasks_completed": subscriptionValue.tasksCompleted,
                "time_saved_minutes": subscriptionValue.timeSavedMinutes,
                "personal_highlight": subscriptionValue.topAction
            ]
        )
    }
}

// Android notification engagement tracking
// (In React Native, use firebase/messaging or expo-notifications)
 
struct NotificationEngagement {
    let userId: String
    
    func checkAndSendReEngagement() async {
        let daysSinceLastOpen = await getDaysSinceLastAppOpen(userId: userId)
        
        switch daysSinceLastOpen {
        case 3:
            await sendNotification(
                to: userId,
                title: "Quick check-in",
                body: "You have [X] things waiting in \(AppName.displayName)"
            )
        case 7:
            await sendNotification(
                to: userId,
                title: "Don't lose your streak",
                body: "Your [feature] data is still here. Pick up where you left off."
            )
        case 14:
            // Last attempt before treating as churned
            await sendNotification(
                to: userId,
                title: "Still there?",
                body: "We've kept your [data/work/progress] safe. Takes 30 seconds to check in."
            )
        case let days where days > 21:
            // Mark as at-risk, consider offering a discount on next renewal
            await flagForChurnIntervention(userId: userId)
        default:
            break
        }
    }
}

# price_increase_manager.py
 
NOTICE_DAYS = 60       # Minimum 60 days notice
LOYALTY_THRESHOLD = 6  # Months before qualifying for loyalty discount
 
def notify_price_increase(
    subscribers: list,
    old_price: int,
    new_price: int,
    effective_date: str
) -> dict:
    
    results = {"notified": 0, "loyalty_offered": 0, "errors": 0}
    
    for sub in subscribers:
        months_active = sub["months_subscribed"]
        
        try:
            if months_active >= LOYALTY_THRESHOLD:
                # Long-term subscribers get a lock-in offer
                lock_in_price = int(old_price * 1.05)  # 5% increase only
                send_loyalty_email(
                    email=sub["email"],
                    platform=sub["platform"],
                    old_price=old_price,
                    new_price=new_price,
                    lock_in_price=lock_in_price,
                    effective_date=effective_date
                )
                results["loyalty_offered"] += 1
            else:
                send_price_increase_email(
                    email=sub["email"],
                    platform=sub["platform"],
                    old_price=old_price,
                    new_price=new_price,
                    effective_date=effective_date
                )
            
            results["notified"] += 1
        except Exception as e:
            log_error(f"Price increase notification failed for {sub['email']}: {e}")
            results["errors"] += 1
    
    return results

def model_dual_store_economics(
    ios_subscribers: int,
    android_subscribers: int, 
    ios_dau: int,
    android_dau: int,
    ios_arpu: int = 1200,
    android_arpu: int = 880,
    ios_ad_per_dau: int = 120,
    android_ad_per_dau: int = 160
) -> dict:
    
    # Subscriber revenue
    ios_sub_rev = ios_subscribers * ios_arpu
    android_sub_rev = android_subscribers * android_arpu
    
    # Ad revenue (from non-subscribing active users)
    ios_ad_users = ios_dau - ios_subscribers
    android_ad_users = android_dau - android_subscribers
    ios_ad_rev = max(0, ios_ad_users) * ios_ad_per_dau
    android_ad_rev = max(0, android_ad_users) * android_ad_per_dau
    
    # Platform totals
    ios_total = ios_sub_rev + ios_ad_rev
    android_total = android_sub_rev + android_ad_rev
    grand_total = ios_total + android_total
    
    # Approximate costs (infrastructure + Apple/Google 30% cut already deducted from ARPU)
    server_cost = 20000 + (ios_dau + android_dau) * 2
    support_cost = (ios_subscribers + android_subscribers) * 300  # ¥300/sub/month
    
    net_revenue = grand_total - server_cost - support_cost
    
    return {
        "ios": {"subscribers": ios_subscribers, "subscription": ios_sub_rev, "ads": ios_ad_rev, "total": ios_total},
        "android": {"subscribers": android_subscribers, "subscription": android_sub_rev, "ads": android_ad_rev, "total": android_total},
        "grand_total_jpy": grand_total,
        "net_revenue_jpy": net_revenue,
        "margin_pct": round(net_revenue / grand_total * 100, 1) if grand_total > 0 else 0
    }
 
# Illustrative scenarios. Every input here is a placeholder, not my own revenue:
scenarios = [
    ("Early stage", 80, 60, 600, 1200),
    ("Growing",     200, 180, 1500, 3500),
    ("Established", 500, 450, 3000, 7500),
]
 
for name, ios_subs, and_subs, ios_dau, and_dau in scenarios:
    e = model_dual_store_economics(ios_subs, and_subs, ios_dau, and_dau)
    print(f"{name}: ¥{e['grand_total_jpy']:,}/month → Net ¥{e['net_revenue_jpy']:,} ({e['margin_pct']}% margin)")
 
# Output for the placeholder inputs above:
# Early stage: ¥393,600/month → Net ¥328,000 (83.3% margin)
# Growing:     ¥1,085,600/month → Net ¥941,600 (86.7% margin)
# Established: ¥2,424,000/month → Net ¥2,098,000 (86.5% margin)