版本记录

前言

大家都知道，iOS虚拟商品如宝石、金币等都需要走内购，和苹果三七分成，如果这类商品不走内购那么上不去架或者上架以后被发现而被下架。最近有一个项目需要增加内购支付功能，所以最近又重新集成并整理了下，希望对大家有所帮助。感兴趣的可以参考上面几篇。
1. iOS内购IAP（一） —— 基础配置篇(一)
2. iOS内购IAP（二） —— 工程实践（一）
3. iOS内购IAP（三） —— 编程指南之关于内购（一）
4. iOS内购IAP（四） —— 编程指南之设计您的应用程序的产品（一）
5. iOS内购IAP（五） —— 编程指南之检索产品信息（一）
6. iOS内购IAP（六） —— 编程指南之请求支付（一）
7. iOS内购IAP（七） —— 编程指南之促进应用内购买（一）
8. iOS内购IAP（八） —— 编程指南之提供产品（一）
9. iOS内购IAP（九） —— 编程指南之处理订阅（一）
10. iOS内购IAP（十） —— 编程指南之恢复购买的产品（一）
11. iOS内购IAP（十一） —— 编程指南之准备App审核（一）
12. iOS内购IAP（十二） —— 一个详细的内购流程（一）

Project Configuration - 工程配置

为了使一切正常工作，应用程序中的bundle identifier和product identifiers与您在Developer Center和App Store Connect中创建的标识符和产品标识符相匹配非常重要。

回到Xcode中，在Project导航器中选择RazeFaces项目，然后在Targets下再次选择它。 选择General选项卡，将您的Team切换到正确的团队，然后输入您之前使用的bundle ID。

接下来选择Capabilities选项卡。 向下滚动到In-App Purchase并将开关切换到ON。

注意：如果IAP未显示在列表中，请确保在Xcode
preferences的Accounts部分中使用您用于创建应用程序ID的Apple ID登录。

打开RazeFaceProducts.swift。 请注意，您创建的IAP产品有一个占位符引用：SwiftShopping。 将其替换为您在App Store Connect中配置的完整Product ID - 例如：

public static let SwiftShopping = "com.theNameYouPickedEarlier.razefaces.swiftshopping"

注意：可以从Web服务器中提取产品标识符列表，以便可以动态添加新的IAP，而不需要更新应用程序。 本教程简单易用，使用硬编码的产品标识符。

Listing In-App Purchases - IAP列表

RazeFaceProducts的store属性是IAPHelper的一个实例。 如前所述，此对象与StoreKit API交互以列出和执行购买。 您的第一个任务是更新IAPHelper以检索IAP列表 - 目前只有一个 - 来自Apple的服务器。

打开IAPHelper.swift。 在该类的顶部，添加以下私有属性：

private let productIdentifiers: Set<ProductIdentifier>

接下来，在调用super.init（）之前将以下内容添加到init（productIds :)：

productIdentifiers = productIds

通过传入一组产品标识符来创建IAPHelper实例。 这就是RazeFaceProducts创建其store实例的方式。

接下来，在刚才添加的那个下添加其他私有属性：

private var purchasedProductIdentifiers: Set<ProductIdentifier> = []
private var productsRequest: SKProductsRequest?
private var productsRequestCompletionHandler: ProductsRequestCompletionHandler?

purchaseProductIdentifiers跟踪已购买的商品。 SKProductsRequest委托使用其他两个属性来执行对Apple服务器的请求。

接下来，仍然在IAPHelper.swift中用以下代码替换requestProducts（_ :)的实现：

public func requestProducts(completionHandler: @escaping ProductsRequestCompletionHandler) {
  productsRequest?.cancel()
  productsRequestCompletionHandler = completionHandler

  productsRequest = SKProductsRequest(productIdentifiers: productIdentifiers)
  productsRequest!.delegate = self
  productsRequest!.start()
}

此代码保存用户的完成处理程序以供将来执行。 然后，它通过SKProductsRequest对象创建并向Apple发起请求。 有一个问题：代码将IAPHelper声明为请求的代理，但它还不遵守SKProductsRequestDelegate协议。

要解决此问题，请在最后一个大括号之后将以下扩展名添加到IAPHelper.swift的最后：

// MARK: - SKProductsRequestDelegate

extension IAPHelper: SKProductsRequestDelegate {

  public func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
    print("Loaded list of products...")
    let products = response.products
    productsRequestCompletionHandler?(true, products)
    clearRequestAndHandler()

    for p in products {
      print("Found product: \(p.productIdentifier) \(p.localizedTitle) \(p.price.floatValue)")
    }
  }
  
  public func request(_ request: SKRequest, didFailWithError error: Error) {
    print("Failed to load list of products.")
    print("Error: \(error.localizedDescription)")
    productsRequestCompletionHandler?(false, nil)
    clearRequestAndHandler()
  }

  private func clearRequestAndHandler() {
    productsRequest = nil
    productsRequestCompletionHandler = nil
  }
}

此扩展用于通过实现SKProductsRequestDelegate协议所需的两种方法从Apple服务器获取产品列表，标题，描述和价格。

成功检索列表时调用productsRequest（_：didReceive :)。 它接收一组SKProduct对象并将它们传递给先前保存的完成处理程序。 处理程序使用新数据重新加载表。 如果出现问题，则调用request（_：didFailWithError :)。 在任何一种情况下，当请求完成时，请求和完成处理程序都将使用clearRequestAndHandler（）清除。

Build并运行。table view中显示了产品列表（目前只有一个）！ 这需要一些工作，但还是实现了。

注意：您可以在iOS模拟器和物理iOS设备上显示IAP产品，但如果您要测试购买或恢复购买，则只能在物理设备上执行此操作。 更多相关信息，请参阅下面的购买部分。

注意：如果运行不成功且您没有看到任何产品，那么有很多事情需要检查。

• 项目的Bundle ID是否与iOS Development Center的App ID相匹配？
• 在制作SKProductRequest时是否使用完整的product ID？ （检查RazeFaceProducts的productIdentifiers属性。）
• Paid Applications Contract是否对iTunes Connect有效？他们提交申请的时间可能需要数小时到数天才能从待定到接受。
• 自从将产品添加到App Store Connect后，您有几个小时的时间吗？产品添加可能会立即生效或可能需要一些时间。
• 检查Apple Developer System Status。或者，尝试此链接this link。如果它没有响应状态值，则iTunes沙盒可能已关闭。 Apple的 Validating Receipts With the App Store文档中说明了状态代码。
• 是否为App ID启用了IAP？ （你之前选择过Cleared for Sale吗？）
• 您是否尝试从设备中删除该应用并重新安装？

Purchased Items - 购买项目

您希望能够确定已购买的商品。 为此，您将使用之前添加的purchaseProductIdentifiers属性。 如果此集合中包含产品标识符，则用户已购买该项目。 检查这个的方法很简单。

在IAPHelper.swift中，使用以下内容替换isProductPurchased（_ :)中的return语句：

return purchasedProductIdentifiers.contains(productIdentifier)

在本地保存购买状态可以减少每次应用启动时向Apple服务器请求此类数据的需求。 purchaseProductIdentifiers使用UserDefaults保存。

仍在IAPHelper.swift中，将init（productIds :)替换为以下内容：

public init(productIds: Set<ProductIdentifier>) {
  productIdentifiers = productIds
  for productIdentifier in productIds {
    let purchased = UserDefaults.standard.bool(forKey: productIdentifier)
    if purchased {
      purchasedProductIdentifiers.insert(productIdentifier)
      print("Previously purchased: \(productIdentifier)")
    } else {
      print("Not purchased: \(productIdentifier)")
    }
  }
  super.init()
}

对于每个产品标识符，检查该值是否存储在UserDefaults中。 如果是，则将标识符插入到purchaseProductIdentifiers的set中。 之后，您将在购买后向set中添加标识符。

注意：User defaults可能不是在实际应用程序中存储有关已购买产品的信息的最佳位置。 越狱设备的所有者可以轻松访问您应用的UserDefaults plist，并将其修改为unlock购买。 如果这种事情与您有关，那么值得查看Apple关于Validating App Store Receipts的文档 - 这可以让您验证用户是否进行了特定购买。

Making Purchases (Show Me The Money!) - 进行购买

可以了解用户购买的产品很好，但您仍然需要首先进行购买！ 实施购买能力是合乎逻辑的下一步。

仍然在IAPHelper.swift中，用以下内容替换buyProduct（_ :)：

public func buyProduct(_ product: SKProduct) {
  print("Buying \(product.productIdentifier)...")
  let payment = SKPayment(product: product)
  SKPaymentQueue.default().add(payment)
}

这将使用SKProduct（从Apple服务器检索）创建支付对象以添加到支付队列。 该代码使用名为default（）的单例SKPaymentQueue对象。钱在银行里。 不是吗？ 你怎么知道付款是否通过？

通过让IAPHelper观察SKPaymentQueue上发生的交易来实现付款验证。 在将IAPHelper设置为SKPaymentQueue交易观察器之前，该类必须遵循SKPaymentTransactionObserver协议。

转到IAPHelper.swift的最底部（在最后一个大括号之后）并添加以下扩展名：

// MARK: - SKPaymentTransactionObserver
 
extension IAPHelper: SKPaymentTransactionObserver {
 
  public func paymentQueue(_ queue: SKPaymentQueue, 
                           updatedTransactions transactions: [SKPaymentTransaction]) {
    for transaction in transactions {
      switch transaction.transactionState {
      case .purchased:
        complete(transaction: transaction)
        break
      case .failed:
        fail(transaction: transaction)
        break
      case .restored:
        restore(transaction: transaction)
        break
      case .deferred:
        break
      case .purchasing:
        break
      }
    }
  }
 
  private func complete(transaction: SKPaymentTransaction) {
    print("complete...")
    deliverPurchaseNotificationFor(identifier: transaction.payment.productIdentifier)
    SKPaymentQueue.default().finishTransaction(transaction)
  }
 
  private func restore(transaction: SKPaymentTransaction) {
    guard let productIdentifier = transaction.original?.payment.productIdentifier else { return }
 
    print("restore... \(productIdentifier)")
    deliverPurchaseNotificationFor(identifier: productIdentifier)
    SKPaymentQueue.default().finishTransaction(transaction)
  }
 
  private func fail(transaction: SKPaymentTransaction) {
    print("fail...")
    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)
  }
}

这是很多代码！ 详细的审查是有序的。 幸运的是，每种方法都很短。

paymentQueue（_：updatedTransactions :)是协议实际需要的唯一方法。 当一个或多个交易状态发生变化时，它会被调用。 此方法评估更新交易数组中每个交易的状态，并调用相关的帮助方法：complete(transaction:)，restore(transaction:)或fail(transaction:)。

如果交易已完成或已恢复，则会将其添加到购买set中并将标识符保存在UserDefaults中。 它还会在该事务中发布通知，以便应用程序中的任何感兴趣的对象都可以监听它以执行更新用户界面等操作。 最后，在成功或失败的情况下，它将交易标记为已完成。

剩下的就是将IAPHelper作为支付交易观察者。 仍然在IAPHelper.swift中，返回init（productIds :)并在super.init（）之后添加以下行。

SKPaymentQueue.default().add(self)

Making a Sandbox Purchase - 进行沙盒购买

Build并运行应用程序 - 但要测试购买，您必须在设备上运行它。 之前创建的沙箱测试仪可用于执行购买而无需收费。以下是如何使用测试人员帐户：

转到您的iPhone并确保您已退出正常的App Store帐户。 要执行此操作，请转到Settings应用，然后点按iTunes & App Store。

点按您的iCloud帐户名称，然后点按Sign Out。 此时，实际上并未使用沙箱用户登录。 一旦您尝试在示例应用程序中购买IAP，系统将提示您执行此操作。

