Rork MaxでiOSとAndroidを同時展開して収益を倍にする — デュアルストア収益化の設計

// 課金状態と広告表示の連動
class AdManager {
    static let shared = AdManager()
    
    // 広告を表示すべきかどうか（課金状態に依存）
    var shouldShowAds: Bool {
        return !SubscriptionManager.shared.isPremium
    }
    
    func loadInterstitialIfNeeded() {
        guard shouldShowAds else {
            print("Premium user — skipping ad load")
            return
        }
        
        GADInterstitialAd.load(
            withAdUnitID: adUnitId,
            request: GADRequest()
        ) { [weak self] ad, error in
            self?.interstitialAd = ad
        }
    }
    
    func showInterstitialIfReady(from viewController: UIViewController) {
        guard shouldShowAds, let ad = interstitialAd else { return }
        ad.present(fromRootViewController: viewController)
        interstitialAd = nil
        loadInterstitialIfNeeded()  // 次の広告をプリロード
    }
}

// 広告ユニットIDの分岐（iOS ネイティブ側）
// Swift のコンパイル条件に os(Android) は存在しません。同じ struct の中で
// 同名の static let を二度宣言することもできないため、ここは DEBUG だけで分けます。
struct AdConfig {
    #if DEBUG
    // 開発中は Google 提供のテストIDを使います
    static let bannerAdUnitId = "ca-app-pub-3940256099942544/2934735716"
    static let interstitialAdUnitId = "ca-app-pub-3940256099942544/4411468910"
    #else
    static let bannerAdUnitId = "ca-app-pub-XXXX/YOUR_IOS_BANNER_ID"
    static let interstitialAdUnitId = "ca-app-pub-XXXX/YOUR_IOS_INTERSTITIAL_ID"
    #endif
}

// React Native / Expo 側で iOS と Android を分ける
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 が公開しているテストID（iOS と 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 {
    // すでに決定済みなら何もしない
    guard ATTrackingManager.trackingAuthorizationStatus == .notDetermined else {
        return
    }
    // システムダイアログを表示
    let status = await ATTrackingManager.requestTrackingAuthorization()
    switch status {
    case .authorized:
        // IDFAが利用可能。広告SDKへ渡す
        let idfa = ASIdentifierManager.shared().advertisingIdentifier
        AdManager.shared.configureTracking(idfa: idfa)
    default:
        // 非追跡モードでも広告自体は配信される（単価は下がる）
        AdManager.shared.configureNonPersonalized()
    }
}

# revenue_store.py — RevenueCat の Webhook を受けて月次集計の土台を作る
# 事前準備: RevenueCat のダッシュボードで Webhook の送信先にこのエンドポイントを登録します
import os
import sqlite3
from datetime import datetime
from flask import Flask, request, abort
 
DB = "revenue.sqlite3"
WEBHOOK_AUTH = os.environ["REVENUECAT_WEBHOOK_AUTH"]  # ダッシュボードで設定した Authorization ヘッダの値
 
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,  -- 再送に備えて冪等にする
                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               -- ストア手数料は引かれていない額
            )
        """)
 
 
@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  # 解約予告などは売上に足さない
 
    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:
    """ストア別の課金売上（USD）。返金と解約は別イベントとして差し引きます"""
    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:
    """課金（USD）と広告（円）を1つのレポートにまとめる"""
    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},
    }

# 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} 形式
    """
    creds = Credentials.from_authorized_user_file("admob_token.json")
    service = build("admob", "v1", credentials=creds)
 
    report_spec = {
        "dateRange": {"startDate": start, "endDate": end},
        "dimensions": ["PLATFORM"],          # 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 はマイクロ単位（1,000,000 で1通貨単位）で返る
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_ltv_by_platform(platform: str, data: dict) -> dict:
    """
    プラットフォーム別LTV計算
    
    data = {
        "monthly_arpu": 月次ARPU（円）,
        "monthly_churn_rate": 月次解約率（0〜1）,
        "ad_revenue_per_dau": 広告ユーザー一人あたりの月次収益
    }
    """
    arpu = data["monthly_arpu"]
    churn = data["monthly_churn_rate"]
    ad_rev = data.get("ad_revenue_per_dau", 0)
    
    # 課金ユーザーLTV
    subscription_ltv = arpu / churn if churn > 0 else arpu * 12
    
    # 広告ユーザーLTV（平均継続月数 × 月次広告収益）
    avg_retention_months = 1 / churn if churn > 0 else 12
    ad_ltv = ad_rev * avg_retention_months
    
    return {
        "platform": platform,
        "subscription_ltv_jpy": int(subscription_ltv),
        "ad_user_ltv_jpy": int(ad_ltv),
        "avg_retention_months": round(avg_retention_months, 1)
    }
 
# 入力例（自分のアプリの実測値に置き換えてください）
ios_ltv = calculate_ltv_by_platform("iOS", {
    "monthly_arpu": 1200,
    "monthly_churn_rate": 0.08,
    "ad_revenue_per_dau": 120
})
 
android_ltv = calculate_ltv_by_platform("Android", {
    "monthly_arpu": 880,
    "monthly_churn_rate": 0.11,
    "ad_revenue_per_dau": 160  # Androidは広告収益が高い
})
 
print(f"iOS: 課金LTV ¥{ios_ltv['subscription_ltv_jpy']:,} / 広告LTV ¥{ios_ltv['ad_user_ltv_jpy']:,}")
print(f"Android: 課金LTV ¥{android_ltv['subscription_ltv_jpy']:,} / 広告LTV ¥{android_ltv['ad_user_ltv_jpy']:,}")
 
# 出力例:
# iOS: 課金LTV ¥15,000 / 広告LTV ¥1,500
# Android: 課金LTV ¥8,000 / 広告LTV ¥1,454

// App Store審査で問題になるパターン（禁止）
// ❌ 外部サイトへの決済誘導
Button("ウェブサイトで購入する（お得）") {
    UIApplication.shared.open(URL(string: "https://yoursite.com/checkout")!)
}
 
// ✅ StoreKit経由での購入のみ
Button("Proにアップグレード") {
    Task { try await purchase(packageId: "pro_monthly") }
}