subscription-paywall

订阅 & Paywall

技术栈

• StoreKit 2（iOS 15+）
• 产品配置：App Store Connect → Subscriptions
• 本地权益验证：Transaction.currentEntitlements
• 服务端验证（可选）：JWS Transaction 发送到后端校验

---

订阅产品结构

enum SubscriptionProduct: String, CaseIterable {
    case monthly  = "com.app.subscription.monthly"
    case yearly   = "com.app.subscription.yearly"
}

extension SubscriptionProduct {
    var displayName: String {
        switch self {
        case .monthly: return "月度会员"
        case .yearly: return "年度会员"
        }
    }

    var pricePerMonth: String {
        switch self {
        case .monthly: return "按月付费"
        case .yearly: return "按年付费（省 40%）"
        }
    }
}

---

SubscriptionManager 完整封装

import StoreKit

final class SubscriptionManager {
    static let shared = SubscriptionManager()

    private(set) var isPro: Bool = false
    private(set) var activeSubscription: SubscriptionProduct?
    private(set) var expirationDate: Date?

    var onEntitlementChanged: ((Bool) -> Void)?

    private var transactionListener: Task<Void, Never>?

    private init() {
        transactionListener = listenForTransactions()
        Task { await checkEntitlement() }
    }

    deinit {
        transactionListener?.cancel()
    }

    func loadProducts() async throws -> [Product] {
        let productIDs = SubscriptionProduct.allCases.map(\.rawValue)
        return try await Product.products(for: productIDs)
    }

    func purchase(_ product: Product) async throws -> Bool {
        let result = try await product.purchase()

        switch result {
        case .success(let verification):
            let transaction = try checkVerification(verification)
            await transaction.finish()
            await updateEntitlement(transaction)
            return true
        case .userCancelled:
            return false
        case .pending:
            return false
        @unknown default:
            return false
        }
    }

    func restorePurchases() async {
        try? await AppStore.sync()
        await checkEntitlement()
    }

    func checkEntitlement() async {
        var isSubscribed = false
        var latestTransaction: StoreKit.Transaction?

        for await result in Transaction.currentEntitlements {
            if case .verified(let transaction) = result {
                if transaction.productType == .autoRenewable,
                   transaction.revocationDate == nil {
                    isSubscribed = true
                    if latestTransaction == nil || transaction.expirationDate ?? .distantPast > latestTransaction?.expirationDate ?? .distantPast {
                        latestTransaction = transaction
                    }
                }
            }
        }

        isPro = isSubscribed
        if let transaction = latestTransaction {
            activeSubscription = SubscriptionProduct(rawValue: transaction.productID)
            expirationDate = transaction.expirationDate
        }
        onEntitlementChanged?(isPro)
    }

    private func listenForTransactions() -> Task<Void, Never> {
        Task.detached { [weak self] in
            for await result in Transaction.updates {
                if case .verified(let transaction) = result {
                    await transaction.finish()
                    await self?.updateEntitlement(transaction)
                }
            }
        }
    }

    private func updateEntitlement(_ transaction: StoreKit.Transaction) async {
        isPro = transaction.revocationDate == nil
        activeSubscription = SubscriptionProduct(rawValue: transaction.productID)
        expirationDate = transaction.expirationDate
        onEntitlementChanged?(isPro)
    }

    private func checkVerification(_ result: VerificationResult<StoreKit.Transaction>) throws -> StoreKit.Transaction {
        switch result {
        case .unverified(_, let error):
            throw error
        case .verified(let transaction):
            return transaction
        }
    }
}