iOS 内购购买逻辑代码封装代理 - Swift & Objective-C 示例 - 常规

以下是一个简单的 iOS 内购购买的逻辑代码封装代理的示例，分别使用 Swift 和 Objective-C 实现：

Objective-C 代码示例

首先，创建一个名为IAPManager的类，实现SKPaymentTransactionObserver和SKProductsRequestDelegate协议：

#import <Foundation/Foundation.h>
#import <StoreKit/StoreKit.h>

@protocol IAPManagerDelegate <NSObject>
- (void)didCompletePurchaseWithProductIdentifier:(NSString *)productIdentifier;
- (void)didFailPurchaseWithError:(NSError *)error;
@end

@interface IAPManager : NSObject <SKPaymentTransactionObserver, SKProductsRequestDelegate>

@property (nonatomic, weak) id<IAPManagerDelegate> delegate;

+ (instancetype)sharedManager;
- (void)startObservingTransactions;
- (void)stopObservingTransactions;
- (void)buyProductWithIdentifier:(NSString *)productIdentifier;
- (BOOL)canMakePayments;

@end

然后，在IAPManager.m文件中实现相应的方法：

#import "IAPManager.h"

@implementation IAPManager

+ (instancetype)sharedManager {
    static dispatch_once_t onceToken;
    static IAPManager *sharedManager;
    dispatch_once(&onceToken, ^{ 
        sharedManager = [[self alloc] init];
    });
    return sharedManager;
}

- (void)startObservingTransactions {
    [[SKPaymentQueue defaultQueue] addTransactionObserver:self];
}

- (void)stopObservingTransactions {
    [[SKPaymentQueue defaultQueue] removeTransactionObserver:self];
}

- (void)buyProductWithIdentifier:(NSString *)productIdentifier {
    if (![self canMakePayments]) {
        // 无法进行支付
        return;
    }
    
    SKProductsRequest *request = [[SKProductsRequest alloc] initWithProductIdentifiers:[NSSet setWithObject:productIdentifier]];
    request.delegate = self;
    [request start];
}

- (BOOL)canMakePayments {
    return [SKPaymentQueue canMakePayments];
}

#pragma mark - SKPaymentTransactionObserver

- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray<SKPaymentTransaction *> *)transactions {
    for (SKPaymentTransaction *transaction in transactions) {
        switch (transaction.transactionState) {
            case SKPaymentTransactionStatePurchased:
                // 购买成功
                [self completeTransaction:transaction];
                break;
            case SKPaymentTransactionStateFailed:
                // 购买失败
                [self failedTransaction:transaction];
                break;
            case SKPaymentTransactionStateRestored:
                // 已经购买过该商品
                [self restoreTransaction:transaction];
                break;
            default:
                break;
        }
    }
}

