val billingClient = BillingClient.newBuilder(context)
  .setListener(purchaseUpdateListener)
  .enablePendingPurchases()
  .build()
billingClient.startConnection(object : BillingClientStateListener {
  override fun onBillingSetupFinished(billingResult: BillingResult) {
    if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
        // The billing client is ready, you can now query subscription information asynchronously


        billingClient.queryPurchasesAsync(BillingClient.SkuType.SUBS) {result, subscriptionList ->
            if (result.responseCode == BillingClient.BillingResponseCode.OK && subscriptionList != null) {
                // Handle the retrieved subscription list


                subscriptionList.forEach { purchase ->
                    // Process each subscription purchase


                }
            } else {
                // Handle error in queryPurchasesAsync


            }
        }
    } else {
       // Handle error on setup finished


    }
  }
  override fun onBillingServiceDisconnected() {
    // Retry connection after a delay if the service gets disconnected


    Handler(Looper.getMainLooper()).postDelayed({
        billingClient.startConnection(this)
    }, 3000)
  }
})
// Remember to properly disconnect the billing client in your activity/fragment lifecycle


override fun onDestroy() {
    billingClient.endConnection()
    super.onDestroy()
}

import StoreKit
class YourViewController: UIViewController, SKPaymentTransactionObserver {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Add the observer for payment transactions


        SKPaymentQueue.default().add(self)
        
        // Refresh the receipt to get the latest subscription information


        refreshReceipt()
    }
    func refreshReceipt() {
        let request = SKReceiptRefreshRequest()
        request.delegate = self
        request.start()
    }
    // Implement SKPaymentTransactionObserver methods


    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
        for transaction in transactions {
            switch transaction.transactionState {
            case .purchased, .restored:
                // Handle the purchase or restore


                // You can check the transaction.transactionReceipt for receipt information


                break
            case .failed:
                // Handle the failed transaction


                break
            case .deferred:
                // Handle the deferred transaction


                break
            case .purchasing:
                // Transaction is in progress


                break
            @unknown default:
                break
            }
        }
    }
    // Implement SKRequestDelegate method


    func requestDidFinish(_ request: SKRequest) {
        // Receipt refresh request completed


        // Now you can use the updated receipt to check subscription status


    }
    func request(_ request: SKRequest, didFailWithError error: Error) {
        // Handle the error during the receipt refresh request


    }
}