iOS应用内购买(IAP)指南 - StoreKit 2详解

产品类型        可重复购买    可恢复购买    适用场景
消耗型         ✅          ❌         游戏道具、虚拟货币
非消耗型       ❌          ✅         解锁功能、永久权益
自动续订订阅    ❌          ✅         持续服务、定期更新
非续订订阅      ✅          ❌         课程、赛事、短期会员

// 1. App Store Connect配置
- 创建应用内购买项目
- 设置价格和描述
- 提交审核

// 2. 项目配置
- 添加StoreKit框架
- 配置App ID
- 设置测试账号

import Foundation
import StoreKit

typealias Transaction = StoreKit.Transaction
typealias RenewalInfo = StoreKit.Product.SubscriptionInfo.RenewalInfo
typealias RenewalState = StoreKit.Product.SubscriptionInfo.RenewalState

public enum StoreError: Error {
    case failedVerification
}

// 定义应用的订阅权限等级，按服务级别排序，最高级别的服务在前
// 数值级别与StoreKit配置文件或App Store Connect中配置的订阅级别匹配
public enum ServiceEntitlement: Int, Comparable {
    case notEntitled = 0
    
    case pro = 1
    case premium = 2
    case standard = 3
    
    init?(for product: Product) {
        // 产品必须是订阅才能有服务权限
        guard let subscription = product.subscription else {
            return nil
        }
        if #available(iOS 16.4, *) {
            self.init(rawValue: subscription.groupLevel)
        } else {
            switch product.id {
            case "subscription.standard":
                self = .standard
            case "subscription.premium":
                self = .premium
            case "subscription.pro":
                self = .pro
            default:
                self = .notEntitled
            }
        }
    }

    public static func < (lhs: Self, rhs: Self) -> Bool {
        // 订阅组级别按降序排列
        return lhs.rawValue > rhs.rawValue
    }
}

class Store: ObservableObject {

    // 产品分类
    @Published private(set) var cars: [Product]
    @Published private(set) var fuel: [Product]
    @Published private(set) var subscriptions: [Product]
    @Published private(set) var nonRenewables: [Product]
    
    // 已购买产品状态
    @Published private(set) var purchasedCars: [Product] = []
    @Published private(set) var purchasedNonRenewableSubscriptions: [Product] = []
    @Published private(set) var purchasedSubscriptions: [Product] = []
    @Published private(set) var subscriptionGroupStatus: Product.SubscriptionInfo.Status?
    
    // 交易监听任务
    var updateListenerTask: Task<Void, Error>? = nil

    // 产品ID到表情映射字典
    private let productIdToEmoji: [String: String]

    init() {
        // 从配置文件加载产品ID到表情的映射
        productIdToEmoji = Store.loadProductIdToEmojiData()

        // 初始化空产品列表，然后异步执行产品请求来填充它们
        cars = []
        fuel = []
        subscriptions = []
        nonRenewables = []

        // 尽可能早地启动交易监听器，以免错过任何交易
        updateListenerTask = listenForTransactions()

        Task {
            // 在商店初始化期间，从App Store请求产品
            await requestProducts()

            // 交付用户购买的产品
            await updateCustomerProductStatus()
        }
    }

    deinit {
        // 在类销毁时取消交易监听任务
        updateListenerTask?.cancel()
    }
}

static func loadProductIdToEmojiData() -> [String: String] {
    guard let path = Bundle.main.path(forResource: "Products", ofType: "plist"),
          let plist = FileManager.default.contents(atPath: path),
          let data = try? PropertyListSerialization.propertyList(from: plist, format: nil) as? [String: String] else {
        return [:]
    }
    return data
}

// 获取产品对应的表情符号
func emoji(for productId: String) -> String {
    return productIdToEmoji[productId]!
}

// 按价格排序产品
func sortByPrice(_ products: [Product]) -> [Product] {
    products.sorted(by: { return $0.price < $1.price })
}

