Question

我遇到的问题是，如果您尝试取消订阅，该应用程序将继续工作。

这是我的代码段：

override func viewDidLoad() {
    super.viewDidLoad()

    if(SKPaymentQueue.canMakePayments()) {
        print("IAP is enabled, loading")
        let productID: NSSet = NSSet(objects: "Seb.DiPlus.RenewingSubMonthAuto", "Seb.DiPlus.RenewingSubYearAuto")
        let request: SKProductsRequest = SKProductsRequest(productIdentifiers: productID as! Set<String>)
        request.delegate = self
        request.start()
    } else {
        print("please enable IAPS")
    }
}

@IBAction func subscribeMonth(_ sender: Any) {
    for product in list {
        let prodID = product.productIdentifier
        if(prodID == "Seb.DiPlus.RenewingSubMonthAuto") {
            p = product
            buyProduct()
        }
    }
}

@IBAction func subscribeYear(_ sender: Any) {
    for product in list {
        let prodID = product.productIdentifier
        if(prodID == "Seb.DiPlus.RenewingSubYearAuto") {
            p = product
            buyProduct()
        }
    }
}

@IBAction func restoreComplete(_ sender: UIButton) {
    restorePurchases()
}

@IBAction func exit(_ sender: Any) {
    _exit(0)
}

func restorePurchases() {
    if SKPaymentQueue.canMakePayments(){
        print("restored complete")
        SKPaymentQueue.default().add(self)
        SKPaymentQueue.default().restoreCompletedTransactions()
    }
    else{
        print("restored faild, IAP not activ?")
    }
}

func buyProduct() {
    print("buy " + p.productIdentifier)
    let pay = SKPayment(product: p)
    SKPaymentQueue.default().add(self)
    SKPaymentQueue.default().add(pay as SKPayment)
}

func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
    print("product request")
    let myProduct = response.products
    for product in myProduct {
        print("product added")
        print(product.productIdentifier)
        print(product.localizedTitle)
        print(product.localizedDescription)
        print(product.price)

        list.append(product)
    }
}

func paymentQueueRestoreCompletedTransactionsFinished(_ queue: SKPaymentQueue) {
    print("transactions restored")
    for transaction in queue.transactions {
        let t: SKPaymentTransaction = transaction
        let prodID = t.payment.productIdentifier as String

        switch prodID {
        case "Seb.DiPlus.RenewingSubMonthAuto":
            print("Subscribe Month!")
            if abo < 1 {
                readySubscribe()
            }
            abo = 1
            break
        case "Seb.DiPlus.RenewingSubYearAuto":
            print("Subscribe Year!")
            if abo < 1 {
                readySubscribe()
            }
            abo = 1
            break
        default:
            print("IAP not found")
        }
    }
}

func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
    print("add payment")

    for transaction: AnyObject in transactions {
        let trans = transaction as! SKPaymentTransaction
        print("ERROR: ", trans.error)

        switch trans.transactionState {
        case .purchased:
            print("buy ok, unlock IAP HERE")
            print(p.productIdentifier)

            let prodID = p.productIdentifier
            switch prodID {
            case "Seb.DiPlus.RenewingSubMonthAuto":
                print("Subscribe Month!!")
                if abo < 1 {
                    readySubscribe()
                }
                abo = 1
                break
            case "Seb.DiPlus.RenewingSubYearAuto":
                print("Subscribe Year!!")
                if abo < 1 {
                    readySubscribe()
                }
                abo = 1
                break
            default:
                print("IAP not found")
            }
            queue.finishTransaction(trans)
        case .failed:
            print("buy error")
            alert(title: "ERROR", message: trans.error?.localizedDescription)
            queue.finishTransaction(trans)
            break
        default:
            print("Default")
            break
        }
    }
}

func readySubscribe()  {
    UserDefaults.standard.setValue(checkSubscribe, forKeyPath: "subscribe")
    UserDefaults.standard.synchronize()
    self.performSegue(withIdentifier: "readySubscribe", sender: self)

}

func alert (title:String, message:String?){

    let alert = UIAlertController(title: title, message: message, preferredStyle: UIAlertControllerStyle.alert)

    alert.addAction(UIAlertAction(title: "OK", style: UIAlertActionStyle.default, handler: { (action) in
        alert.dismiss(animated: true, completion: nil)
    }))

    self.present(alert, animated: true, completion: nil)
}

单击还原购买后，即使不再激活订阅，您也可以继续使用该应用。

因此调用了readySubscribe（）函数。

Answer 1

您不应在paymentQueueRestoreCompletedTransactionsFinished中激活任何购买。恢复过程完成后，将调用此函数。您可以使用它来更新用户界面或警告用户。

产品的实际恢复应在您的paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction])函数中处理。

恢复的事务显示为.restored状态。您应该像处理.purchased状态一样处理它们。

由于您使用的是自动续订的订阅IAP，因此您还需要从收据中检查到期日期，并准备好在续订时显示新交易。因此，您的应用在didFinishLaunchingWithOptions中要做的第一件事就是创建一个支付队列观察器。

取消订阅后，仍然允许用户访问应用

1 个答案: