Ios 取消订阅后，用户仍然可以访问应用程序

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

以下是我的代码片段：

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)
}

override func viewDidLoad（）{
super.viewDidLoad（）
if（SKPaymentQueue.canMakePayments（））{
打印（“IAP已启用，正在加载”）
让productID:NSSet=NSSet（对象：“Seb.DiPlus.RenewingSubMonthAuto”、“Seb.DiPlus.RenewingSubYearAuto”）
let请求：SKProductsRequest=SKProductsRequest（产品标识符：productID as！Set）
request.delegate=self
request.start（）
}否则{
打印（“请启用IAPS”）
}
}
@iAction func subscribeMonth（\发送方：任意）{
对于列表中的产品{
让prodID=product.productIdentifier
if（prodID==“Seb.DiPlus.renewangsubmonthauto”）{
p=产品
购买产品（）
}
}
}
@iAction func subscribeear（uu发送方：任意）{
对于列表中的产品{
让prodID=product.productIdentifier
if（prodID==“Seb.DiPlus.RenewingSubYearAuto”）{
p=产品
购买产品（）
}
}
}
@iAction func restoreComplete（\uSender:ui按钮）{
恢复采购（）
}
@iAction func退出（\发送方：任何）{
_出口（0）
}
func restorepources（）{
如果SKPaymentQueue.canMakePayments（）{
打印（“恢复完成”）
SKPaymentQueue.default（）.add（self）
SKPaymentQueue.default（）.restoreCompletedTransactions（）
}
否则{
打印（“恢复失败，IAP未激活？”）
}
}
func buydroduct（）{
打印（“购买”+p.productIdentifier）
let pay=SKPayment（产品：p）
SKPaymentQueue.default（）.add（self）
SKPaymentQueue.default（）.add（按SKPayment付款）
}
func productsRequest（uRequest:SKProductsRequest，didReceive response:SKProductsResponse）{
打印（“产品请求”）
让myProduct=response.products
对于myProduct中的产品{
打印（“添加产品”）
打印（product.productIdentifier）
打印（产品本地化标题）
打印（产品本地化说明）
印刷品（产品价格）
列表.附加（产品）
}
}
func paymentQueueRestoreCompletedTransactionsFinished（队列：SKPaymentQueue）{
打印（“恢复的交易”）
对于queue.transactions中的事务{
设t:SKPaymentTransaction=transaction
将prodID=t.payment.productIdentifier设为字符串
开关prodID{
案例“Seb.DiPlus.续订Submonthauto”：
打印（“订阅月份！”）
如果abo<1{
准备订阅（）
}
abo=1
打破
案例“Seb.DiPlus.RenewingSubYearAuto”：
打印（“订阅年份！”）
如果abo<1{
准备订阅（）
}
abo=1
打破
违约：
打印（“未找到IAP”）
}
}
}
func paymentQueue（queue:SKPaymentQueue，updatedTransactions事务：[SKPaymentTransaction]）{
打印（“添加付款”）
对于事务：事务中的任何对象{
let trans=事务处理为！SKPaymentTransaction
打印（“错误：”，传输错误）
开关trans.transactionState{
案例。购买：
打印（“购买确定，在此处解锁IAP”）
打印（p.productIdentifier）
设prodID=p.productIdentifier
开关prodID{
案例“Seb.DiPlus.续订Submonthauto”：
打印（“订阅月份！！”）
如果abo<1{
准备订阅（）
}
abo=1
打破
案例“Seb.DiPlus.RenewingSubYearAuto”：
打印（“订阅年份！！”）
如果abo<1{
准备订阅（）
}
abo=1
打破
违约：
打印（“未找到IAP”）
}
queue.finishTransaction（trans）
案例。失败：
打印（“购买错误”）
警报（标题：“错误”，消息：trans.ERROR？.localizedDescription）
queue.finishTransaction（trans）
打破
违约：
打印（“默认”）
打破
}
}
}
func readySubscribe（）{
UserDefaults.standard.setValue（选中subscribe，forKeyPath:“subscribe”）
UserDefaults.standard.synchronize（）
self.performsgue（带有标识符：“readySubscribe”，发送者：self）
}
func警报（标题：字符串，消息：字符串？）{
let alert=UIAlertController（标题：标题，消息：消息，首选样式：UIAlertControllerStyle.alert）
addAction（UIAlertAction）（标题：“确定”，样式：UIAlertActionStyle.default，处理程序：{（操作）在
警报。解除（动画：真，完成：零）
}))
self.present（警报、动画：true、完成：nil）
}

一旦我点击恢复购买，即使订阅不再激活，你也可以继续使用该应用

---

因此，函数readySubscribe（）被调用。

您不应该在

paymentQueueRestoreCompletedTransactionsFinished

中激活任何购买。恢复过程完成时调用此函数。您可以使用它来更新UI或提醒用户

产品的实际恢复应在

paymentQueue（queue:SKPaymentQueue，updatedTransactions事务：[SKPaymentTransaction]）

函数中处理

还原的事务显示为

。还原的
。您应该像处理
.purchased
状态一样处理它们

由于您使用的是自动续费订阅IAP，因此您还需要检查收据上的到期日期，并为订阅续费时显示的新交易做好准备。因此，您的应用程序在使用选项启动时首先要做的事情之一是创建一个付款队列观察者。
感谢您的及时回复。