Antigravity × App Clip・WidgetKit・Live Activities 収益化ファネル設計ガイド

# Project: MonetizationFunnel
 
## Architecture Overview
Three-stage iOS monetization funnel:
1. App Clip → cold user acquisition
2. Widget → engagement & upsell signals
3. Live Activity → time-sensitive conversion
 
## Key Constraints
- App Clip bundle size: < 15MB (hard limit)
- Widget timeline: refresh every 15-60 min
- Live Activity: use ActivityKit + Push to Start
 
## Monetization Stack
- StoreKit 2 for IAP
- RevenueCat for subscription management
- Firebase Analytics for funnel tracking
 
## Code Style
- SwiftUI only (no UIKit)
- Swift Concurrency (async/await)
- MVVM + Repository pattern

// SharedKit/Extensions/AppGroup.swift
 
import Foundation
 
public enum AppGroup {
    // App Group ID は Xcode の Signing & Capabilities で設定
    public static let identifier = "group.com.example.myapp"
    
    // UserDefaults を App Group 経由で共有
    public static var defaults: UserDefaults {
        UserDefaults(suiteName: identifier) ?? .standard
    }
    
    // 共有するキー定義
    public enum Keys {
        public static let userPremiumStatus = "userPremiumStatus"
        public static let lastActiveContent = "lastActiveContent"
        public static let conversionStage = "conversionStage"  // funnel tracking
        public static let widgetRefreshDate = "widgetRefreshDate"
    }
}
 
// 購入状態を共有する型
public enum PurchaseState: String, Codable {
    case none        // 未購入
    case trial       // トライアル中
    case active      // 有料会員
    case expired     // 期限切れ
}

// AppClip/AppClipApp.swift
 
import SwiftUI
import SharedKit
 
@main
struct AppClipApp: App {
    @StateObject private var store = AppClipStore()
    
    var body: some Scene {
        WindowGroup {
            AppClipRootView()
                .environmentObject(store)
                .onContinueUserActivity(NSUserActivityTypes.appClipActivity) { activity in
                    store.handleActivity(activity)
                }
        }
    }
}
 
// App Clip の状態管理
@MainActor
class AppClipStore: ObservableObject {
    @Published var contentID: String?
    @Published var showUpgradePrompt = false
    @Published var analyticsStage: FunnelStage = .appClipView
    
    func handleActivity(_ activity: NSUserActivity) {
        // QRコード・NFCから受け取ったURLを解析
        guard let url = activity.webpageURL else { return }
        parseInvocationURL(url)
        trackFunnelEvent(.appClipOpened)
    }
    
    private func parseInvocationURL(_ url: URL) {
        // URL パターン: https://example.com/clip?content=<id>
        let components = URLComponents(url: url, resolvingAgainstBaseURL: true)
        contentID = components?.queryItems?.first(where: { $0.name == "content" })?.value
    }
    
    func trackFunnelEvent(_ stage: FunnelStage) {
        AnalyticsService.shared.logEvent(
            "funnel_stage",
            parameters: ["stage": stage.rawValue, "source": "app_clip"]
        )
    }
}

// AppClip/Views/AppClipRootView.swift
 
import SwiftUI
import SharedKit
 
struct AppClipRootView: View {
    @EnvironmentObject var store: AppClipStore
    @State private var showContent = false
    
    var body: some View {
        NavigationStack {
            ZStack {
                // ステップ1: コンテンツ体験（価値の提示）
                if let contentID = store.contentID {
                    ContentPreviewView(contentID: contentID)
                        .transition(.opacity)
                } else {
                    DefaultClipLandingView()
                }
                
                // ステップ2: フルアプリへの誘導バナー
                VStack {
                    Spacer()
                    AppClipUpgradeBanner(
                        onGetFullApp: {
                            store.trackFunnelEvent(.upgradePromptTapped)
                            openFullApp()
                        }
                    )
                    .padding(.bottom, 20)
                }
            }
        }
        .onAppear {
            store.trackFunnelEvent(.appClipView)
        }
    }
    
    // App Store Connect でのフルアプリ遷移
    private func openFullApp() {
        guard let url = URL(string: "https://apps.apple.com/app/id\(AppConstants.appStoreID)") else { return }
        UIApplication.shared.open(url)
    }
}
 
