1

让我描述一下我做了什么。我开始和停止在我的应用委托中观察应用内购买，如下所示：

在didFinishLaunchingWithOptions：

IAPManager.shared.startObserving()

并在applicationWillTerminate：

IAPManager.shared.stopObserving()

这些是我的 IAPManager 类中的函数：

func startObserving() {
    SKPaymentQueue.default().add(self)
}

func stopObserving() {
    SKPaymentQueue.default().remove(self)
}

我知道沙盒用户的购买时间范围如下：

1 week = 3 minutes
1 month = 5 minutes
2 months = 10 minutes
3 months = 15 minutes
6 months = 30 minutes
1 year = 1 hour

但它与沙盒用户测试不匹配。跨越这个时间跨度后，如果我点击“恢复购买”按钮，它仍然会给我所有以前购买的产品 ID。

我的恢复代码：

PurchaseViewController：

func restorePurchases() {
    IAPManager.shared.restorePurchases { (result) in
        DispatchQueue.main.async {
            switch result {
            case .success(let success):
                if success {
                    self.restoredProductSuccessfully()
                    self.didFinishRestoringPurchasedProducts()
                } else {
                    self.didFinishRestoringPurchasesWithZeroProducts()
                }

            case .failure(let error):
                self.showIAPRelatedError(error)
            }
            self.activityIndicator.stopAnimating()
        }
    }
}

IAPManager class：

//Handler
var onBuyProductHandler: ((Result<Bool, Error>) -> Void)?

func restorePurchases(withHandler handler: @escaping ((_ result: Result<Bool, Error>) -> Void)) {
    onBuyProductHandler = handler
    totalRestoredPurchases = 0
    SKPaymentQueue.default().restoreCompletedTransactions()
}

SKPaymentTransactionObserver委托方法：

extension IAPManager: SKPaymentTransactionObserver {
    //This delegate will trigger for every transactions, either for purchasing or restoring
    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
        transactions.forEach { (transaction) in
            switch transaction.transactionState {
            case .purchased:
                onBuyProductHandler?(.success(true))
                SKPaymentQueue.default().finishTransaction(transaction)
                
            case .restored:
                totalRestoredPurchases += 1
                let prodID = transaction.payment.productIdentifier
                print("restored productID \(prodID)")
                SKPaymentQueue.default().finishTransaction(transaction)

            case .failed:
                if let error = transaction.error as? SKError {
                    if error.code != .paymentCancelled {
                        onBuyProductHandler?(.failure(error))
                    } else {
                        onBuyProductHandler?(.failure(IAPManagerError.paymentWasCancelled))
                    }
                    onBuyProductHandler?(.failure(error))
                    //print("IAP Error:", error.localizedDescription)
                }
                SKPaymentQueue.default().finishTransaction(transaction)
                
            case .deferred, .purchasing: break
            @unknown default: break
            }
        }
    }
    
    func paymentQueueRestoreCompletedTransactionsFinished(_ queue: SKPaymentQueue) {
        if totalRestoredPurchases != 0 {
            onBuyProductHandler?(.success(true))
        } else {
            print("IAP: No purchases to restore!")
            onBuyProductHandler?(.success(false))
        }
    }
    
    func paymentQueue(_ queue: SKPaymentQueue, restoreCompletedTransactionsFailedWithError error: Error) {
        if let error = error as? SKError {
            if error.code != .paymentCancelled {
                print("IAP Restore Error:", error.localizedDescription)
                onBuyProductHandler?(.failure(error))
            } else {
                onBuyProductHandler?(.failure(IAPManagerError.paymentWasCancelled))
            }
        }
    }
}

在这一行的委托方法中，print("restored productID \(prodID)")我总是得到我以前的所有产品标识符，尽管它们应该已经过期。我在这里想念什么？

4

0 回答 0