Rork Max で SwiftUI ネイティブアプリを収益化する — App Store 審査攻略からサブスクリプション設計まで

import StoreKit
 
@MainActor
final class StoreManager: ObservableObject {
    @Published private(set) var products: [Product] = []
    @Published private(set) var isSubscribed = false
    @Published var errorMessage: String?
 
    private let productIDs = ["com.example.app.monthly", "com.example.app.yearly"]
    private var updatesTask: Task<Void, Never>?
 
    init() {
        updatesTask = Task { [weak self] in
            for await result in Transaction.updates {
                if case .verified(let transaction) = result {
                    await transaction.finish()
                }
                await self?.refreshEntitlements()
            }
        }
        Task { await refreshEntitlements() }
    }
 
    deinit { updatesTask?.cancel() }
 
    func loadProducts() async {
        do {
            products = try await Product.products(for: productIDs)
                .sorted { $0.price < $1.price }
        } catch {
            errorMessage = "商品情報を取得できませんでした。"
        }
    }
 
    func purchase(_ product: Product) async {
        do {
            switch try await product.purchase() {
            case .success(let verification):
                guard case .verified(let transaction) = verification else {
                    errorMessage = "購入の検証に失敗しました。"
                    return
                }
                await transaction.finish()
                await refreshEntitlements()
            case .userCancelled, .pending:
                break
            @unknown default:
                break
            }
        } catch {
            errorMessage = "購入を完了できませんでした。"
        }
    }
 
    func refreshEntitlements() async {
        var active = false
        for await result in Transaction.currentEntitlements {
            if case .verified(let transaction) = result,
               productIDs.contains(transaction.productID),
               transaction.revocationDate == nil {
                active = true
            }
        }
        isSubscribed = active
    }
 
    func restore() async {
        try? await AppStore.sync()
        await refreshEntitlements()
    }
}

func trialText(for product: Product) -> String? {
    guard let offer = product.subscription?.introductoryOffer,
          offer.paymentMode == .freeTrial else { return nil }
    let unit = offer.period.unit
    let value = offer.period.value
    let span: String
    switch unit {
    case .day: span = "\(value)日間"
    case .week: span = "\(value)週間"
    case .month: span = "\(value)か月"
    default: span = "\(value)年"
    }
    return "\(span)無料、その後 \(product.displayPrice)"
}

struct PaywallView: View {
    @StateObject private var store = StoreManager()
    @Environment(\.dismiss) private var dismiss
 
    var body: some View {
        NavigationStack {
            List(store.products) { product in
                VStack(alignment: .leading, spacing: 4) {
                    Text(product.displayName).font(.headline)
                    if let trial = trialText(for: product) {
                        Text(trial).font(.subheadline)
                    } else {
                        Text(product.displayPrice).font(.subheadline)
                    }
                    Button("購入する") {
                        Task { await store.purchase(product) }
                    }
                }
                .padding(.vertical, 4)
            }
            .navigationTitle("プレミアム")
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("閉じる") { dismiss() }
                }
                ToolbarItem(placement: .bottomBar) {
                    Button("購入を復元") { Task { await store.restore() } }
                }
            }
            .task { await store.loadProducts() }
            .onChange(of: store.isSubscribed) { _, subscribed in
                if subscribed { dismiss() }
            }
        }
    }
}

import UserNotifications
 
func scheduleReminder(afterDays days: Int, title: String, body: String) async {
    let center = UNUserNotificationCenter.current()
    guard (try? await center.requestAuthorization(options: [.alert, .sound])) == true else { return }
 
    let content = UNMutableNotificationContent()
    content.title = title
    content.body = body
 
    let trigger = UNTimeIntervalNotificationTrigger(
        timeInterval: TimeInterval(days * 24 * 60 * 60), repeats: false)
    try? await center.add(UNNotificationRequest(
        identifier: "retention-\(days)d", content: content, trigger: trigger))
}