// コンバージョンを促すバナーコンポーネント
struct AppClipUpgradeBanner: View {
    let onGetFullApp: () -> Void
    
    var body: some View {
        VStack(spacing: 12) {
            Text("フル機能を無料で試す")
                .font(.headline)
            Text("App Clipでは一部の機能のみご利用いただけます")
                .font(.caption)
                .foregroundStyle(.secondary)
            
            Button("フルアプリをダウンロード", action: onGetFullApp)
                .buttonStyle(.borderedProminent)
                .controlSize(.large)
        }
        .padding(20)
        .background(.regularMaterial)
        .clipShape(RoundedRectangle(cornerRadius: 16))
        .shadow(radius: 8)
    }
}

// WidgetExtension/Widget.swift
 
import WidgetKit
import SwiftUI
import SharedKit
 
// タイムラインエントリー
struct MonetizationWidgetEntry: TimelineEntry {
    let date: Date
    let content: ContentItem
    let userState: PurchaseState
    let showUpgradePrompt: Bool  // ファネルのステージに応じてCTAを表示
}
 
// タイムラインプロバイダー
struct MonetizationWidgetProvider: TimelineProvider {
    func placeholder(in context: Context) -> MonetizationWidgetEntry {
        .placeholder
    }
    
    func getSnapshot(in context: Context, completion: @escaping (MonetizationWidgetEntry) -> Void) {
        completion(makeEntry(isSnapshot: true))
    }
    
    func getTimeline(in context: Context, completion: @escaping (Timeline<MonetizationWidgetEntry>) -> Void) {
        Task {
            // App Group から最新の状態を読み込む
            let userState = loadUserState()
            let content = await fetchLatestContent()
            
            // アップグレードプロンプトの表示判定
            // 未課金ユーザーには3回に1回プロンプトを表示
            let showUpgrade = userState == .none && shouldShowUpgradePrompt()
            
            let entry = MonetizationWidgetEntry(
                date: .now,
                content: content,
                userState: userState,
                showUpgradePrompt: showUpgrade
            )
            
            // 次の更新は30分後
            let nextUpdate = Calendar.current.date(byAdding: .minute, value: 30, to: .now) ?? .now
            completion(Timeline(entries: [entry], policy: .after(nextUpdate)))
        }
    }
    
    private func loadUserState() -> PurchaseState {
        let raw = AppGroup.defaults.string(forKey: AppGroup.Keys.userPremiumStatus) ?? ""
        return PurchaseState(rawValue: raw) ?? .none
    }
    
    private func shouldShowUpgradePrompt() -> Bool {
        // 表示回数を管理して UX を損なわないようにする
        let count = AppGroup.defaults.integer(forKey: "widgetUpgradeShowCount")
        AppGroup.defaults.set(count + 1, forKey: "widgetUpgradeShowCount")
        return count % 3 == 0  // 3回に1回表示
    }
}
 
// ウィジェットビュー
struct MonetizationWidgetView: View {
    let entry: MonetizationWidgetEntry
    @Environment(\.widgetFamily) var family
    
    var body: some View {
        switch family {
        case .systemSmall: SmallWidgetView(entry: entry)
        case .systemMedium: MediumWidgetView(entry: entry)
        case .systemLarge: LargeWidgetView(entry: entry)
        default: SmallWidgetView(entry: entry)
        }
    }
}
 
// Medium サイズ: コンテンツ + アップグレードCTA
struct MediumWidgetView: View {
    let entry: MonetizationWidgetEntry
    
    var body: some View {
        HStack(spacing: 12) {
            // コンテンツプレビュー
            ContentThumbnailView(item: entry.content)
                .frame(width: 80)
            
            VStack(alignment: .leading, spacing: 6) {
                Text(entry.content.title)
                    .font(.headline)
                    .lineLimit(2)
                
                if entry.showUpgradePrompt && entry.userState == .none {
                    // アップグレードCTA（ディープリンクで課金画面へ）
                    Link(destination: URL(string: "myapp://upgrade?source=widget")!) {
                        Label("プレミアムを試す", systemImage: "star.fill")
                            .font(.caption)
                            .foregroundStyle(.yellow)
                            .padding(.horizontal, 10)
                            .padding(.vertical, 5)
                            .background(.yellow.opacity(0.2))
                            .clipShape(Capsule())
                    }
                } else {
                    // 通常: コンテンツへのリンク
                    Link(destination: URL(string: "myapp://content/\(entry.content.id)")!) {
                        Text("続きを見る →")
                            .font(.caption)
                            .foregroundStyle(.blue)
                    }
                }
            }
        }
        .padding()
        .containerBackground(.regularMaterial, for: .widget)
    }
}