func listenForTransactions() -> Task<Void, Error> {
    return Task.detached {
        // 迭代处理所有不是直接来自`purchase()`调用的交易
        for await result in Transaction.updates {
            do {
                let transaction = try self.checkVerified(result)

                // 向用户交付产品
                await self.updateCustomerProductStatus()

                // 始终完成交易
                await transaction.finish()
            } catch {
                // StoreKit有一个验证失败的交易。不要向用户交付内容
                print("Transaction failed verification.")
            }
        }
    }
}

func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
    // 检查JWS是否通过StoreKit验证
    switch result {
    case .unverified:
        // StoreKit解析了JWS，但验证失败
        throw StoreError.failedVerification
    case .verified(let safe):
        // 结果已验证。返回解包的值
        return safe
    }
}

@MainActor
func requestProducts() async {
    do {
        // 使用`Products.plist`文件定义的标识符从App Store请求产品
        let storeProducts = try await Product.products(for: productIdToEmoji.keys)

        var newCars: [Product] = []
        var newSubscriptions: [Product] = []
        var newNonRenewables: [Product] = []
        var newFuel: [Product] = []

        // 根据类型将产品分类
        for product in storeProducts {
            switch product.type {
            case .consumable:
                newFuel.append(product)
            case .nonConsumable:
                newCars.append(product)
            case .autoRenewable:
                newSubscriptions.append(product)
            case .nonRenewable:
                newNonRenewables.append(product)
            default:
                // 忽略此产品
                print("Unknown product.")
            }
        }

        // 按价格从低到高对每个产品类别进行排序，以更新商店
        cars = sortByPrice(newCars)
        subscriptions = sortByPrice(newSubscriptions)
        nonRenewables = sortByPrice(newNonRenewables)
        fuel = sortByPrice(newFuel)
    } catch {
        print("Failed product request from the App Store server. \(error)")
    }
}

func purchase(_ product: Product) async throws -> Transaction? {
    // 开始购买用户选择的`Product`
    let result = try await product.purchase()

    switch result {
    case .success(let verification):
        // 检查交易是否已验证。如果没有，
        // 此函数会重新抛出验证错误
        let transaction = try checkVerified(verification)

        // 交易已验证。向用户交付内容
        await updateCustomerProductStatus()

        // 始终完成交易
        await transaction.finish()

        return transaction
    case .userCancelled, .pending:
        return nil
    default:
        return nil
    }
}

func isPurchased(_ product: Product) async throws -> Bool {
    // 确定用户是否购买了给定产品
    switch product.type {
    case .nonRenewable:
        return purchasedNonRenewableSubscriptions.contains(product)
    case .nonConsumable:
        return purchasedCars.contains(product)
    case .autoRenewable:
        return purchasedSubscriptions.contains(product)
    default:
        return false
    }
}

