482 lines
19 KiB
Swift
482 lines
19 KiB
Swift
import Foundation
|
|
import StoreKit
|
|
import TermindDomain
|
|
|
|
@MainActor
|
|
@Observable
|
|
public final class ProAccessController {
|
|
public static let lifetimeProductID = "com.akinokaede.termind.pro"
|
|
public static let annualProductID = "com.akinokaede.termind.pro.annual"
|
|
|
|
private let now: () -> Date
|
|
private var transactionUpdates: Task<Void, Never>?
|
|
private var refreshTask: Task<Void, Never>?
|
|
private var accessTask: Task<EntitlementStatus, Never>?
|
|
private var metadataTask: Task<Void, Never>?
|
|
private var productsTask: Task<[Product], any Error>?
|
|
private var entitlementExpirationTask: Task<Void, Never>?
|
|
private var refreshGeneration: UInt64 = 0
|
|
private var metadataError: ProAccessControllerError?
|
|
|
|
public private(set) var status: EntitlementStatus
|
|
/// The permanent, non-consumable product. Kept under the existing name for source compatibility.
|
|
public private(set) var product: Product?
|
|
public private(set) var annualProduct: Product?
|
|
public private(set) var isEligibleForAnnualIntroOffer: Bool?
|
|
public private(set) var error: ProAccessControllerError?
|
|
public private(set) var isProcessing = false
|
|
public private(set) var pendingProductID: String?
|
|
public var isPaywallPresented = false
|
|
public var requestedFeature: ProFeature?
|
|
|
|
public var displayPrice: String? { product?.displayPrice }
|
|
public var annualDisplayPrice: String? { annualProduct?.displayPrice }
|
|
public var annualBillingPeriod: DateComponents? {
|
|
annualProduct?.subscription.map { Self.dateComponents(for: $0.subscriptionPeriod, count: 1) }
|
|
}
|
|
public var annualIntroOfferDuration: DateComponents? {
|
|
guard let offer = Self.freeIntroductoryOffer(for: annualProduct) else { return nil }
|
|
return Self.dateComponents(for: offer.period, count: offer.periodCount)
|
|
}
|
|
public var hasProAccess: Bool { status.hasProAccess }
|
|
public var canPurchase: Bool { canPurchase(.lifetime) }
|
|
public var canPurchaseAnnual: Bool { canPurchase(.annual) }
|
|
public var canStartTrial: Bool {
|
|
canPurchase(.annual) && isEligibleForAnnualIntroOffer == true
|
|
&& Self.freeIntroductoryOffer(for: annualProduct) != nil
|
|
}
|
|
public var message: String? {
|
|
if let error { return error.localizedDescription }
|
|
if pendingProductID != nil { return ProAccessControllerError.purchasePending.localizedDescription }
|
|
if status.canPurchase, let metadataError { return metadataError.localizedDescription }
|
|
return nil
|
|
}
|
|
|
|
public static func live() -> ProAccessController { ProAccessController() }
|
|
|
|
public static func unrestrictedForTesting() -> ProAccessController {
|
|
testing(status: .unrestrictedForTesting)
|
|
}
|
|
|
|
public static func testing(status: EntitlementStatus) -> ProAccessController {
|
|
let controller = ProAccessController(observeStore: false)
|
|
controller.status = status
|
|
return controller
|
|
}
|
|
|
|
public init(
|
|
now: @escaping () -> Date = { .now },
|
|
observeStore: Bool = true
|
|
) {
|
|
self.now = now
|
|
status = .loading
|
|
guard observeStore else { return }
|
|
transactionUpdates = Task { [weak self] in
|
|
for await update in Transaction.updates {
|
|
guard !Task.isCancelled, let self else { return }
|
|
await self.handleTransactionUpdate(update)
|
|
}
|
|
}
|
|
refreshTask = Task { [weak self] in await self?.refresh() }
|
|
metadataTask = Task { [weak self] in await self?.reloadProducts() }
|
|
}
|
|
|
|
isolated deinit {
|
|
transactionUpdates?.cancel()
|
|
refreshTask?.cancel()
|
|
accessTask?.cancel()
|
|
metadataTask?.cancel()
|
|
productsTask?.cancel()
|
|
entitlementExpirationTask?.cancel()
|
|
}
|
|
|
|
public func canUse(_: ProFeature) -> Bool {
|
|
status.hasProAccess
|
|
}
|
|
|
|
public func canPurchase(_ plan: ProPurchasePlan) -> Bool {
|
|
guard status.canPurchase, !isProcessing else { return false }
|
|
switch plan {
|
|
case .annual:
|
|
return pendingProductID != Self.annualProductID && annualProduct != nil
|
|
case .lifetime:
|
|
return pendingProductID != Self.lifetimeProductID && product != nil
|
|
}
|
|
}
|
|
|
|
@discardableResult
|
|
public func require(_ feature: ProFeature) -> Bool {
|
|
guard !canUse(feature) else { return true }
|
|
requestedFeature = feature
|
|
isPaywallPresented = true
|
|
return false
|
|
}
|
|
|
|
public func presentPaywall(for feature: ProFeature? = nil) {
|
|
requestedFeature = feature
|
|
isPaywallPresented = true
|
|
}
|
|
|
|
/// StoreKit's local transactions resolve access independently of network product metadata.
|
|
public func refresh() async { await refresh(including: nil) }
|
|
|
|
private func refresh(including transaction: Transaction?) async {
|
|
if status == .unrestrictedForTesting { return }
|
|
if accessTask == nil || transaction != nil {
|
|
accessTask?.cancel()
|
|
refreshGeneration &+= 1
|
|
accessTask = Task { [weak self] in
|
|
await self?.currentStatus(including: transaction) ?? .loading
|
|
}
|
|
}
|
|
let generation = refreshGeneration
|
|
guard let task = accessTask else { return }
|
|
let resolved = await task.value
|
|
guard generation == refreshGeneration else {
|
|
if accessTask != nil { await refresh() }
|
|
return
|
|
}
|
|
guard accessTask != nil else { return }
|
|
accessTask = nil
|
|
switch resolved {
|
|
case .purchased:
|
|
pendingProductID = nil
|
|
case .subscription(let subscription) where subscription.phase.hasProAccess:
|
|
if pendingProductID == Self.annualProductID { pendingProductID = nil }
|
|
default:
|
|
break
|
|
}
|
|
apply(resolved)
|
|
}
|
|
|
|
/// Purchases the annual subscription. StoreKit applies its introductory offer for eligible accounts.
|
|
public func purchaseAnnual() async { await purchaseProduct(Self.annualProductID) }
|
|
public func purchaseLifetime() async { await purchaseProduct(Self.lifetimeProductID) }
|
|
|
|
private func purchaseProduct(_ id: String) async {
|
|
guard !isProcessing, pendingProductID != id, status.canPurchase else { return }
|
|
isProcessing = true
|
|
error = nil
|
|
defer { isProcessing = false }
|
|
await refresh()
|
|
guard status.canPurchase else { return }
|
|
do {
|
|
try await fetchProducts()
|
|
let selected: Product
|
|
switch id {
|
|
case Self.annualProductID:
|
|
guard let annualProduct else { throw ProAccessControllerError.productUnavailable }
|
|
selected = annualProduct
|
|
case Self.lifetimeProductID:
|
|
guard let product else { throw ProAccessControllerError.productUnavailable }
|
|
selected = product
|
|
default:
|
|
throw ProAccessControllerError.productUnavailable
|
|
}
|
|
switch try await selected.purchase() {
|
|
case .success(let verification):
|
|
guard case .verified(let transaction) = verification, transaction.productID == id else {
|
|
error = .purchaseVerificationFailed
|
|
return
|
|
}
|
|
await refresh(including: transaction)
|
|
await transaction.finish()
|
|
if status.hasProAccess { isPaywallPresented = false }
|
|
case .pending:
|
|
pendingProductID = id
|
|
case .userCancelled:
|
|
break
|
|
@unknown default:
|
|
error = .purchaseVerificationFailed
|
|
}
|
|
} catch StoreKitError.userCancelled {
|
|
// Cancellation is not an entitlement change or a failure to display.
|
|
} catch let purchaseError {
|
|
error = purchaseError as? ProAccessControllerError ?? .operationFailed(purchaseError.localizedDescription)
|
|
}
|
|
}
|
|
|
|
public func restorePurchases() async {
|
|
guard !isProcessing else { return }
|
|
isProcessing = true
|
|
error = nil
|
|
defer { isProcessing = false }
|
|
do {
|
|
try await AppStore.sync()
|
|
await refresh()
|
|
switch status {
|
|
case .purchased:
|
|
isPaywallPresented = false
|
|
case .subscription(let subscription) where subscription.phase.hasProAccess:
|
|
isPaywallPresented = false
|
|
case .verificationFailed:
|
|
error = .purchaseVerificationFailed
|
|
default:
|
|
error = .purchaseNotFound
|
|
}
|
|
} catch {
|
|
self.error = .operationFailed(error.localizedDescription)
|
|
}
|
|
}
|
|
|
|
public func reloadProducts() async {
|
|
do {
|
|
try await fetchProducts()
|
|
} catch {
|
|
product = nil
|
|
annualProduct = nil
|
|
isEligibleForAnnualIntroOffer = nil
|
|
metadataError = .productMetadataUnavailable
|
|
}
|
|
}
|
|
|
|
private func fetchProducts() async throws {
|
|
let task =
|
|
productsTask
|
|
?? Task {
|
|
try await Product.products(for: [Self.lifetimeProductID, Self.annualProductID])
|
|
}
|
|
productsTask = task
|
|
defer { productsTask = nil }
|
|
let loaded = try await task.value
|
|
product = loaded.first { Self.isLifetimeProduct($0) }
|
|
annualProduct = loaded.first { Self.isAnnualSubscription($0) }
|
|
if let subscription = annualProduct?.subscription,
|
|
Self.freeIntroductoryOffer(for: annualProduct) != nil
|
|
{
|
|
isEligibleForAnnualIntroOffer = await subscription.isEligibleForIntroOffer
|
|
} else {
|
|
isEligibleForAnnualIntroOffer = false
|
|
}
|
|
if product == nil, annualProduct == nil {
|
|
metadataError = .productUnavailable
|
|
} else {
|
|
metadataError = nil
|
|
}
|
|
if case .free = status {
|
|
apply(.free(trialAvailable: isEligibleForAnnualIntroOffer == true))
|
|
}
|
|
}
|
|
|
|
public static func isLifetimeProduct(_ product: Product) -> Bool {
|
|
product.id == lifetimeProductID && product.type == .nonConsumable && product.isFamilyShareable
|
|
}
|
|
|
|
public static func isAnnualSubscription(_ product: Product) -> Bool {
|
|
guard product.id == annualProductID, product.type == .autoRenewable,
|
|
product.isFamilyShareable, let subscription = product.subscription
|
|
else { return false }
|
|
return subscription.subscriptionPeriod.unit == .year && subscription.subscriptionPeriod.value == 1
|
|
}
|
|
|
|
public static func freeIntroductoryOffer(for product: Product?) -> Product.SubscriptionOffer? {
|
|
guard let offer = product?.subscription?.introductoryOffer,
|
|
offer.type == .introductory, offer.paymentMode == .freeTrial, offer.price == .zero
|
|
else { return nil }
|
|
return offer
|
|
}
|
|
|
|
private func currentStatus(including update: Transaction?) async -> EntitlementStatus {
|
|
let lifetimeResult = await currentLifetimeTransaction(including: update)
|
|
if let lifetime = lifetimeResult.transaction {
|
|
return .purchased(Self.ownership(of: lifetime))
|
|
}
|
|
|
|
var verificationFailed = lifetimeResult.verificationFailed
|
|
let annualResult: VerificationResult<Transaction>?
|
|
if let update, update.productID == Self.annualProductID {
|
|
annualResult = .verified(update)
|
|
} else {
|
|
annualResult = await Transaction.latest(for: Self.annualProductID)
|
|
}
|
|
if let annualResult {
|
|
switch annualResult {
|
|
case .verified(let transaction):
|
|
return .subscription(await subscriptionStatus(for: transaction))
|
|
case .unverified:
|
|
verificationFailed = true
|
|
}
|
|
}
|
|
|
|
return verificationFailed ? .verificationFailed : .free(trialAvailable: isEligibleForAnnualIntroOffer == true)
|
|
}
|
|
|
|
private func currentLifetimeTransaction(
|
|
including update: Transaction?
|
|
) async -> (transaction: Transaction?, verificationFailed: Bool) {
|
|
if let update, update.productID == Self.lifetimeProductID, update.productType == .nonConsumable,
|
|
update.revocationDate == nil
|
|
{
|
|
return (update, false)
|
|
}
|
|
var verificationFailed = false
|
|
for await result in Transaction.currentEntitlements {
|
|
switch result {
|
|
case .verified(let transaction)
|
|
where
|
|
transaction.productID == Self.lifetimeProductID && transaction.revocationDate == nil
|
|
&& transaction.productType == .nonConsumable
|
|
&& !(update?.productID == Self.lifetimeProductID && update?.revocationDate != nil
|
|
&& update?.originalID == transaction.originalID):
|
|
return (transaction, false)
|
|
case .unverified(let transaction, _) where transaction.productID == Self.lifetimeProductID:
|
|
verificationFailed = true
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
if let latest = await Transaction.latest(for: Self.lifetimeProductID) {
|
|
switch latest {
|
|
case .verified(let transaction)
|
|
where transaction.revocationDate == nil && transaction.productType == .nonConsumable
|
|
&& !(update?.productID == Self.lifetimeProductID && update?.revocationDate != nil
|
|
&& update?.originalID == transaction.originalID):
|
|
return (transaction, false)
|
|
case .unverified:
|
|
verificationFailed = true
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
return (nil, verificationFailed)
|
|
}
|
|
|
|
private func subscriptionStatus(for transaction: Transaction) async -> ProSubscriptionStatus {
|
|
let ownership = Self.ownership(of: transaction)
|
|
if transaction.revocationDate != nil || transaction.productType != .autoRenewable {
|
|
return ProSubscriptionStatus(
|
|
phase: .revoked, expiresAt: transaction.expirationDate, willAutoRenew: false,
|
|
ownership: ownership)
|
|
}
|
|
|
|
let storeStatus = await transaction.subscriptionStatus
|
|
let renewalInfo: Product.SubscriptionInfo.RenewalInfo?
|
|
if let storeStatus, case .verified(let verified) = storeStatus.renewalInfo {
|
|
renewalInfo = verified
|
|
} else {
|
|
renewalInfo = nil
|
|
}
|
|
|
|
if let expiration = transaction.expirationDate, expiration > now(), !transaction.isUpgraded {
|
|
let phase: ProSubscriptionPhase = Self.isIntroductoryTrial(transaction) ? .introductoryTrial : .subscribed
|
|
return ProSubscriptionStatus(
|
|
phase: phase, expiresAt: expiration, willAutoRenew: renewalInfo?.willAutoRenew,
|
|
ownership: ownership)
|
|
}
|
|
|
|
switch storeStatus?.state {
|
|
case .inGracePeriod:
|
|
if let graceExpiration = renewalInfo?.gracePeriodExpirationDate, graceExpiration > now() {
|
|
return ProSubscriptionStatus(
|
|
phase: .gracePeriod, expiresAt: graceExpiration, willAutoRenew: renewalInfo?.willAutoRenew,
|
|
ownership: ownership)
|
|
}
|
|
return ProSubscriptionStatus(
|
|
phase: .billingRetry, expiresAt: transaction.expirationDate,
|
|
willAutoRenew: renewalInfo?.willAutoRenew, ownership: ownership)
|
|
case .inBillingRetryPeriod:
|
|
return ProSubscriptionStatus(
|
|
phase: .billingRetry, expiresAt: transaction.expirationDate,
|
|
willAutoRenew: renewalInfo?.willAutoRenew, ownership: ownership)
|
|
case .revoked:
|
|
return ProSubscriptionStatus(
|
|
phase: .revoked, expiresAt: transaction.expirationDate, willAutoRenew: false,
|
|
ownership: ownership)
|
|
case .subscribed:
|
|
return ProSubscriptionStatus(
|
|
phase: .subscribed, expiresAt: transaction.expirationDate,
|
|
willAutoRenew: renewalInfo?.willAutoRenew, ownership: ownership)
|
|
case .expired, .none:
|
|
return ProSubscriptionStatus(
|
|
phase: .expired, expiresAt: transaction.expirationDate, willAutoRenew: false,
|
|
ownership: ownership)
|
|
default:
|
|
return ProSubscriptionStatus(
|
|
phase: .expired, expiresAt: transaction.expirationDate, willAutoRenew: false,
|
|
ownership: ownership)
|
|
}
|
|
}
|
|
|
|
private static func isIntroductoryTrial(_ transaction: Transaction) -> Bool {
|
|
transaction.offer?.type == .introductory && transaction.offer?.paymentMode == .freeTrial
|
|
}
|
|
|
|
private static func ownership(of transaction: Transaction) -> ProOwnership {
|
|
transaction.ownershipType == .familyShared ? .familyShared : .purchased
|
|
}
|
|
|
|
public func handleTransactionUpdate(_ update: VerificationResult<Transaction>) async {
|
|
let knownProductIDs = [Self.lifetimeProductID, Self.annualProductID]
|
|
guard knownProductIDs.contains(update.unsafePayloadValue.productID) else { return }
|
|
if case .verified(let transaction) = update {
|
|
error = nil
|
|
if pendingProductID == transaction.productID { pendingProductID = nil }
|
|
await refresh(including: transaction)
|
|
await transaction.finish()
|
|
} else {
|
|
error = .purchaseVerificationFailed
|
|
await refresh()
|
|
}
|
|
}
|
|
|
|
private func apply(_ next: EntitlementStatus) {
|
|
status = next
|
|
entitlementExpirationTask?.cancel()
|
|
let expiresAt: Date?
|
|
switch next {
|
|
case .subscription(let subscription) where subscription.phase.hasProAccess:
|
|
expiresAt = subscription.expiresAt
|
|
default:
|
|
expiresAt = nil
|
|
}
|
|
if let expiresAt {
|
|
entitlementExpirationTask = Task { [weak self] in
|
|
let remaining = min(60, max(0, expiresAt.timeIntervalSince(self?.now() ?? .now)))
|
|
try? await Task.sleep(for: .seconds(remaining))
|
|
guard !Task.isCancelled else { return }
|
|
await self?.refresh()
|
|
}
|
|
}
|
|
}
|
|
|
|
private static func dateComponents(for period: Product.SubscriptionPeriod, count: Int) -> DateComponents {
|
|
let value = period.value * count
|
|
var components = DateComponents()
|
|
switch period.unit {
|
|
case .day: components.day = value
|
|
case .week: components.weekOfYear = value
|
|
case .month: components.month = value
|
|
case .year: components.year = value
|
|
@unknown default: break
|
|
}
|
|
return components
|
|
}
|
|
|
|
}
|
|
|
|
public nonisolated enum ProAccessControllerError: LocalizedError, Equatable, Sendable {
|
|
case productUnavailable
|
|
case productMetadataUnavailable
|
|
case purchaseVerificationFailed
|
|
case purchasePending
|
|
case operationFailed(String)
|
|
case purchaseNotFound
|
|
|
|
public var errorDescription: String? {
|
|
switch self {
|
|
case .productUnavailable:
|
|
String(localized: "Termind Pro is not available from the App Store right now.")
|
|
case .productMetadataUnavailable:
|
|
String(localized: "The App Store is temporarily unavailable. You can keep using already unlocked features.")
|
|
case .operationFailed(let description):
|
|
description
|
|
case .purchaseVerificationFailed:
|
|
String(localized: "The App Store could not verify this purchase.")
|
|
case .purchasePending:
|
|
String(localized: "The purchase is waiting for App Store approval.")
|
|
case .purchaseNotFound:
|
|
String(localized: "No active Termind Pro purchase or subscription was found for this App Store account.")
|
|
}
|
|
}
|
|
}
|