Antigravity × App Clip, WidgetKit & Live Activities: Designing an iOS Monetization Funnel

# 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 {
    public static let identifier = "group.com.example.myapp"
    
    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"
        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)
                }
        }
    }
}
 
@MainActor
class AppClipStore: ObservableObject {
    @Published var contentID: String?
    @Published var showUpgradePrompt = false
    
    func handleActivity(_ activity: NSUserActivity) {
        guard let url = activity.webpageURL else { return }
        parseInvocationURL(url)
        trackFunnelEvent(.appClipOpened)
    }
    
    private func parseInvocationURL(_ url: URL) {
        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
    
    var body: some View {
        NavigationStack {
            ZStack {
                if let contentID = store.contentID {
                    ContentPreviewView(contentID: contentID)
                        .transition(.opacity)
                } else {
                    DefaultClipLandingView()
                }
                
                VStack {
                    Spacer()
                    AppClipUpgradeBanner(
                        onGetFullApp: {
                            store.trackFunnelEvent(.upgradePromptTapped)
                            openFullApp()
                        }
                    )
                    .padding(.bottom, 20)
                }
            }
        }
        .onAppear {
            store.trackFunnelEvent(.appClipView)
        }
    }
    
    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("Try the full experience — free")
                .font(.headline)
            Text("App Clip shows a preview. The full app unlocks everything.")
                .font(.caption)
                .foregroundStyle(.secondary)
            
            Button("Download the Full App", 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
}
 
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 {
            let userState = loadUserState()
            let content = await fetchLatestContent()
            
            // Show upgrade prompt for non-paying users every 3rd refresh
            let showUpgrade = userState == .none && shouldShowUpgradePrompt()
            
            let entry = MonetizationWidgetEntry(
                date: .now,
                content: content,
                userState: userState,
                showUpgradePrompt: showUpgrade
            )
            
            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 {
        let count = AppGroup.defaults.integer(forKey: "widgetUpgradeShowCount")
        AppGroup.defaults.set(count + 1, forKey: "widgetUpgradeShowCount")
        return count % 3 == 0
    }
}
 
// Medium widget: content preview + upgrade 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 {
                    Link(destination: URL(string: "myapp://upgrade?source=widget")!) {
                        Label("Try Premium", 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("Keep reading →")
                            .font(.caption)
                            .foregroundStyle(.blue)
                    }
                }
            }
        }
        .padding()
        .containerBackground(.regularMaterial, for: .widget)
    }
}

.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"
        ])
        showPaywall(source: source)
        
    case "content":
        let contentID = components.path.dropFirst()
        navigateToContent(String(contentID))
        
    default: break
    }
}

// SharedKit/Models/LiveActivityState.swift
 
import ActivityKit
import SwiftUI
 
public struct SaleActivityAttributes: ActivityAttributes {
    
    public struct ContentState: Codable, Hashable {
        var remainingSeconds: Int
        var currentPrice: String
        var discountRate: Int
        var isPurchased: Bool
    }
    
    public var saleName: String
    public var originalPrice: String
    public var deepLinkURL: String
}
 
public class LiveActivityService: ObservableObject {
    private var currentActivity: Activity<SaleActivityAttributes>?
    
    public func startSaleActivity(
        saleName: String,
        durationSeconds: Int,
        discountRate: Int,
        originalPrice: String,
        salePrice: String
    ) async {
        guard ActivityAuthorizationInfo().areActivitiesEnabled else { 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(durationSeconds: durationSeconds)
        } catch {
            print("Live Activity failed to start: \(error)")
        }
    }
    
    private func startCountdown(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)
                }
            }
            await endActivity(purchased: false)
        }
    }
    
    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
            LockScreenSaleView(context: context)
        } dynamicIsland: { context in
            DynamicIsland {
                DynamicIslandExpandedRegion(.leading) {
                    SaleTimerView(seconds: context.state.remainingSeconds)
                }
                DynamicIslandExpandedRegion(.trailing) {
                    DiscountBadge(rate: context.state.discountRate)
                }
                DynamicIslandExpandedRegion(.bottom) {
                    Link(destination: URL(string: context.attributes.deepLinkURL)!) {
                        Label("Buy Now — \(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 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
        return h > 0
            ? String(format: "%dh %02dm", h, m)
            : String(format: "%02d:%02d", m, s)
    }
}

// MainApp/AppSetup.swift
 
import RevenueCat
import FirebaseCore
 
func setupApp() {
    FirebaseApp.configure()
    Purchases.configure(withAPIKey: "YOUR_REVENUECAT_API_KEY")
    Purchases.logLevel = .warn
    
    if let userID = AuthService.shared.currentUserID {
        Purchases.shared.logIn(userID) { customerInfo, _, error in
            if let error { print("RevenueCat login error: \(error)"); return }
            updatePremiumStatus(from: customerInfo)
        }
    }
}
 
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
    }
    
    AppGroup.defaults.set(state.rawValue, forKey: AppGroup.Keys.userPremiumStatus)
    WidgetCenter.shared.reloadAllTimelines()  // Refresh widget immediately
}

// 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 = "Unable to load plans. Please try again." }
    }
    
    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
                ])
                
                await LiveActivityService().endActivity(purchased: true)
                dismiss()
            }
        } catch {
            purchaseError = "Purchase failed: \(error.localizedDescription)"
        }
    }
}

// SharedKit/Services/AnalyticsService.swift
 
public class AnalyticsService {
    public static let shared = AnalyticsService()
    
    public enum FunnelEvent: String {
        // TOFU
        case appClipOpened = "app_clip_opened"
        case appClipContentViewed = "app_clip_content_viewed"
        case appClipUpgradeTapped = "app_clip_upgrade_tapped"
        
        // MOFU
        case widgetTapped = "widget_tapped"
        case widgetUpgradeCTATapped = "widget_upgrade_cta_tapped"
        
        // BOFU
        case liveActivityOpened = "live_activity_opened"
        case liveActivityCTATapped = "live_activity_cta_tapped"
        
        // Conversion
        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 }
        Analytics.logEvent(event.rawValue, parameters: params)
    }
}

// ❌ Two-way writes will race
sharedDefaults.set(["sessionId": id], forKey: "active_session")    // App Clip
sharedDefaults.set(["lastSeen": Date()], forKey: "active_session") // Main app
 
// ✅ App Clip writes; main app is read-only on that key
sharedDefaults.set(payload, forKey: "clip_handoff_v2")
// Main app reads only:
let payload = sharedDefaults.dictionary(forKey: "clip_handoff_v2")
// To persist new runtime state, use a separate key:
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 the initial token immediately
if let token = activity.pushToken {
  await api.upsertPushToken(activity.id, token: token, source: "initial")
}
 
// Subscribe to subsequent updates
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)
}

// Inside the App Clip view (onAppear)
let sessionId = UUID().uuidString
sharedDefaults.set(sessionId, forKey: "clip_handoff_session_id")
Analytics.setUserID(sessionId)
 
// In the main app's first-launch sequence
if let inherited = sharedDefaults.string(forKey: "clip_handoff_session_id") {
  Analytics.setUserID(inherited)
  sharedDefaults.removeObject(forKey: "clip_handoff_session_id")
}