IAP autoRenewable subscriptions, SKPaymentQueue update transaction function is not responding - ios

Question

I have implemented in app purchases for auto renewable subscriptions in my app, but I am trying to implement something once a purchased has been completed.
Below is my SubscriptionService for the IAPs
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)")
}
}
}
//-------------------------------------------------------------
This is the part that does not seem to be working. None of the functions seem to be firing (I have implemented print statements to see if they are ever hit, but they don't seem to be.)
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
}
}
}
I am assuming that the complete function should be used to do certain functionality once the purchased is made.
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

So I found the error. In my loadSubscriptions function, I needed to app an observer to the SKPaymentQueue. So it should be like below:
func loadSubscriptionOptions() {
let products: Set = ["productIDS"]
let request = SKProductsRequest(productIdentifiers: products)
request.delegate = self
request.start()
SKPaymentQueue.default().add(self) //--> this line is needed
}