如何在iOS 11中处理应用内购买的应用商店付款？

这是我所做的一个可以帮助你实现你想要的类,只需复制下面的代码并将其粘贴到一个新文件中,然后你可以简单地访问类StoreManager.shared到你想要访问的任何方法/变量.

1-要初始化此类,只需从didFinishLaunchingWithOptions调用即可@H_301_13@StoreManager.shared.begin()然后添加付款观察员.

import Foundation
import StoreKit


class StoreManager: NSObject{



    /**
     Initialize StoreManager and load subscriptions SKProducts from Store
     */
    static let shared = StoreManager()

    func Begin(){
        print("StoreManager initialized"))
    }


    override init() {
        super.init()


        // Add pyament observer to payment qu
        SKPaymentQueue.default().add(self)


    }


    func requestProductWithID(identifers:Set<String>){

        if SKPaymentQueue.canMakePayments() {
            let request = SKProductsrequest(productIdentifiers:
                identifers)
            request.delegate = self
            request.start()


        } else {
            print("ERROR: Store Not Available")
        }


    }

    func buyProduct(product: SKProduct) {

        print("Buying \(product.productIdentifier)...")
        let payment = SKPayment(product: product)
        SKPaymentQueue.default().add(payment)


    }


    func restorePurchases(){

        SKPaymentQueue.default().restoreCompletedtransactions()
    }
    /*
     Instance variables

     */

}








// MARK:
// MARK: SKProductsrequestDelegate

//The delegate receives the product information that the request was interested in.
extension StoreManager:SKProductsrequestDelegate{

    func productsrequest(_ request: SKProductsrequest,didReceive response: SKProductsResponsE) {

        var products = response.products as [SKProduct]


        var buys = [SKProduct]()

        if (products.count > 0) {

            for i in 0 ..< products.count
            {
                let product = products[i]


                print("Product Found: ",product.localizedtitlE)
            }


        } else {
            print("No products found")
        }

        let productsInvalidIds = response.invalidProductIdentifiers

        for product in productsInvalidIds
        {
            print("Product not found: \(product)")
        }
    }


    func request(_ request: SKrequest,didFailWithError error: Error) {
        print("Something went wrong: \(error.localizedDescription)")
    }
}



// MARK:
// MARK: SKtransactions


extension StoreManager: SKPaymenttransactionObserver {



    public func paymentQueue(_ queue: SKPaymentQueue,updatedtransactions transactions: [SKPaymenttransaction]) {
        for transaction in transactions {
            switch (transaction.transactionStatE) {
            case .purchased:
                completetransaction(transaction: transaction)
                break
            case .Failed:
                Failedtransaction(transaction: transaction)
                break
            case .restored:
                restoretransaction(transaction: transaction)
                break
            case .deferred:
                // TODO show user that is waiTing for approval

                break
            case .purchasing:
                break
            }
        }
    }

    private func completetransaction(transaction: SKPaymenttransaction) {

        print("completetransaction...")

        deliverPurchaseForIdentifier(identifier: transaction.payment.productIdentifier)
        SKPaymentQueue.default().finishtransaction(transaction)
    }

    private func restoretransaction(transaction: SKPaymenttransaction) {


        guard let productIdentifier = transaction.original?.payment.productIdentifier else { return }

        print("restoretransaction... \(productIdentifier)")


        deliverPurchaseForIdentifier(identifier: productIdentifier)
        SKPaymentQueue.default().finishtransaction(transaction)
    }

    private func Failedtransaction(transaction: SKPaymenttransaction) {

        if let error = transaction.error as NSError? {
            if error.domain == SKErrorDomain {
                // handle all possible errors
                switch (error.codE) {
                case SKError.unkNown.rawValue:
                    print("UnkNown error")

                case SKError.clienTinvalid.rawValue:
                    print("client is not allowed to issue the request")


                case SKError.paymentCancelled.rawValue:
                    print("user cancelled the request")

                case SKError.paymenTinvalid.rawValue:
                    print("purchase identifier was invalid")

                case SKError.paymentNotAllowed.rawValue:
                    print("this device is not allowed to make the payment")

                default:
                    break;
                }
            }


        }

        SKPaymentQueue.default().finishtransaction(transaction)
    }

    private func deliverPurchaseForIdentifier(identifier: String?) {

        guard let identifier = identifier else { return }


    }
}



//in-app Purchases App Store
extension StoreManager{

    func paymentQueue(_ queue: SKPaymentQueue,shouldAddStorePayment payment: SKPayment,for product: SKProduct) -> Bool {
        return true

        //To hold
        //return false

        //and then to conTinue
        //SKPaymentQueue.default().add(savedPayment)
    }

}