Understanding Auto-Renewable Subscriptions with StoreKit

As a developer working on iOS applications, you’re likely familiar with the process of managing subscriptions using the StoreKit framework. In this article, we’ll delve into the specifics of auto-renewable subscriptions and explore how to handle scenarios where an existing subscription is attempted to be restored.

What are Auto-Renewable Subscriptions?

Auto-renewable subscriptions allow users to purchase a recurring service or product without having to manually renew their subscription at the end of each period. This feature provides a seamless experience for customers, as their payments will automatically be processed on a regular basis (e.g., monthly, quarterly, or annually).

When an auto-renewable subscription is purchased, Apple creates a receipt that stores the user’s purchase information and payment details. This receipt is used to authenticate future purchases, ensuring that users are not charged multiple times for the same service.

Troubleshooting Issues with Auto-Renewable Subscriptions

In your Newsstand app, you’re facing an issue where attempting to restore an existing subscription results in a failed transaction state (SKPaymentTransactionStateFailed) instead of the expected restored state (SKPaymentTransactionStateRestored). This behavior is puzzling, as Apple’s documentation indicates that StoreKit should return the restored state if the user has previously purchased an auto-renewable subscription.

To better understand this issue, let’s break down the steps involved in purchasing and restoring an auto-renewable subscription:

1. Purchasing an Auto-Renewable Subscription

   • The user launches your app and taps the “Purchase” button.
   • StoreKit initiates a payment transaction to process the purchase.
   • If the payment is successful, Apple creates a receipt that stores the user’s purchase information and payment details.

2. Restoring an Existing Subscription

   • The user launches your app again and taps the “Restore” button.
   • StoreKit attempts to restore any previously purchased auto-renewable subscriptions by querying the App Store server for an authentication token based on the stored receipt.

Now, let’s examine why attempting to restore a subscription is returning a failed transaction state (SKPaymentTransactionStateFailed) instead of the expected restored state (SKPaymentTransactionStateRestored).

The Issue with Restoring Subscriptions

When you attempt to restore a subscription by calling [[SKPaymentQueue defaultQueue] restoreCompletedTransactions], StoreKit sends an authentication token request to Apple’s App Store server. If the stored receipt is valid, Apple returns an authentication token that can be used to authenticate future purchases.

However, it appears that there’s a discrepancy between how StoreKit handles this process and what your app expects. Specifically:

• When you call [[SKPaymentQueue defaultQueue] restoreCompletedTransactions], StoreKit attempts to create a new payment transaction using the stored receipt information.
• Instead of returning the restored state (SKPaymentTransactionStateRestored), StoreKit returns a failed transaction state (SKPaymentTransactionStateFailed) because it’s unable to verify the authenticity of the stored receipt.

Resolving the Issue: Implementing Both Purchase and Restore Buttons

To resolve this issue, you can implement both “Purchase” and “Restore” buttons in your app. The “Purchase” button will trigger a new payment transaction when tapped, allowing users to purchase an auto-renewable subscription without affecting the existing subscription.

The “Restore” button, on the other hand, will attempt to restore any previously purchased auto-renewable subscriptions using [[SKPaymentQueue defaultQueue] restoreCompletedTransactions]. By providing both buttons, you can ensure that your app handles subscription restoration correctly and provides a seamless experience for users.

Example Code: Implementing Both Purchase and Restore Buttons

Here’s an example code snippet demonstrating how to implement both “Purchase” and “Restore” buttons in your app:

#import <StoreKit/StoreKit.h>

@interface YourViewController () <SKPaymentQueueDelegate, SKProductsRequestDelegate>
@property (nonatomic) SKPaymentTransaction *currentTransaction;
@end

@implementation YourViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // Create a purchase button
    UIButton *purchaseButton = [UIButton buttonWithType:UIButtonTypeSystem];
    purchaseButton.title = @"Purchase";
    [purchaseButton addTarget:self action:@selector(purchaseSubscription:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:purchaseButton];
}

- (void)purchaseSubscription:(UIButton *)button {
    // Get the product ID for the auto-renewable subscription
    NSString *productID = @"auto-renewal-subscription";
    
    // Request products from the App Store
    SKProductsRequest *request = [[SKProductsRequest alloc] initWithProductIdentifiers:@[productID]];
    request.delegate = self;
    [request start];
}

- (void)skproductsRequest:(SKProductsRequest *)request didReceiveResponse:(SKProductsResponse *)response {
    // Get the product details from the response
    SKProduct *product = response.products.firstObject;
    
    if (!product.isFamilySharingEnabled && !product.requiresReceiptVerification) {
        // Proceed with purchasing the subscription
        [self purchaseSubscriptionOnDevice];
        
        return;
    }
}

- (void)purchaseSubscriptionOnDevice {
    // Create a payment transaction
    SKPayment *payment = [[SKPayment alloc] initWithProductID:@"auto-renewal-subscription"];
    
    // Add the payment transaction to the current transaction array
    self.currentTransaction = [[SKPaymentQueue defaultQueue].paymentTransactions firstObject];
    
    [[SKPaymentQueue defaultQueue] addPayment:payment];
}

- (void)restoreCompletedTransactions {
    SKPaymentQueue *queue = [SKPaymentQueue defaultQueue];
    queue.restoredTransactions = @[@(self.currentTransaction)];
    queue.paymentQueue:queue updatedTransactions:nil;
}

- (IBAction)restoreSubscription:(UIButton *)button {
    // Attempt to restore any previously purchased auto-renewable subscriptions
    [self.restoreCompletedTransactions];
}
@end

In this example, the “Purchase” button triggers a new payment transaction when tapped. The “Restore” button calls [[SKPaymentQueue defaultQueue] restoreCompletedTransactions] to attempt to restore any previously purchased auto-renewable subscriptions.

By implementing both buttons and handling subscription restoration correctly, you can provide a seamless experience for users and ensure that your app manages auto-renewable subscriptions accurately.

Conclusion

In this article, we’ve explored the complexities of managing auto-renewable subscriptions using StoreKit. We’ve examined why attempting to restore an existing subscription is returning a failed transaction state (SKPaymentTransactionStateFailed) instead of the expected restored state (SKPaymentTransactionStateRestored).

By implementing both “Purchase” and “Restore” buttons in your app, you can handle subscription restoration correctly and provide a seamless experience for users. This approach ensures that your app manages auto-renewable subscriptions accurately and provides a positive user experience.

Additional Resources

• Apple Developer Documentation: StoreKit Framework
• Apple Developer Documentation: [Auto-Renewable Subscriptions](https://developer.apple.com/documentation storekit/4148087-auto-renewable-subscription)
• Apple Developer Documentation: SKPaymentQueue

Last modified on 2023-08-05