// MainApp/AppDelegate.swift または Scene設定
 
// URL スキームのハンドリング
.onOpenURL { url in
    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else { return }
    
    switch components.host {
    case "upgrade":
        let source = components.queryItems?.first(where: { $0.name == "source" })?.value ?? "unknown"
        AnalyticsService.shared.logEvent("upgrade_intent", parameters: [
            "source": source,
            "funnel_stage": "widget_cta"
        ])
        // RevenueCat のペイウォールを表示
        showPaywall(source: source)
        
    case "content":
        let contentID = components.path.dropFirst()  // "/content_id" → "content_id"
        navigateToContent(String(contentID))
        
    default: break
    }
}

// SharedKit/Models/LiveActivityState.swift
 
import ActivityKit
import SwiftUI
 
// Live Activity の状態型（ActivityAttributes を継承）
public struct SaleActivityAttributes: ActivityAttributes {
    
    // 変更されない静的データ
    public struct ContentState: Codable, Hashable {
        var remainingSeconds: Int  // カウントダウン
        var currentPrice: String   // "¥4,980" など
        var discountRate: Int      // 割引率（%）
        var isPurchased: Bool      // 購入完了フラグ
    }
    
    // Activity 初期化時に設定する固定データ
    public var saleName: String      // "春の特別セール"
    public var originalPrice: String // "¥9,800"
    public var deepLinkURL: String   // 課金画面のURLスキーム
    
    public init(saleName: String, originalPrice: String, deepLinkURL: String) {
        self.saleName = saleName
        self.originalPrice = originalPrice
        self.deepLinkURL = deepLinkURL
    }
}
 
// Live Activity を管理するサービス
public class LiveActivityService: ObservableObject {
    private var currentActivity: Activity<SaleActivityAttributes>?
    
    // セール開始時に Live Activity を起動
    public func startSaleActivity(saleName: String, durationSeconds: Int, discountRate: Int, originalPrice: String, salePrice: String) async {
        guard ActivityAuthorizationInfo().areActivitiesEnabled else {
            print("Live Activities が無効です")
            return
        }
        
        let attributes = SaleActivityAttributes(
            saleName: saleName,
            originalPrice: originalPrice,
            deepLinkURL: "myapp://upgrade?source=live_activity&sale=\(saleName)"
        )
        
        let initialState = SaleActivityAttributes.ContentState(
            remainingSeconds: durationSeconds,
            currentPrice: salePrice,
            discountRate: discountRate,
            isPurchased: false
        )
        
        do {
            let activity = try Activity.request(
                attributes: attributes,
                content: .init(state: initialState, staleDate: Date().addingTimeInterval(Double(durationSeconds)))
            )
            currentActivity = activity
            
            // カウントダウンを開始
            startCountdown(activityID: activity.id, durationSeconds: durationSeconds)
            
        } catch {
            print("Live Activity 起動失敗: \(error)")
        }
    }
    
    // 毎秒カウントダウンを更新
    private func startCountdown(activityID: String, durationSeconds: Int) {
        Task {
            for remaining in stride(from: durationSeconds, through: 0, by: -1) {
                guard let activity = currentActivity else { break }
                
                let updatedState = SaleActivityAttributes.ContentState(
                    remainingSeconds: remaining,
                    currentPrice: activity.content.state.currentPrice,
                    discountRate: activity.content.state.discountRate,
                    isPurchased: false
                )
                
                await activity.update(
                    ActivityContent(state: updatedState, staleDate: nil)
                )
                
                if remaining > 0 {
                    try? await Task.sleep(nanoseconds: 1_000_000_000)
                }
            }
            
            // タイムアップ時に Activity を終了
            await endActivity(purchased: false)
        }
    }
    