- (void)completeTransaction:(SKPaymentTransaction *)transaction {
    // 将购买成功的商品标记为完成
    [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
    
    if ([self.delegate respondsToSelector:@selector(didCompletePurchaseWithProductIdentifier:)]) {
        [self.delegate didCompletePurchaseWithProductIdentifier:transaction.payment.productIdentifier];
    }
}

- (void)failedTransaction:(SKPaymentTransaction *)transaction {
    if (transaction.error.code != SKErrorPaymentCancelled) {
        // 购买失败
        if ([self.delegate respondsToSelector:@selector(didFailPurchaseWithError:)]) {
            [self.delegate didFailPurchaseWithError:transaction.error];
        }
    }
    
    // 将购买失败的商品标记为完成
    [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
}

- (void)restoreTransaction:(SKPaymentTransaction *)transaction {
    // 恢复已经购买过的商品
    [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
}

#pragma mark - SKProductsRequestDelegate

- (void)productsRequest:(SKProductsRequest *)request didReceiveResponse:(SKProductsResponse *)response {
    NSArray<SKProduct *> *products = response.products;
    if (products.count > 0) {
        SKProduct *product = products.firstObject;
        SKPayment *payment = [SKPayment paymentWithProduct:product];
        [[SKPaymentQueue defaultQueue] addPayment:payment];
    }
}

@end

接下来，在你的使用内购的地方，设置IAPManager的代理，并实现相关的代理方法：

@interface YourViewController () <IAPManagerDelegate>

@property (nonatomic, strong) IAPManager *iapManager;

@end

@implementation YourViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.iapManager = [IAPManager sharedManager];
    self.iapManager.delegate = self;
}

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    
    [self.iapManager startObservingTransactions];
}

- (void)viewWillDisappear:(BOOL)animated {
    [super viewWillDisappear:animated];
    
    [self.iapManager stopObservingTransactions];
}

- (void)didCompletePurchaseWithProductIdentifier:(NSString *)productIdentifier {
    // 内购购买成功
    // 处理购买成功的逻辑
}

- (void)didFailPurchaseWithError:(NSError *)error {
    // 内购购买失败
    // 处理购买失败的逻辑
}

- (IBAction)buyButtonTapped:(id)sender {
    NSString *productIdentifier = "your_product_identifier";
    [self.iapManager buyProductWithIdentifier:productIdentifier];
}

@end

这样，当用户点击购买按钮时，会调用buyButtonTapped:方法，然后调用IAPManager的buyProductWithIdentifier:方法进行购买。购买成功或失败后，会通过代理方法通知YourViewController来处理相应的逻辑。

Swift 代码示例

首先，创建一个名为IAPManager的类，实现SKPaymentTransactionObserver和SKProductsRequestDelegate协议：

import StoreKit

protocol IAPManagerDelegate: AnyObject {
    func didCompletePurchaseWithProductIdentifier(_ productIdentifier: String)
    func didFailPurchaseWithError(_ error: Error)
}

class IAPManager: NSObject, SKPaymentTransactionObserver, SKProductsRequestDelegate {
    weak var delegate: IAPManagerDelegate?

    static let shared = IAPManager()

    private override init() {}

    func startObservingTransactions() {
        SKPaymentQueue.default().add(self)
    }

    func stopObservingTransactions() {
        SKPaymentQueue.default().remove(self)
    }

    func buyProductWithIdentifier(_ productIdentifier: String) {
        if !canMakePayments() {
            // 无法进行支付
            return
        }

        let request = SKProductsRequest(productIdentifiers: [productIdentifier])
        request.delegate = self
        request.start()
    }

    func canMakePayments() -> Bool {
        return SKPaymentQueue.canMakePayments()
    }

    // MARK: - SKPaymentTransactionObserver

    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
        for transaction in transactions {
            switch transaction.transactionState {
            case .purchased:
                // 购买成功
                completeTransaction(transaction)
            case .failed:
                // 购买失败
                failedTransaction(transaction)
            case .restored:
                // 已经购买过该商品
                restoreTransaction(transaction)
            default:
                break
            }
        }
    }

    func completeTransaction(_ transaction: SKPaymentTransaction) {
        // 将购买成功的商品标记为完成
        SKPaymentQueue.default().finishTransaction(transaction)

        if let delegate = delegate {
            delegate.didCompletePurchaseWithProductIdentifier(transaction.payment.productIdentifier)
        }
    }

    func failedTransaction(_ transaction: SKPaymentTransaction) {
        if transaction.error?.code != SKError.paymentCancelled.rawValue {
            // 购买失败
            if let delegate = delegate {
                delegate.didFailPurchaseWithError(transaction.error!)
            }
        }

        // 将购买失败的商品标记为完成
        SKPaymentQueue.default().finishTransaction(transaction)
    }

    func restoreTransaction(_ transaction: SKPaymentTransaction) {
        // 恢复已经购买过的商品
        SKPaymentQueue.default().finishTransaction(transaction)
    }

    // MARK: - SKProductsRequestDelegate

    func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
        if let products = response.products, !products.isEmpty {
            let product = products.first!
            let payment = SKPayment(product: product)
            SKPaymentQueue.default().add(payment)
        }
    }
}

接下来，在你的使用内购的地方，设置IAPManager的代理，并实现相关的代理方法：

class YourViewController: UIViewController, IAPManagerDelegate {

    let iapManager = IAPManager.shared

    override func viewDidLoad() {
        super.viewDidLoad()

        iapManager.delegate = self
    }

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)

        iapManager.startObservingTransactions()
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)

        iapManager.stopObservingTransactions()
    }

    func didCompletePurchaseWithProductIdentifier(_ productIdentifier: String) {
        // 内购购买成功
        // 处理购买成功的逻辑
    }

    func didFailPurchaseWithError(_ error: Error) {
        // 内购购买失败
        // 处理购买失败的逻辑
    }

    @IBAction func buyButtonTapped(_ sender: Any) {
        let productIdentifier = "your_product_identifier"
        iapManager.buyProductWithIdentifier(productIdentifier)
    }
}

注意：

以上代码只是示例，实际使用中需要根据具体情况进行调整。
记得在应用中添加内购商品并设置好对应的 productIdentifier。
在 YourViewController 中处理购买成功和失败的逻辑。

希望以上代码示例能够帮助你快速集成 iOS 内购功能。

iOS 内购购买逻辑代码封装代理 - Swift & Objective-C 示例