连接您的设备，Build并运行！ 您会在应用中看到您的产品。 要开始购买，请点按Buy按钮。

将出现一个提示您登录的弹窗。点击Use Existing Apple ID，然后输入您之前创建的沙箱测试人员帐户的登录详细信息。

点按Buy确认购买。 弹窗视图显示正在沙盒中进行购买，以提醒您不会向您收取费用。

最后，将出现一个弹窗视图，确认购买成功。 购买过程完成后，购买项目旁边会出现一个复选标记。 点击purchased item即可享受新的RazeFace。

最后你会看到这个Swift Shopping RazeFace。

Restoring Purchases - 恢复购买

如果用户删除并重新安装应用程序或将其安装在其他设备上，则他们需要能够访问以前购买的项目。 事实上，如果App无法恢复非消费品购买，Apple可能会拒绝该应用。

作为购买交易观察者，IAPHelper已经在恢复购买时得到通知。 下一步是通过恢复购买来对此通知做出反应。

打开IAPHelper.swift并滚动到文件的底部。 在StoreKit API extension中，将restorePurchases（）替换为以下内容：

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

那太简单了！ 您已经设置了事务观察器并实现了方法来处理上一步中的恢复事务。

要对此进行测试，请在上一步中完成购买后，从设备中删除该应用。 再次构建并运行，然后点击右上角的Restore。 您应该会在先前购买的产品旁边看到复选标记。

Payment Permissions - 支付许可

某些设备和帐户可能不允许进行应用内购买。 例如，如果将父级控件设置为禁止它，则会发生这种情况。 Apple要求优雅地处理这种情况。 不这样做可能会导致应用拒绝。

再次打开IAPHelper.swift。 在StoreKit API extension中，将canMakePayments（）中的return语句替换为以下行：

return SKPaymentQueue.canMakePayments()

根据canMakePayments（）返回的值，产品单元的行为应该不同。 例如，如果canMakePayments（）返回false，则不应显示Buy按钮，并且应将价格替换为Not Available。

要完成此任务，请打开ProductCell.swift并使用以下内容替换product属性的didSet处理程序的整个实现：

didSet {
  guard let product = product else { return }
 
  textLabel?.text = product.localizedTitle
 
  if RazeFaceProducts.store.isProductPurchased(product.productIdentifier) {
    accessoryType = .checkmark
    accessoryView = nil
    detailTextLabel?.text = ""
  } else if IAPHelper.canMakePayments() {
    ProductCell.priceFormatter.locale = product.priceLocale
    detailTextLabel?.text = ProductCell.priceFormatter.string(from: product.price)
 
    accessoryType = .none
    accessoryView = self.newBuyButton()
  } else {
    detailTextLabel?.text = "Not available"
  }
}

当无法使用设备付款时，此实施将显示更合适的信息。

Apple有一个很棒的页面讲述In-App Purchase for Developers：面向开发人员的应用内购买。 它汇集了所有相关文档和WWDC视频的链接。

IAP可以成为您业务模式的重要组成部分。 明智地使用它们并确保遵循有关恢复购买和优雅处理失败的指导方针，您将走向成功的道路！

源码

下面给出Swift版本的源码。

1. IAPHelper.swift

import StoreKit

public typealias ProductIdentifier = String
public typealias ProductsRequestCompletionHandler = (_ success: Bool, _ products: [SKProduct]?) -> Void

extension Notification.Name {
  static let IAPHelperPurchaseNotification = Notification.Name("IAPHelperPurchaseNotification")
}

open class IAPHelper: NSObject  {
  
  private let productIdentifiers: Set<ProductIdentifier>
  private var purchasedProductIdentifiers: Set<ProductIdentifier> = []
  private var productsRequest: SKProductsRequest?
  private var productsRequestCompletionHandler: ProductsRequestCompletionHandler?
  