    // 購入完了時のActivity終了
    public func endActivity(purchased: Bool) async {
        guard let activity = currentActivity else { return }
        
        let finalState = SaleActivityAttributes.ContentState(
            remainingSeconds: 0,
            currentPrice: activity.content.state.currentPrice,
            discountRate: activity.content.state.discountRate,
            isPurchased: purchased
        )
        
        await activity.end(
            ActivityContent(state: finalState, staleDate: nil),
            dismissalPolicy: .after(.now.addingTimeInterval(10))
        )
        
        currentActivity = nil
    }
}

// LiveActivityExtension/LiveActivityViews.swift
 
import SwiftUI
import ActivityKit
import WidgetKit
 
struct SaleActivityWidget: Widget {
    var body: some WidgetConfiguration {
        ActivityConfiguration(for: SaleActivityAttributes.self) { context in
            // ロック画面 / 通知センター の表示
            LockScreenView(context: context)
        } dynamicIsland: { context in
            // Dynamic Island の表示
            DynamicIsland {
                // Expanded view（長押し展開時）
                DynamicIslandExpandedRegion(.leading) {
                    SaleTimerView(seconds: context.state.remainingSeconds)
                }
                DynamicIslandExpandedRegion(.trailing) {
                    DiscountBadge(rate: context.state.discountRate)
                }
                DynamicIslandExpandedRegion(.bottom) {
                    Link(destination: URL(string: context.attributes.deepLinkURL)!) {
                        Label("今すぐ購入 \(context.state.currentPrice)", systemImage: "cart.fill")
                            .font(.callout.bold())
                            .foregroundStyle(.white)
                            .frame(maxWidth: .infinity)
                            .padding(.vertical, 8)
                            .background(.blue.gradient)
                            .clipShape(RoundedRectangle(cornerRadius: 12))
                    }
                }
            } compactLeading: {
                // コンパクト表示（左）: タイマー
                Image(systemName: "timer")
                    .foregroundStyle(.orange)
            } compactTrailing: {
                // コンパクト表示（右）: 残り時間
                Text(formatTime(context.state.remainingSeconds))
                    .font(.caption.monospacedDigit())
                    .foregroundStyle(.orange)
            } minimal: {
                // 最小表示
                Image(systemName: "percent")
                    .foregroundStyle(.orange)
            }
        }
    }
    
    private func formatTime(_ seconds: Int) -> String {
        let m = seconds / 60
        let s = seconds % 60
        return String(format: "%02d:%02d", m, s)
    }
}
 
// ロック画面ビュー
struct LockScreenView: View {
    let context: ActivityViewContext<SaleActivityAttributes>
    
    var body: some View {
        HStack(spacing: 16) {
            // 割引バッジ
            VStack {
                Text("\(context.state.discountRate)%")
                    .font(.title.bold())
                    .foregroundStyle(.orange)
                Text("OFF")
                    .font(.caption)
                    .foregroundStyle(.orange)
            }
            .frame(width: 60, height: 60)
            .background(.orange.opacity(0.15))
            .clipShape(Circle())
            
            VStack(alignment: .leading, spacing: 4) {
                Text(context.attributes.saleName)
                    .font(.headline)
                HStack {
                    Text(context.attributes.originalPrice)
                        .strikethrough()
                        .foregroundStyle(.secondary)
                    Text("→ \(context.state.currentPrice)")
                        .foregroundStyle(.primary)
                        .bold()
                }
                .font(.subheadline)
                
                // カウントダウン
                SaleTimerView(seconds: context.state.remainingSeconds)
            }
            
            Spacer()
        }
        .padding()
        .activityBackgroundTint(Color(.systemBackground))
        .activitySystemActionForegroundColor(.primary)
    }
}
 
struct SaleTimerView: View {
    let seconds: Int
    
    var body: some View {
        HStack(spacing: 2) {
            Image(systemName: "clock")
                .font(.caption2)
            Text("残り \(formattedTime)")
                .font(.caption.monospacedDigit())
        }
        .foregroundStyle(.red)
    }
    
    var formattedTime: String {
        let h = seconds / 3600
        let m = (seconds % 3600) / 60
        let s = seconds % 60
        if h > 0 {
            return String(format: "%d時間%02d分", h, m)
        }
        return String(format: "%02d:%02d", m, s)
    }
}

