IAP autoRenewable подписки, функция транзакции обновления SKPaymentQueue не отвечает

Question

Я реализовал покупки в приложении для автообновляемых подписок в своем приложении, но я пытаюсь реализовать что-то после завершения покупки.

Ниже мой сервис подписки для IAP

class SubscriptionService: NSObject {


static let sessionIdSetNotification = Notification.Name("SubscriptionServiceSessionIdSetNotification")
static let optionsLoadedNotification = Notification.Name("SubscriptionServiceOptionsLoadedNotification")
static let restoreSuccessfulNotification = Notification.Name("SubscriptionServiceRestoreSuccessfulNotification")
static let purchaseSuccessfulNotification = Notification.Name("SubscriptionServiceRestoreSuccessfulNotification")

static let shared = SubscriptionService()

private var purchasedProductIdentifiers: Set<ProductIdentifier> = []

var productDidPurchased: (() -> Void)?

var hasReceiptData: Bool {
    return loadReceipt() != nil
}

var options: [Subscription]? {
    didSet {
        NotificationCenter.default.post(name: SubscriptionService.optionsLoadedNotification, object: options)
    }
}

func loadSubscriptionOptions() {

    let products: Set = ["productIDS"]

    let request = SKProductsRequest(productIdentifiers: products)
    request.delegate = self
    request.start()
}

func uploadReceipt(completion: ((_ success: Bool) -> Void)? = nil) {
    if let receiptData = loadReceipt() {

    }
}

private func loadReceipt() -> Data? {
    guard let url = Bundle.main.appStoreReceiptURL else {
        return nil
    }

    do {
        let data = try Data(contentsOf: url)
        return data
    } catch {
        print("Error loading receipt data: \(error.localizedDescription)")
        return nil
    }
}

func purchase(subscription: Subscription) {
    let payment = SKPayment(product: subscription.product)
    print("Product being bought: \(payment)")
    SKPaymentQueue.default().add(payment)
}

func restorePurchases() {
    SKPaymentQueue.default().restoreCompletedTransactions()
}
 }

 extension SubscriptionService: SKProductsRequestDelegate {
func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
    options = response.products.map { Subscription(product: $0) }
    print("in here 1")
    print(options!)
   // let purchased = UserDefaults.standard.bool(forKey: "com.mylawnow.sub.allaccess")
    //print("Purchased\(purchased)")
    print("in here 2")
}

func request(_ request: SKRequest, didFailWithError error: Error) {
    if request is SKProductsRequest {
        print("Subscription Options Failed Loading: \(error.localizedDescription)")
    }
}
}

// --------------------------------------------- ----------------

Эта часть, похоже, не работает. Кажется, что ни одна из функций не срабатывает (я реализовал операторы print, чтобы увидеть, были ли они когда-нибудь нажаты, но, похоже, что они не срабатывали.)

extension SubscriptionService: SKPaymentTransactionObserver{

public func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
    print("updating")
    for transaction in transactions {
        switch (transaction.transactionState) {
        case .purchased:
            print("purchased made")
            complete(transaction: transaction)
            break
        case .failed:
            print("purchased failed")
            fail(transaction: transaction)
            break
        case .restored:
            print("restored")
            restore(transaction: transaction)
            break
        case .deferred:
            print("purchase deferred")
            break
        case .purchasing:
            print("purchase being made")
            break
        }
    }
}

Я предполагаю, что полная функция должна быть использована для выполнения определенных функций после того, как приобретено.

private func complete(transaction: SKPaymentTransaction) {
    print("completed...")
    deliverPurchaseNotificationFor(identifier: transaction.payment.productIdentifier)
    SKPaymentQueue.default().finishTransaction(transaction)
}

private func restore(transaction: SKPaymentTransaction) {
    guard let productIdentifier = transaction.original?.payment.productIdentifier else { return }

    deliverPurchaseNotificationFor(identifier: productIdentifier)
    print("identifier: \(productIdentifier)")
    SKPaymentQueue.default().finishTransaction(transaction)
}

private func fail(transaction: SKPaymentTransaction) {
    print("failed...")
    if let transactionError = transaction.error as NSError?,
        let localizedDescription = transaction.error?.localizedDescription,
        transactionError.code != SKError.paymentCancelled.rawValue {
        print("Transaction Error: \(localizedDescription)")
    }

    SKPaymentQueue.default().finishTransaction(transaction)
}

private func deliverPurchaseNotificationFor(identifier: String?) {
    guard let identifier = identifier else { return }

   purchasedProductIdentifiers.insert(identifier)
   UserDefaults.standard.set(true, forKey: identifier)
   NotificationCenter.default.post(name: .IAPHelperPurchaseNotification, object: identifier)
}

}

Answer 1

Итак, я нашел ошибку. В моей функции loadSubscription мне нужно было добавить наблюдателя в SKPaymentQueue. Так и должно быть, как показано ниже:

func loadSubscriptionOptions() {
    let products: Set = ["productIDS"]

    let request = SKProductsRequest(productIdentifiers: products)
    request.delegate = self
    request.start()
     SKPaymentQueue.default().add(self) //--> this line is needed
}