  public init(productIds: Set<ProductIdentifier>) {
    productIdentifiers = productIds
    for productIdentifier in productIds {
      let purchased = UserDefaults.standard.bool(forKey: productIdentifier)
      if purchased {
        purchasedProductIdentifiers.insert(productIdentifier)
        print("Previously purchased: \(productIdentifier)")
      } else {
        print("Not purchased: \(productIdentifier)")
      }
    }
    super.init()

    SKPaymentQueue.default().add(self)
  }
}

// MARK: - StoreKit API

extension IAPHelper {
  
  public func requestProducts(_ completionHandler: @escaping ProductsRequestCompletionHandler) {
    productsRequest?.cancel()
    productsRequestCompletionHandler = completionHandler

    productsRequest = SKProductsRequest(productIdentifiers: productIdentifiers)
    productsRequest!.delegate = self
    productsRequest!.start()
  }

  public func buyProduct(_ product: SKProduct) {
    print("Buying \(product.productIdentifier)...")
    let payment = SKPayment(product: product)
    SKPaymentQueue.default().add(payment)
  }

  public func isProductPurchased(_ productIdentifier: ProductIdentifier) -> Bool {
    return purchasedProductIdentifiers.contains(productIdentifier)
  }
  
  public class func canMakePayments() -> Bool {
    return SKPaymentQueue.canMakePayments()
  }
  
  public func restorePurchases() {
    SKPaymentQueue.default().restoreCompletedTransactions()
  }
}

// MARK: - SKProductsRequestDelegate

extension IAPHelper: SKProductsRequestDelegate {

  public func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
    print("Loaded list of products...")
    let products = response.products
    productsRequestCompletionHandler?(true, products)
    clearRequestAndHandler()

    for p in products {
      print("Found product: \(p.productIdentifier) \(p.localizedTitle) \(p.price.floatValue)")
    }
  }

  public func request(_ request: SKRequest, didFailWithError error: Error) {
    print("Failed to load list of products.")
    print("Error: \(error.localizedDescription)")
    productsRequestCompletionHandler?(false, nil)
    clearRequestAndHandler()
  }

  private func clearRequestAndHandler() {
    productsRequest = nil
    productsRequestCompletionHandler = nil
  }
}

// MARK: - SKPaymentTransactionObserver

extension IAPHelper: SKPaymentTransactionObserver {

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

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

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

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

  private func fail(transaction: SKPaymentTransaction) {
    print("fail...")
    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)
  }
}

2. RazeFaceProducts.swift

import Foundation

public struct RazeFaceProducts {
  
  public static let SwiftShopping = "com.razeware.razefaces.swiftshopping"
  
  private static let productIdentifiers: Set<ProductIdentifier> = [RazeFaceProducts.SwiftShopping]

  public static let store = IAPHelper(productIds: RazeFaceProducts.productIdentifiers)
}

func resourceNameForProductIdentifier(_ productIdentifier: String) -> String? {
  return productIdentifier.components(separatedBy: ".").last
}

3. MasterViewController.swift

import UIKit
import StoreKit

class MasterViewController: UITableViewController {
  
  let showDetailSegueIdentifier = "showDetail"
  
  var products: [SKProduct] = []
  
  override func shouldPerformSegue(withIdentifier identifier: String, sender: Any?) -> Bool {
    if identifier == showDetailSegueIdentifier {
      guard let indexPath = tableView.indexPathForSelectedRow else {
        return false
      }
      
      let product = products[(indexPath as NSIndexPath).row]
      
      return RazeFaceProducts.store.isProductPurchased(product.productIdentifier)
    }
    
    return true
  }