// MainApp/AppSetup.swift
 
import RevenueCat
import FirebaseCore
 
func setupApp() {
    // Firebase を先に初期化
    FirebaseApp.configure()
    
    // RevenueCat の初期化
    Purchases.configure(withAPIKey: "YOUR_REVENUECAT_API_KEY")
    
    // カスタムログレベル（本番では .warn 以上）
    Purchases.logLevel = .warn
    
    // ユーザーIDの連携（認証済みの場合）
    if let userID = AuthService.shared.currentUserID {
        Purchases.shared.logIn(userID) { customerInfo, _, error in
            if let error {
                print("RevenueCat ログイン失敗: \(error)")
                return
            }
            updatePremiumStatus(from: customerInfo)
        }
    }
}
 
// RevenueCat から課金状態を読み取り App Group に書き込む
func updatePremiumStatus(from customerInfo: CustomerInfo?) {
    guard let info = customerInfo else { return }
    
    let state: PurchaseState
    if info.entitlements["premium"]?.isActive == true {
        state = .active
    } else if info.entitlements["trial"]?.isActive == true {
        state = .trial
    } else {
        state = .none
    }
    
    // Widget / App Clip と共有
    AppGroup.defaults.set(state.rawValue, forKey: AppGroup.Keys.userPremiumStatus)
    
    // Widget のタイムラインを即時更新
    WidgetCenter.shared.reloadAllTimelines()
}

// MainApp/Views/PaywallView.swift
 
import SwiftUI
import RevenueCat
 
struct PaywallView: View {
    let source: String  // "widget_cta", "app_clip", "live_activity"
    @State private var offerings: Offerings?
    @State private var isPurchasing = false
    @State private var purchaseError: String?
    @Environment(\.dismiss) private var dismiss
    
    var body: some View {
        ScrollView {
            VStack(spacing: 24) {
                // ヒーローセクション
                heroSection
                
                // プラン選択
                if let offerings {
                    planSelection(offerings: offerings)
                } else {
                    ProgressView()
                }
                
                // 購入ボタン
                purchaseButton
                
                // 法的テキスト
                legalText
            }
            .padding()
        }
        .task {
            await loadOfferings()
        }
        .onAppear {
            // ファネルトラッキング
            AnalyticsService.shared.logEvent("paywall_viewed", parameters: [
                "source": source,
                "funnel_stage": "paywall"
            ])
        }
    }
    
    private func loadOfferings() async {
        do {
            offerings = try await Purchases.shared.offerings()
        } catch {
            purchaseError = "プランの読み込みに失敗しました"
        }
    }
    
    private func purchase(package: Package) async {
        isPurchasing = true
        defer { isPurchasing = false }
        
        do {
            let result = try await Purchases.shared.purchase(package: package)
            
            if !result.userCancelled {
                // 購入成功
                updatePremiumStatus(from: result.customerInfo)
                
                AnalyticsService.shared.logEvent("purchase_completed", parameters: [
                    "source": source,
                    "product_id": package.storeProduct.productIdentifier,
                    "price": package.storeProduct.price.doubleValue
                ])
                
                // Live Activity が起動中なら終了
                await LiveActivityService().endActivity(purchased: true)
                
                dismiss()
            }
        } catch {
            purchaseError = "購入処理に失敗しました: \(error.localizedDescription)"
        }
    }
    
    // ... UIコンポーネントの実装は省略
}

// SharedKit/Services/AnalyticsService.swift
 
public class AnalyticsService {
    public static let shared = AnalyticsService()
    
    // ファネルの各ステージをイベントとして記録
    public enum FunnelEvent: String {
        // TOFU (App Clip)
        case appClipOpened = "app_clip_opened"
        case appClipContentViewed = "app_clip_content_viewed"
        case appClipUpgradeTapped = "app_clip_upgrade_tapped"
        
        // MOFU (Widget)
        case widgetTapped = "widget_tapped"
        case widgetUpgradeCTATapped = "widget_upgrade_cta_tapped"
        
        // BOFU (Live Activity)
        case liveActivityOpened = "live_activity_opened"
        case liveActivityCTATapped = "live_activity_cta_tapped"
        