@MainActor
func updateCustomerProductStatus() async {
    var purchasedCars: [Product] = []
    var purchasedSubscriptions: [Product] = []
    var purchasedNonRenewableSubscriptions: [Product] = []

    // 迭代用户购买的所有产品
    for await result in Transaction.currentEntitlements {
        do {
            // 检查交易是否已验证。如果没有，捕获`failedVerification`错误
            let transaction = try checkVerified(result)

            // 检查交易的`productType`并从商店获取相应的产品
            switch transaction.productType {
            case .nonConsumable:
                if let car = cars.first(where: { $0.id == transaction.productID }) {
                    purchasedCars.append(car)
                }
            case .nonRenewable:
                if let nonRenewable = nonRenewables.first(where: { $0.id == transaction.productID }),
                   transaction.productID == "nonRenewing.standard" {
                    // 非续期订阅没有固有的过期日期，所以`Transaction.currentEntitlements`
                    // 在用户购买后始终包含它们
                    // 此应用将此非续期订阅的过期日期定义为购买后一年
                    // 如果当前日期在购买日期的一年内，用户仍有权使用此产品
                    let currentDate = Date()
                    let expirationDate = Calendar(identifier: .gregorian).date(byAdding: DateComponents(year: 1),
                                                               to: transaction.purchaseDate)!

                    if currentDate < expirationDate {
                        purchasedNonRenewableSubscriptions.append(nonRenewable)
                    }
                }
            case .autoRenewable:
                if let subscription = subscriptions.first(where: { $0.id == transaction.productID }) {
                    purchasedSubscriptions.append(subscription)
                }
            default:
                break
            }
        } catch {
            print()
        }
    }

    // 使用购买的产品更新商店信息
    self.purchasedCars = purchasedCars
    self.purchasedNonRenewableSubscriptions = purchasedNonRenewableSubscriptions

    // 使用自动续期订阅产品更新商店信息
    self.purchasedSubscriptions = purchasedSubscriptions

    // 检查`subscriptionGroupStatus`以了解自动续期订阅状态，确定客户
    // 是新客户（从未订阅）、活跃客户还是非活跃客户（订阅已过期）
    // 此应用只有一个订阅组，因此subscriptions数组中的产品都属于同一组
    // 客户只能订阅订阅组中的一个产品
    // `product.subscription.status`返回的状态适用于整个订阅组
    subscriptionGroupStatus = try? await subscriptions.first?.subscription?.status.max { lhs, rhs in
        // 由于此应用支持家庭共享，可能有多个家庭成员的不同状态
        // 订阅者有权获得服务级别最高的状态
        let lhsEntitlement = entitlement(for: lhs)
        let rhsEntitlement = entitlement(for: rhs)
        return lhsEntitlement < rhsEntitlement
    }
}

// 使用产品ID获取订阅的服务级别
func entitlement(for status: Product.SubscriptionInfo.Status) -> ServiceEntitlement {
    // 如果状态是过期的，则客户没有权限
    if status.state == .expired || status.state == .revoked {
        return .notEntitled
    }
    // 获取与订阅状态关联的产品
    let productID = status.transaction.unsafePayloadValue.productID
    guard let product = subscriptions.first(where: { $0.id == productID }) else {
        return .notEntitled
    }
    // 最后，获取此产品对应的权限
    return ServiceEntitlement(for: product) ?? .notEntitled
}

// StoreKit 1 (旧API)
// 1. 需要手动实现收据验证
// 2. 使用代理模式处理异步回调
// 3. 需要大量样板代码处理交易队列
// 4. 订阅状态管理复杂

// StoreKit 2 (新API)
// 1. 使用async/await简化异步操作
// 2. 内置收据验证
// 3. 使用Transaction.updates和Transaction.currentEntitlements简化交易处理
// 4. 提供丰富的订阅状态API
// 5. 支持家庭共享

// 示例：StoreKit 2简化的产品请求
let products = try await Product.products(for: ["com.example.product1"])

// 示例：StoreKit 2简化的购买流程
let result = try await product.purchase()

// 1. 尽早启动交易监听器
init() {
    // ...其他初始化代码...
    
    // 在应用启动时尽早启动，避免错过交易
    updateListenerTask = listenForTransactions()
}

// 2. 始终验证交易
let transaction = try checkVerified(verification)

// 3. 始终完成交易
await transaction.finish()

// 4. 正确处理非续期订阅过期
let currentDate = Date()
let expirationDate = Calendar(identifier: .gregorian)
    .date(byAdding: DateComponents(year: 1), to: transaction.purchaseDate)!

if currentDate < expirationDate {
    // 订阅仍然有效
}

// 5. 处理家庭共享
subscriptionGroupStatus = try? await subscriptions.first?.subscription?.status.max { lhs, rhs in
    let lhsEntitlement = entitlement(for: lhs)
    let rhsEntitlement = entitlement(for: rhs)
    return lhsEntitlement < rhsEntitlement
}