  override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if segue.identifier == showDetailSegueIdentifier {
      guard let indexPath = tableView.indexPathForSelectedRow else { return }
      
      let product = products[(indexPath as NSIndexPath).row]
      
      if let name = resourceNameForProductIdentifier(product.productIdentifier),
             let detailViewController = segue.destination as? DetailViewController {
        let image = UIImage(named: name)
        detailViewController.image = image
      }
    }
  }

  override func viewDidLoad() {
    super.viewDidLoad()
    
    title = "RazeFaces"
    
    refreshControl = UIRefreshControl()
    refreshControl?.addTarget(self, action: #selector(MasterViewController.reload), for: .valueChanged)
    
    let restoreButton = UIBarButtonItem(title: "Restore",
                                        style: .plain,
                                        target: self,
                                        action: #selector(MasterViewController.restoreTapped(_:)))
    navigationItem.rightBarButtonItem = restoreButton
    
    NotificationCenter.default.addObserver(self, selector: #selector(MasterViewController.handlePurchaseNotification(_:)),
                                           name: .IAPHelperPurchaseNotification,
                                           object: nil)
  }
  
  override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    reload()
  }
  
  @objc func reload() {
    products = []
    
    tableView.reloadData()
    
    RazeFaceProducts.store.requestProducts{ [weak self] success, products in
      guard let self = self else { return }
      if success {
        self.products = products!
        
        self.tableView.reloadData()
      }
      
      self.refreshControl?.endRefreshing()
    }
  }
  
  @objc func restoreTapped(_ sender: AnyObject) {
    RazeFaceProducts.store.restorePurchases()
  }

  @objc func handlePurchaseNotification(_ notification: Notification) {
    guard
      let productID = notification.object as? String,
      let index = products.index(where: { product -> Bool in
        product.productIdentifier == productID
      })
    else { return }

    tableView.reloadRows(at: [IndexPath(row: index, section: 0)], with: .fade)
  }
}

// MARK: - UITableViewDataSource

extension MasterViewController {
  
  override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return products.count
  }

  override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) as! ProductCell
    
    let product = products[(indexPath as NSIndexPath).row]
    
    cell.product = product
    cell.buyButtonHandler = { product in
      RazeFaceProducts.store.buyProduct(product)
    }
    
    return cell
  }
}

4. DetailViewController.swift

import UIKit

class DetailViewController: UIViewController {
  
  @IBOutlet weak var imageView: UIImageView?
  
  var image: UIImage? {
    didSet {
      configureView()
    }
  }
  
  override func viewDidLoad() {
    super.viewDidLoad()
    
    configureView()
  }
  
  func configureView() {
    imageView?.image = image
  }
}

5. ProductCell.swift

import UIKit
import StoreKit

class ProductCell: UITableViewCell {
  static let priceFormatter: NumberFormatter = {
    let formatter = NumberFormatter()
    
    formatter.formatterBehavior = .behavior10_4
    formatter.numberStyle = .currency
    
    return formatter
  }()
  
  var buyButtonHandler: ((_ product: SKProduct) -> Void)?
  
  var product: SKProduct? {
    didSet {
      guard let product = product else { return }

      textLabel?.text = product.localizedTitle

      if RazeFaceProducts.store.isProductPurchased(product.productIdentifier) {
        accessoryType = .checkmark
        accessoryView = nil
        detailTextLabel?.text = ""
      } else if IAPHelper.canMakePayments() {
        ProductCell.priceFormatter.locale = product.priceLocale
        detailTextLabel?.text = ProductCell.priceFormatter.string(from: product.price)

        accessoryType = .none
        accessoryView = self.newBuyButton()
      } else {
        detailTextLabel?.text = "Not available"
      }
    }
  }
  
  override func prepareForReuse() {
    super.prepareForReuse()
    
    textLabel?.text = ""
    detailTextLabel?.text = ""
    accessoryView = nil
  }
  
  func newBuyButton() -> UIButton {
    let button = UIButton(type: .system)
    button.setTitleColor(tintColor, for: .normal)
    button.setTitle("Buy", for: .normal)
    button.addTarget(self, action: #selector(ProductCell.buyButtonTapped(_:)), for: .touchUpInside)
    button.sizeToFit()
    
    return button
  }
  
  @objc func buyButtonTapped(_ sender: AnyObject) {
    buyButtonHandler?(product!)
  }
}

后记

本篇主要讲述了一个详细的内购流程，感兴趣的给个赞或者关注~~~