        // 共通
        case paywallViewed = "paywall_viewed"
        case purchaseStarted = "purchase_started"
        case purchaseCompleted = "purchase_completed"
        case purchaseFailed = "purchase_failed"
    }
    
    public func logFunnelEvent(_ event: FunnelEvent, source: String, additionalParams: [String: Any] = [:]) {
        var params: [String: Any] = [
            "source": source,
            "timestamp": Date().timeIntervalSince1970
        ]
        params.merge(additionalParams) { _, new in new }
        
        // Firebase Analytics に送信
        Analytics.logEvent(event.rawValue, parameters: params)
    }
    
    // 転換率を計算するためのコンバージョントラッキング
    public func trackConversion(from stage: String, to nextStage: String, source: String) {
        logFunnelEvent(.purchaseCompleted, source: source, additionalParams: [
            "from_stage": stage,
            "to_stage": nextStage
        ])
    }
}

// ❌ 双方向書き込み（競合する）
sharedDefaults.set(["sessionId": id], forKey: "active_session")  // App Clip 側
sharedDefaults.set(["lastSeen": Date()], forKey: "active_session")  // 本体側
 
// ✅ App Clip 側からだけ書き込む。本体は読み取り専用
sharedDefaults.set(payload, forKey: "clip_handoff_v2")
// 本体側
let payload = sharedDefaults.dictionary(forKey: "clip_handoff_v2")
// 上書きしたい場合は別キーで保存する
sharedDefaults.set(updated, forKey: "main_runtime_state_v2")

let activity = try Activity<DeliveryAttributes>.request(
  attributes: .init(orderId: orderId),
  content: .init(state: state, staleDate: .now.addingTimeInterval(60 * 60)),
  pushType: .token
)
 
// 初回トークンを即座に upsert
if let token = activity.pushToken {
  await api.upsertPushToken(activity.id, token: token, source: "initial")
}
 
// 後続更新は AsyncSequence で
Task {
  for await tokenData in activity.pushTokenUpdates {
    await api.upsertPushToken(activity.id, token: tokenData, source: "stream")
  }
}

let staleDate = Calendar.current.date(byAdding: .minute, value: 90, to: .now)!
let activity = try Activity<DeliveryAttributes>.request(
  attributes: attrs,
  content: .init(state: state, staleDate: staleDate),
  pushType: .token
)

for await result in Transaction.currentEntitlements {
  guard case .verified(let tx) = result else { continue }
  if let exp = tx.expirationDate, exp < .now { continue }
  if tx.revocationDate != nil { continue }
  await entitlements.upsert(productId: tx.productID)
}

// App Clip 側 — onAppear で実行
let sessionId = UUID().uuidString
sharedDefaults.set(sessionId, forKey: "clip_handoff_session_id")
Analytics.setUserID(sessionId)
 
// 本体アプリ側 — 初回起動シーケンスの最初
if let inherited = sharedDefaults.string(forKey: "clip_handoff_session_id") {
  Analytics.setUserID(inherited)
  sharedDefaults.removeObject(forKey: "clip_handoff_session_id")
}

// 計測パラメータの生成をひとつの関数に集約します
enum WidgetRoute: String {
  case background = "widget_background"   // widgetURL が受ける余白
  case primaryCTA = "widget_cta"          // Link で覆った主要導線
}
 
func funnelURL(_ route: WidgetRoute, family: WidgetFamily) -> URL {
  var c = URLComponents(string: "myapp://open")!
  c.queryItems = [
    .init(name: "route", value: route.rawValue),
    .init(name: "family", value: String(describing: family)),
    .init(name: "stage", value: "mofu"),
  ]
  return c.url!
}
 
struct FunnelWidgetView: View {
  @Environment(\.widgetFamily) private var family
  let entry: FunnelEntry
 
  var body: some View {
    ZStack {
      content
    }
    // 小サイズでは Link が効かないため、常に受け皿を用意しておきます
    .widgetURL(funnelURL(.background, family: family))
  }
 
  @ViewBuilder private var content: some View {
    if family == .systemSmall {
      // Link を使わず、widgetURL 一本で受けます
      SummaryView(entry: entry)
    } else {
      VStack {
        SummaryView(entry: entry)
        Link(destination: funnelURL(.primaryCTA, family: family)) {
          UpgradeButtonLabel()
        }
      }
    }
  }
}