capacitor-native-purchases 0.2.1 → 0.3.1

package/android/src/main/java/jok/purchases/capacitor/Purchases.java

@@ -3,14 +3,17 @@ package jok.purchases.capacitor;
 import android.app.Activity;
 import android.util.Log;
 
+import com.android.billingclient.api.AcknowledgePurchaseParams;
 import com.android.billingclient.api.BillingClient;
-
 import com.android.billingclient.api.BillingClientStateListener;
+import com.android.billingclient.api.ConsumeParams;
 import com.android.billingclient.api.BillingFlowParams;
 import com.android.billingclient.api.BillingResult;
+import com.android.billingclient.api.PendingPurchasesParams;
 import com.android.billingclient.api.ProductDetails;
 import com.android.billingclient.api.Purchase;
 import com.android.billingclient.api.PurchaseHistoryRecord;
+import com.android.billingclient.api.PurchasesUpdatedListener;
 import com.android.billingclient.api.QueryProductDetailsParams;
 import com.android.billingclient.api.QueryPurchaseHistoryParams;
 import com.android.billingclient.api.QueryPurchasesParams;
@@ -20,8 +23,7 @@ import com.getcapacitor.PluginCall;
 
 import android.content.Context;
 
-
-import androidx.annotation.NonNull;
+import androidx.appcompat.app.AlertDialog;
 
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
@@ -31,370 +33,718 @@ import java.nio.charset.StandardCharsets;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Calendar;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Objects;
 
 public class Purchases {
 
-    private final Activity activity;
-    public Context context;
-    private final BillingClient billingClient;
-    private int billingClientIsConnected = 0;
+  private final Activity activity;
+  public Context context;
+  private BillingClient billingClient;
+  private int billingClientIsConnected = 0;
 
-    private String googleVerifyEndpoint = "";
-    private String googleBid = "";
+  // Reconnection configuration
+  private static final int MAX_RECONNECT_ATTEMPTS = 5;
+  private static final long RECONNECT_BASE_DELAY_MS = 1000; // 1 second
+  private int reconnectAttempts = 0;
+  private final android.os.Handler reconnectHandler = new android.os.Handler(android.os.Looper.getMainLooper());
 
-    public Purchases(PurchasesPlugin plugin, BillingClient billingClient) {
+  private String googleVerifyEndpoint = "";
+  private String googleBid = "";
 
-        this.billingClient = billingClient;
-        this.billingClient.startConnection(new BillingClientStateListener() {
-            @Override
-            public void onBillingSetupFinished(@NonNull BillingResult billingResult) {
-                if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
-                    billingClientIsConnected = 1;
-                } else {
-                    billingClientIsConnected = billingResult.getResponseCode();
-                }
-            }
+  // Cache to store product types (SUBS or INAPP) by productIdentifier
+  private final Map<String, String> productTypeCache = new HashMap<>();
 
-            @Override
-            public void onBillingServiceDisconnected() {
-                // Try to restart the connection on the next request to
-                // Google Play by calling the startConnection() method.
-            }
-        });
-        this.activity = plugin.getActivity();
-        this.context = plugin.getContext();
+  // Store pending purchase call to resolve after acknowledgement
+  private PluginCall pendingPurchaseCall = null;
 
-    }
 
-    public String echo(String value) {
-        Log.i("Echo", value);
-        return value;
-    }
+  // This listener is fired upon completing the billing flow, it is vital to call the acknowledgePurchase
+  // method on the billingClient for SUBS, or consumeAsync for INAPP, otherwise Google will automatically
+  // cancel the subscription or refund the purchase shortly after
+  private final PurchasesUpdatedListener purchasesUpdatedListener = (billingResult, purchases) -> {
+    JSObject response = new JSObject();
+    try {
+      if (purchases != null && billingResult.getResponseCode() == 0) {
+        for (int i = 0; i < purchases.size(); i++) {
 
-    public void setGoogleVerificationDetails(String googleVerifyEndpoint, String bid) {
-        this.googleVerifyEndpoint = googleVerifyEndpoint;
-        this.googleBid = bid;
+          Purchase currentPurchase = purchases.get(i);
+          String purchaseToken = currentPurchase.getPurchaseToken();
 
-        Log.i("SET-VERIFY", "Verification values updated");
-    }
+          // Query INAPP purchases to check if this transaction is there
+          QueryPurchasesParams inAppQueryParams = QueryPurchasesParams.newBuilder()
+            .setProductType(BillingClient.ProductType.INAPP)
+            .build();
 
-    public void getProductDetails(String productIdentifier, PluginCall call) {
+          billingClient.queryPurchasesAsync(inAppQueryParams, (inAppResult, inAppPurchases) -> {
+            boolean foundInInApp = false;
 
-        JSObject response = new JSObject();
+            if (inAppPurchases != null) {
+              for (Purchase p : inAppPurchases) {
+                if (p.getPurchaseToken().equals(purchaseToken)) {
+                  foundInInApp = true;
+                  break;
+                }
+              }
+            }
 
-        if (billingClientIsConnected == 1) {
+            if (foundInInApp) {
+              // Found in INAPP, use consumeAsync
+              ConsumeParams consumeParams = ConsumeParams.newBuilder()
+                .setPurchaseToken(purchaseToken)
+                .build();
+
+              billingClient.consumeAsync(consumeParams, (consumeResult, consumedToken) -> {
+                Log.i("Purchase consumed", currentPurchase.getOriginalJson());
+
+                if (pendingPurchaseCall != null) {
+                  response.put("responseCode", consumeResult.getResponseCode());
+                  if (consumeResult.getResponseCode() == 0) {
+                    response.put("responseMessage", "Purchase consumed successfully");
+                  } else {
+                    response.put("responseMessage", "Failed to consume purchase: " + consumeResult.getDebugMessage());
+                  }
+                  pendingPurchaseCall.resolve(response);
+                  pendingPurchaseCall = null;
+                }
+              });
+            } else {
+              // Not found in INAPP, query SUBS purchases
+              QueryPurchasesParams subsQueryParams = QueryPurchasesParams.newBuilder()
+                .setProductType(BillingClient.ProductType.SUBS)
+                .build();
+
+              billingClient.queryPurchasesAsync(subsQueryParams, (subsResult, subsPurchases) -> {
+                boolean foundInSubs = false;
+
+                if (subsPurchases != null) {
+                  for (Purchase p : subsPurchases) {
+                    if (p.getPurchaseToken().equals(purchaseToken)) {
+                      foundInSubs = true;
+                      break;
+                    }
+                  }
+                }
 
-            QueryProductDetailsParams.Product productToFind = QueryProductDetailsParams.Product.newBuilder()
-                    .setProductId(productIdentifier)
-                    .setProductType(BillingClient.ProductType.SUBS)
+                if (foundInSubs) {
+                  // Found in SUBS, use acknowledgePurchase
+                  AcknowledgePurchaseParams acknowledgePurchaseParams = AcknowledgePurchaseParams.newBuilder()
+                    .setPurchaseToken(purchaseToken)
                     .build();
 
-            QueryProductDetailsParams queryProductDetailsParams =
-                    QueryProductDetailsParams.newBuilder()
-                            .setProductList(List.of(productToFind))
-                            .build();
+                  billingClient.acknowledgePurchase(acknowledgePurchaseParams, ackResult -> {
+                    Log.i("Purchase ack", currentPurchase.getOriginalJson());
+
+                    if (pendingPurchaseCall != null) {
+                      response.put("responseCode", ackResult.getResponseCode());
+                      if (ackResult.getResponseCode() == 0) {
+                        response.put("responseMessage", "Purchase acknowledged successfully");
+                      } else {
+                        response.put("responseMessage", "Failed to acknowledge purchase: " + ackResult.getDebugMessage());
+                      }
+                      pendingPurchaseCall.resolve(response);
+                      pendingPurchaseCall = null;
+                    }
+                  });
+                } else {
+                  // Not found in either INAPP or SUBS
+                  Log.w("PurchasesUpdatedListener", "Purchase not found in INAPP or SUBS queries");
+                  if (pendingPurchaseCall != null) {
+                    response.put("responseCode", -1);
+                    response.put("responseMessage", "Purchase not found in active purchases");
+                    pendingPurchaseCall.resolve(response);
+                    pendingPurchaseCall = null;
+                  }
+                }
+              });
+            }
+          });
+        }
+      } else {
+        // Purchase failed or was cancelled
+        if (pendingPurchaseCall != null) {
+          response.put("responseCode", billingResult.getResponseCode());
+          response.put("responseMessage", billingResult.getDebugMessage());
+          pendingPurchaseCall.resolve(response);
+          pendingPurchaseCall = null;
+        }
+      }
 
-            billingClient.queryProductDetailsAsync(
-                    queryProductDetailsParams,
-                    (billingResult, productDetailsList) -> {
 
-                        try {
+//      if (pendingPurchaseCall != null) {
+//        response.put("responseCode", -2);
+//        response.put("responseMessage", "Not processed");
+//        pendingPurchaseCall.resolve(response);
+//        pendingPurchaseCall = null;
+//      }
+    }
+    catch(Error err){
+      new AlertDialog.Builder(this.context)
+        .setMessage("Error: " + err.toString())
+        .setPositiveButton("OK", null)
+        .show();
+
+      if (pendingPurchaseCall != null) {
+        response.put("responseCode", -1);
+        response.put("responseMessage", err.toString());
+        pendingPurchaseCall.resolve(response);
+        pendingPurchaseCall = null;
+      }
+    }
+  };
+
+  Context savedContext;
+
+  public Purchases(PurchasesPlugin plugin) {
+    this.context = plugin.getContext();
+    this.activity = plugin.getActivity();
+
+    this.billingClient = BillingClient.newBuilder(context)
+      .setListener(purchasesUpdatedListener)
+      .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().enablePrepaidPlans().build())
+      .build();
+
+    // Start initial connection
+    startBillingConnection();
+  }
+
+  /**
+   * Schedule a reconnection attempt with exponential backoff.
+   * Delay increases: 1s, 2s, 4s, 8s, 16s (max 5 attempts)
+   */
+  private void scheduleReconnect() {
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      Log.e("Purchases", "Max reconnection attempts reached. Please restart the app.");
+      return;
+    }
 
-                            ProductDetails productDetails = productDetailsList.get(0);
-                            String productId = productDetails.getProductId();
-                            String title = productDetails.getTitle();
-                            String desc = productDetails.getDescription();
-                            Log.i("productIdentifier", productId);
-                            Log.i("displayName", title);
-                            Log.i("desc", desc);
+    long delayMs = RECONNECT_BASE_DELAY_MS * (1L << reconnectAttempts); // Exponential backoff
+    reconnectAttempts++;
 
-                            List<ProductDetails.SubscriptionOfferDetails> subscriptionOfferDetails = productDetails.getSubscriptionOfferDetails();
+    Log.i("Purchases", "Scheduling reconnect attempt " + reconnectAttempts + " in " + delayMs + "ms");
 
-                            String price = Objects.requireNonNull(subscriptionOfferDetails).get(0).getPricingPhases().getPricingPhaseList().get(0).getFormattedPrice();
+    reconnectHandler.postDelayed(this::startBillingConnection, delayMs);
+  }
 
-                            JSObject data = new JSObject();
-                            data.put("productIdentifier", productId);
-                            data.put("displayName", title);
-                            data.put("description", desc);
-                            data.put("price", price);
+  /**
+   * Start or restart the billing client connection.
+   */
+  private void startBillingConnection() {
+    if (billingClient.isReady()) {
+      Log.i("Purchases", "BillingClient is already connected");
+      billingClientIsConnected = 1;
+      reconnectAttempts = 0;
+      return;
+    }
 
-                            response.put("responseCode", 0);
-                            response.put("responseMessage", "Successfully found the product details for given productIdentifier");
-                            response.put("data", data);
+    billingClient.startConnection(new BillingClientStateListener() {
+      @Override
+      public void onBillingSetupFinished(BillingResult billingResult) {
+        if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
+          billingClientIsConnected = 1;
+          reconnectAttempts = 0; // Reset on successful connection
+          Log.i("Purchases", "BillingClient connected successfully");
+        } else {
+          billingClientIsConnected = billingResult.getResponseCode();
+          Log.e("Purchases", "BillingClient connection failed: " + billingResult.getDebugMessage());
+          // Try again with backoff
+          scheduleReconnect();
+        }
+      }
+
+      @Override
+      public void onBillingServiceDisconnected() {
+        billingClientIsConnected = -1;
+        Log.w("Purchases", "BillingClient disconnected");
+        scheduleReconnect();
+      }
+    });
+  }
+
+  /**
+   * Ensure billing client is connected before executing an operation.
+   * Returns true if connected, false if reconnection was triggered.
+   */
+  public boolean ensureConnected() {
+    if (billingClient.isReady()) {
+      return true;
+    }
+    // Trigger reconnection
+    reconnectAttempts = 0; // Reset for on-demand reconnection
+    startBillingConnection();
+    return false;
+  }
 
-                        } catch (Exception e) {
-                            Log.e("Err", e.toString());
-                            response.put("responseCode", 1);
-                            response.put("responseMessage", "Could not find a product matching the given productIdentifier");
-                        }
+  public String echo(String value) {
+    Log.i("Echo", value);
+    return value;
+  }
 
-                        call.resolve(response);
-                    }
-            );
+  public void setGoogleVerificationDetails(String googleVerifyEndpoint, String bid) {
+    this.googleVerifyEndpoint = googleVerifyEndpoint;
+    this.googleBid = bid;
 
-        } else if (billingClientIsConnected == 2) {
+    Log.i("SET-VERIFY", "Verification values updated");
+  }
 
-            response.put("responseCode", 500);
-            response.put("responseMessage", "Android: BillingClient failed to initialise");
-            call.resolve(response);
+  public void getProductDetails(String productIdentifier, PluginCall call) {
 
-        } else {
+    JSObject response = new JSObject();
 
-            response.put("responseCode", billingClientIsConnected);
-            response.put("responseMessage", "Android: BillingClient failed to initialise");
+    if (!ensureConnected()) {
+      response.put("responseCode", 503);
+      response.put("responseMessage", "Android: BillingClient is reconnecting, please retry");
+      call.resolve(response);
+      return;
+    }
 
-            response.put("responseCode", 503);
-            response.put("responseMessage", "Android: BillingClient is still initialising");
+    // Check cache first
+    String cachedType = productTypeCache.get(productIdentifier);
+
+    if (cachedType != null) {
+      // Use cached type directly
+      if (cachedType.equals(BillingClient.ProductType.SUBS)) {
+        querySubsProduct(productIdentifier, call, response);
+      } else {
+        queryInAppProduct(productIdentifier, call, response);
+      }
+    } else {
+      // Not cached - try SUBS first, then INAPP
+      querySubsProduct(productIdentifier, call, response);
+    }
+  }
+
+  private void querySubsProduct(String productIdentifier, PluginCall call, JSObject response) {
+    QueryProductDetailsParams.Product subsProductToFind = QueryProductDetailsParams.Product.newBuilder()
+      .setProductId(productIdentifier)
+      .setProductType(BillingClient.ProductType.SUBS)
+      .build();
+
+    QueryProductDetailsParams subsQueryParams =
+      QueryProductDetailsParams.newBuilder()
+        .setProductList(List.of(subsProductToFind))
+        .build();
+
+    billingClient.queryProductDetailsAsync(
+      subsQueryParams,
+      (billingResult, productDetailsList) -> {
+
+        if (productDetailsList != null && !productDetailsList.isEmpty()) {
+          // Found as SUBS
+          try {
+            ProductDetails productDetails = productDetailsList.get(0);
+            String productId = productDetails.getProductId();
+            String title = productDetails.getTitle();
+            String desc = productDetails.getDescription();
+            Log.i("productIdentifier", productId);
+            Log.i("displayName", title);
+            Log.i("desc", desc);
+
+            List<ProductDetails.SubscriptionOfferDetails> subscriptionOfferDetails = productDetails.getSubscriptionOfferDetails();
+            String price = Objects.requireNonNull(subscriptionOfferDetails).get(0).getPricingPhases().getPricingPhaseList().get(0).getFormattedPrice();
+
+            // Cache product type as SUBS
+            productTypeCache.put(productId, BillingClient.ProductType.SUBS);
+
+            JSObject data = new JSObject();
+            data.put("productIdentifier", productId);
+            data.put("displayName", title);
+            data.put("description", desc);
+            data.put("price", price);
+            data.put("productType", "SUBS");
+
+            response.put("responseCode", 0);
+            response.put("responseMessage", "Successfully found the product details for given productIdentifier");
+            response.put("data", data);
             call.resolve(response);
 
+          } catch (Exception e) {
+            Log.e("Err", e.toString());
+            // If error processing SUBS, try INAPP
+            queryInAppProduct(productIdentifier, call, response);
+          }
+        } else {
+          // Not found as SUBS, try INAPP
+          queryInAppProduct(productIdentifier, call, response);
+        }
+      }
+    );
+  }
+
+  private void queryInAppProduct(String productIdentifier, PluginCall call, JSObject response) {
+    QueryProductDetailsParams.Product inAppProductToFind = QueryProductDetailsParams.Product.newBuilder()
+      .setProductId(productIdentifier)
+      .setProductType(BillingClient.ProductType.INAPP)
+      .build();
+
+    QueryProductDetailsParams inAppQueryParams =
+      QueryProductDetailsParams.newBuilder()
+        .setProductList(List.of(inAppProductToFind))
+        .build();
+
+    billingClient.queryProductDetailsAsync(
+      inAppQueryParams,
+      (billingResult, productDetailsList) -> {
+        try {
+          if (productDetailsList != null && !productDetailsList.isEmpty()) {
+            ProductDetails productDetails = productDetailsList.get(0);
+            String productId = productDetails.getProductId();
+            String title = productDetails.getTitle();
+            String desc = productDetails.getDescription();
+            Log.i("productIdentifier", productId);
+            Log.i("displayName", title);
+            Log.i("desc", desc);
+
+            ProductDetails.OneTimePurchaseOfferDetails oneTimeOfferDetails = productDetails.getOneTimePurchaseOfferDetails();
+            String price = Objects.requireNonNull(oneTimeOfferDetails).getFormattedPrice();
+
+            // Cache product type as INAPP
+            productTypeCache.put(productId, BillingClient.ProductType.INAPP);
+
+            JSObject data = new JSObject();
+            data.put("productIdentifier", productId);
+            data.put("displayName", title);
+            data.put("description", desc);
+            data.put("price", price);
+            data.put("productType", "INAPP");
+
+            response.put("responseCode", 0);
+            response.put("responseMessage", "Successfully found the product details for given productIdentifier");
+            response.put("data", data);
+          } else {
+            response.put("responseCode", 1);
+            response.put("responseMessage", "Could not find a product matching the given productIdentifier");
+          }
+        } catch (Exception e) {
+          Log.e("Err", e.toString());
+          response.put("responseCode", 1);
+          response.put("responseMessage", "Could not find a product matching the given productIdentifier");
         }
-    }
 
-    public void getLatestTransaction(String productIdentifier, PluginCall call) {
+        call.resolve(response);
+      }
+    );
+  }
 
-        JSObject response = new JSObject();
+  /**
+   * Get product type from cache, defaults to SUBS if not cached
+   */
+  private String getProductType(String productIdentifier) {
+    return productTypeCache.getOrDefault(productIdentifier, null);
+  }
 
-        if (billingClientIsConnected == 1) {
-
-            QueryPurchaseHistoryParams queryPurchaseHistoryParams =
-                    QueryPurchaseHistoryParams.newBuilder()
-                            .setProductType(BillingClient.ProductType.SUBS)
-                            .build();
-
-
-            billingClient.queryPurchaseHistoryAsync(queryPurchaseHistoryParams, (BillingResult billingResult, List<PurchaseHistoryRecord> list) -> {
-
-                // Try to loop through the list until we find a purchase history record associated with the passed in productIdentifier.
-                // If we do, then set found to true to break out of the loop, then compile a response with necessary data. Otherwise compile
-                // a response saying that the there were not transactions for the given productIdentifier.
-                int i = 0;
-                boolean found = false;
-                while (list != null && (i < list.size() && !found)) {
-                    try {
-
-                        JSObject currentPurchaseHistoryRecord = new JSObject(list.get(i).getOriginalJson());
-                        Log.i("PurchaseHistory", currentPurchaseHistoryRecord.toString());
-
-                        if (currentPurchaseHistoryRecord.get("productId").equals(productIdentifier)) {
-
-                            found = true;
-
-                            JSObject data = new JSObject();
-                            String expiryDate = getExpiryDateFromGoogle(productIdentifier, currentPurchaseHistoryRecord.get("purchaseToken").toString());
-                            if (expiryDate != null) {
-                                data.put("expiryDate", expiryDate);
-                            }
-                            Calendar calendar = Calendar.getInstance();
-                            calendar.setTimeInMillis(Long.parseLong((currentPurchaseHistoryRecord.get("purchaseTime").toString())));
-                            String orderId = currentPurchaseHistoryRecord.optString("orderId", "");  // Usamos optString para obtener un valor por defecto si la clave no existe
-                            data.put("productIdentifier", currentPurchaseHistoryRecord.get("productId"));
-                            data.put("originalId", orderId);
-                            data.put("transactionId", orderId);
-                            data.put("developerPayload",currentPurchaseHistoryRecord.optString("developerPayload", ""));  // Usamos optString para obtener un valor por defecto si la clave no existe
-                            data.put("purchaseToken", currentPurchaseHistoryRecord.get("purchaseToken").toString());
-
-                            response.put("responseCode", 0);
-                            response.put("responseMessage", "Successfully found the latest transaction matching given productIdentifier");
-                            response.put("data", data);
-                        }
-                    } catch (Exception e) {
-                        Logger.error(e.getMessage());
-                    }
+  public void getLatestTransaction(String productIdentifier, PluginCall call) {
 
-                    i++;
+    JSObject response = new JSObject();
 
-                }
+    if (!ensureConnected()) {
+      response.put("responseCode", 503);
+      response.put("responseMessage", "Android: BillingClient is reconnecting, please retry");
+      call.resolve(response);
+      return;
+    }
 
-                // If after looping through the list of purchase history records, no records are found to be associated with
-                // the given product identifier, return a response saying no transactions found
-                if (!found) {
-                    response.put("responseCode", 3);
-                    response.put("responseMessage", "No transaction for given productIdentifier, or it could not be verified");
-                }
+    // Use cached product type, defaults to SUBS
+    String productType = getProductType(productIdentifier);
+    if (productType == null) {
+      response.put("responseCode", 1);
+      response.put("responseMessage", "Please load products first so type will be identified");
+      call.resolve(response);
+      return;
+    }
 
-                call.resolve(response);
+    QueryPurchaseHistoryParams queryPurchaseHistoryParams =
+      QueryPurchaseHistoryParams.newBuilder()
+        .setProductType(productType)
+        .build();
 
-            });
+    billingClient.queryPurchaseHistoryAsync(queryPurchaseHistoryParams, (BillingResult billingResult, List<PurchaseHistoryRecord> list) -> {
 
-        }
+      // Try to loop through the list until we find a purchase history record associated with the passed in productIdentifier.
+      // If we do, then set found to true to break out of the loop, then compile a response with necessary data. Otherwise compile
+      // a response saying that the there were not transactions for the given productIdentifier.
+      int i = 0;
+      boolean found = false;
+      while (list != null && (i < list.size() && !found)) {
+        try {
 
-    }
+          JSObject currentPurchaseHistoryRecord = new JSObject(list.get(i).getOriginalJson());
+          Log.i("PurchaseHistory", currentPurchaseHistoryRecord.toString());
 
-    public void getCurrentEntitlements(PluginCall call) {
+          if (currentPurchaseHistoryRecord.get("productId").equals(productIdentifier)) {
 
-        JSObject response = new JSObject();
+            found = true;
 
-        if (billingClientIsConnected == 1) {
+            JSObject data = new JSObject();
+            String expiryDate = getExpiryDateFromGoogle(productIdentifier, currentPurchaseHistoryRecord.get("purchaseToken").toString());
+            if (expiryDate != null) {
+              data.put("expiryDate", expiryDate);
+            }
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTimeInMillis(Long.parseLong((currentPurchaseHistoryRecord.get("purchaseTime").toString())));
+            String orderId = currentPurchaseHistoryRecord.optString("orderId", "");  // Usamos optString para obtener un valor por defecto si la clave no existe
+            data.put("productIdentifier", currentPurchaseHistoryRecord.get("productId"));
+            data.put("originalId", orderId);
+            data.put("transactionId", orderId);
+            data.put("developerPayload", currentPurchaseHistoryRecord.optString("developerPayload", ""));  // Usamos optString para obtener un valor por defecto si la clave no existe
+            data.put("purchaseToken", currentPurchaseHistoryRecord.get("purchaseToken").toString());
+
+            response.put("responseCode", 0);
+            response.put("responseMessage", "Successfully found the latest transaction matching given productIdentifier");
+            response.put("data", data);
+          }
+        } catch (Exception e) {
+          Logger.error(e.getMessage());
+        }
 
-            QueryPurchasesParams queryPurchasesParams =
-                    QueryPurchasesParams.newBuilder()
-                            .setProductType(BillingClient.ProductType.SUBS)
-                            .build();
+        i++;
 
-            billingClient.queryPurchasesAsync(
-                    queryPurchasesParams,
-                    (billingResult, purchaseList) -> {
+      }
 
-                        try {
+      // If after looping through the list of purchase history records, no records are found to be associated with
+      // the given product identifier, return a response saying no transactions found
+      if (!found) {
+        response.put("responseCode", 3);
+        response.put("responseMessage", "No transaction for given productIdentifier, or it could not be verified");
+      }
 
-                            int amountOfPurchases = purchaseList.size();
+      call.resolve(response);
 
-                            if (amountOfPurchases > 0) {
+    });
+  }
 
-                                ArrayList<JSObject> entitlements = new ArrayList<>();
-                                for (int i = 0; i < purchaseList.size(); i++) {
+  public void getCurrentEntitlements(PluginCall call) {
 
-                                    Purchase currentPurchase = purchaseList.get(i);
+    JSObject response = new JSObject();
 
-                                    String expiryDate = this.getExpiryDateFromGoogle(currentPurchase.getProducts().get(0), currentPurchase.getPurchaseToken());
-                                    String orderId = currentPurchase.getOrderId();
+    if (!ensureConnected()) {
+      response.put("responseCode", 503);
+      response.put("responseMessage", "Android: BillingClient is reconnecting, please retry");
+      call.resolve(response);
+      return;
+    }
 
-                                    String dateFormat = "dd-MM-yyyy hh:mm";
-                                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat, Locale.getDefault());
-                                    Calendar calendar = Calendar.getInstance();
-                                    calendar.setTimeInMillis(Long.parseLong((String.valueOf(currentPurchase.getPurchaseTime()))));
+    ArrayList<JSObject> allEntitlements = new ArrayList<>();
+
+    // First query SUBS
+    QueryPurchasesParams subsQueryParams =
+      QueryPurchasesParams.newBuilder()
+        .setProductType(BillingClient.ProductType.SUBS)
+        .build();
+
+    billingClient.queryPurchasesAsync(
+      subsQueryParams,
+      (billingResult, subsPurchaseList) -> {
+
+        // Process SUBS purchases
+        processEntitlements(subsPurchaseList, allEntitlements, "SUBS");
+
+        // Then query INAPP
+        QueryPurchasesParams inAppQueryParams =
+          QueryPurchasesParams.newBuilder()
+            .setProductType(BillingClient.ProductType.INAPP)
+            .build();
+
+        billingClient.queryPurchasesAsync(
+          inAppQueryParams,
+          (billingResult2, inAppPurchaseList) -> {
+
+            // Process INAPP purchases
+            processEntitlements(inAppPurchaseList, allEntitlements, "INAPP");
+
+            try {
+              if (!allEntitlements.isEmpty()) {
+                response.put("responseCode", 0);
+                response.put("responseMessage", "Successfully found all entitlements across all product types");
+                response.put("data", allEntitlements);
+              } else {
+                Log.i("No Purchases", "No active purchases found");
+                response.put("responseCode", 1);
+                response.put("responseMessage", "No entitlements were found");
+              }
+            } catch (Exception e) {
+              Log.e("Error", e.toString());
+              response.put("responseCode", 2);
+              response.put("responseMessage", e.toString());
+            }
 
-                                    entitlements.add(
-                                            new JSObject()
-                                                    .put("productIdentifier", currentPurchase.getProducts().get(0))
-                                                    .put("expiryDate", expiryDate)
-                                                    .put("originalStartDate", simpleDateFormat.format(calendar.getTime()))
-                                                    .put("originalId", orderId)
-                                                    .put("transactionId", orderId)
-                                                    .put("purchaseToken", currentPurchase.getPurchaseToken())
-                                    );
-                                }
+            call.resolve(response);
+          }
+        );
+      }
+    );
+  }
+
+  private void processEntitlements(List<Purchase> purchaseList, ArrayList<JSObject> entitlements, String productType) {
+    if (purchaseList == null) return;
+
+    for (Purchase currentPurchase : purchaseList) {
+      try {
+        String productId = currentPurchase.getProducts().get(0);
+        String orderId = currentPurchase.getOrderId();
+
+        String dateFormat = "dd-MM-yyyy hh:mm";
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat, Locale.getDefault());
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTimeInMillis(currentPurchase.getPurchaseTime());
+
+        JSObject entitlement = new JSObject()
+          .put("productIdentifier", productId)
+          .put("originalStartDate", simpleDateFormat.format(calendar.getTime()))
+          .put("originalId", orderId)
+          .put("transactionId", orderId)
+          .put("purchaseToken", currentPurchase.getPurchaseToken())
+          .put("productType", productType);
+
+        // Only get expiry date for subscriptions
+        if (productType.equals("SUBS")) {
+          String expiryDate = this.getExpiryDateFromGoogle(productId, currentPurchase.getPurchaseToken());
+          entitlement.put("expiryDate", expiryDate);
+        }
 
-                                response.put("responseCode", 0);
-                                response.put("responseMessage", "Successfully found all entitlements across all product types");
-                                response.put("data", entitlements);
+        // Cache the product type
+//        productTypeCache.put(productId, productType.equals("SUBS") ? BillingClient.ProductType.SUBS : BillingClient.ProductType.INAPP);
 
+        entitlements.add(entitlement);
+      } catch (Exception e) {
+        Log.e("Error", "Error processing entitlement: " + e.toString());
+      }
+    }
+  }
 
-                            } else {
-                                Log.i("No Purchases", "No active subscriptions found");
-                                response.put("responseCode", 1);
-                                response.put("responseMessage", "No entitlements were found");
-                            }
+  public void purchaseProduct(String productIdentifier, String accountToken, PluginCall call) {
+    JSObject response = new JSObject();
 
+    if (!ensureConnected()) {
+      response.put("responseCode", 503);
+      response.put("responseMessage", "Android: BillingClient is reconnecting, please retry");
+      call.resolve(response);
+      return;
+    }
 
-                            call.resolve(response);
+    // Use cached product type, defaults to SUBS
+    String productType = getProductType(productIdentifier);
 
-                        } catch (Exception e) {
-                            Log.e("Error", e.toString());
-                            response.put("responseCode", 2);
-                            response.put("responseMessage", e.toString());
-                        }
+    if (productType == null) {
+      response.put("responseCode", 1);
+      response.put("responseMessage", "Please load products first so type will be identified");
+      call.resolve(response);
+      return;
+    }
 
-                        call.resolve(response);
+    QueryProductDetailsParams.Product productToFind = QueryProductDetailsParams.Product.newBuilder()
+      .setProductId(productIdentifier)
+      .setProductType(productType)
+      .build();
 
-                    }
-            );
+    QueryProductDetailsParams queryProductDetailsParams =
+      QueryProductDetailsParams.newBuilder()
+        .setProductList(List.of(productToFind))
+        .build();
 
+    billingClient.queryProductDetailsAsync(
+      queryProductDetailsParams,
+      (billingResult1, productDetailsList) -> {
+
+        if (productDetailsList != null && !productDetailsList.isEmpty()) {
+          launchBillingFlow(productDetailsList.get(0), accountToken, call);
+        } else {
+          JSObject resp = new JSObject();
+          resp.put("responseCode", 1);
+          resp.put("responseMessage", "Product not found. " + productIdentifier + " " + productType + " " + productTypeCache.size());
+          call.resolve(resp);
         }
+      });
+  }
 
-    }
+  private void launchBillingFlow(ProductDetails productDetails, String accountToken, PluginCall call) {
+    try {
+      BillingFlowParams.ProductDetailsParams.Builder productParamsBuilder =
+        BillingFlowParams.ProductDetailsParams.newBuilder()
+          .setProductDetails(productDetails);
 
-    public void purchaseProduct(String productIdentifier, String accountToken, PluginCall call) {
+      if (productDetails.getProductType().equals(BillingClient.ProductType.SUBS)) {
+        productParamsBuilder.setOfferToken(Objects.requireNonNull(productDetails.getSubscriptionOfferDetails()).get(0).getOfferToken());
+      }
 
-        JSObject response = new JSObject();
+      BillingFlowParams.Builder paramsBuilder = BillingFlowParams.newBuilder()
+        .setProductDetailsParamsList(List.of(productParamsBuilder.build()));
 
-        if (billingClientIsConnected == 1) {
+      if (accountToken != null && !accountToken.isEmpty()) {
+        paramsBuilder.setObfuscatedAccountId(accountToken);
+      }
 
-            QueryProductDetailsParams.Product productToFind = QueryProductDetailsParams.Product.newBuilder()
-                    .setProductId(productIdentifier)
-                    .setProductType(BillingClient.ProductType.SUBS)
-                    .build();
+      BillingFlowParams billingFlowParams = paramsBuilder.build();
 
-            QueryProductDetailsParams queryProductDetailsParams =
-                    QueryProductDetailsParams.newBuilder()
-                            .setProductList(List.of(productToFind))
-                            .build();
-
-            billingClient.queryProductDetailsAsync(
-                    queryProductDetailsParams,
-                    (billingResult1, productDetailsList) -> {
-
-                        try {
-                            ProductDetails productDetails = productDetailsList.get(0);
-                            BillingFlowParams.Builder paramsBuilder = BillingFlowParams.newBuilder()
-                                    .setProductDetailsParamsList(
-                                            List.of(
-                                                    BillingFlowParams.ProductDetailsParams.newBuilder()
-                                                            .setProductDetails(productDetails)
-                                                            .setOfferToken(Objects.requireNonNull(productDetails.getSubscriptionOfferDetails()).get(0).getOfferToken())
-                                                            .build()
-                                            )
-                                    );
-
-                            if (accountToken != null && !accountToken.isEmpty()) {
-                                paramsBuilder.setObfuscatedAccountId(accountToken);
-                            }
-
-                            BillingFlowParams billingFlowParams = paramsBuilder.build();
-
-                            BillingResult result = billingClient.launchBillingFlow(this.activity, billingFlowParams);
-
-                            Log.i("RESULT", result.toString());
-                            response.put("responseCode", 0);
-                            response.put("responseMessage", "Successfully opened native popover");
-
-                        } catch (Exception e) {
-                            Logger.error(e.getMessage());
-                            response.put("responseCode", 1);
-                            response.put("responseMessage", "Failed to open native popover");
-                        }
-
-                        call.resolve(response);
-                    });
-        }
+      BillingResult result = billingClient.launchBillingFlow(this.activity, billingFlowParams);
+
+      Log.i("RESULT", result.toString());
 
+      if (result.getResponseCode() == BillingClient.BillingResponseCode.OK) {
+        // Save the call to resolve later in purchasesUpdatedListener
+        pendingPurchaseCall = call;
+      } else {
+        JSObject response = new JSObject();
+        // Billing flow failed to launch
+        response.put("responseCode", result.getResponseCode());
+        response.put("responseMessage", "Failed to launch billing flow: " + result.getDebugMessage());
+        call.resolve(response);
+      }
+
+    } catch (Exception e) {
+      Logger.error(e.getMessage());
+      JSObject response = new JSObject();
+      response.put("responseCode", 1);
+      response.put("responseMessage", "Failed to open native popover. " + e.getMessage() + " " + productDetails.getProductType());
+      call.resolve(response);
     }
+  }
 
-    private String getExpiryDateFromGoogle(String productIdentifier, String purchaseToken) {
+  private String getExpiryDateFromGoogle(String productIdentifier, String purchaseToken) {
 
-        try {
+    try {
 
-            // Compile request to verify purchase token
-            URL obj = new URL(this.googleVerifyEndpoint + "?bid=" + this.googleBid + "&subId=" + productIdentifier + "&purchaseToken=" + purchaseToken);
-            HttpURLConnection con = (HttpURLConnection) obj.openConnection();
-            con.setRequestMethod("GET");
+      // Compile request to verify purchase token
+      URL obj = new URL(this.googleVerifyEndpoint + "?bid=" + this.googleBid + "&subId=" + productIdentifier + "&purchaseToken=" + purchaseToken);
+      HttpURLConnection con = (HttpURLConnection) obj.openConnection();
+      con.setRequestMethod("GET");
 
-            // Try to receive response from server
-            try (BufferedReader br = new BufferedReader(
-                    new InputStreamReader(con.getInputStream(), StandardCharsets.UTF_8))) {
+      // Try to receive response from server
+      try (BufferedReader br = new BufferedReader(
+        new InputStreamReader(con.getInputStream(), StandardCharsets.UTF_8))) {
 
-                StringBuilder googleResponse = new StringBuilder();
-                String responseLine;
-                while ((responseLine = br.readLine()) != null) {
-                    googleResponse.append(responseLine.trim());
-                    Log.i("Response Line", responseLine);
-                }
-
-                // If the response was successful, extract expiryDate and put it in our response data property
-                if (con.getResponseCode() == 200) {
-                    JSObject postResponseJSON = new JSObject(googleResponse.toString());
-                    JSObject googleResponseJSON = new JSObject(postResponseJSON.get("googleResponse").toString()); // <-- note the typo in response object from server
-                    JSObject payloadJSON = new JSObject(googleResponseJSON.get("payload").toString());
-                    String dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
-                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat, Locale.getDefault());
-                    Calendar calendar = Calendar.getInstance();
-                    calendar.setTimeInMillis(Long.parseLong(payloadJSON.get("expiryTimeMillis").toString()));
-                    return simpleDateFormat.format(calendar.getTime());
-                } else {
-                    return null;
-                }
-            } catch (Exception e) {
-                Logger.error(e.getMessage());
-            }
-        } catch (Exception e) {
-            Logger.error(e.getMessage());
+        StringBuilder googleResponse = new StringBuilder();
+        String responseLine;
+        while ((responseLine = br.readLine()) != null) {
+          googleResponse.append(responseLine.trim());
+          Log.i("Response Line", responseLine);
         }
 
-        // If the method manages to each this far before already returning, just return null
-        // because something went wrong
-        return null;
+        // If the response was successful, extract expiryDate and put it in our response data property
+        if (con.getResponseCode() == 200) {
+          JSObject postResponseJSON = new JSObject(googleResponse.toString());
+          JSObject googleResponseJSON = new JSObject(postResponseJSON.get("googleResponse").toString()); // <-- note the typo in response object from server
+          JSObject payloadJSON = new JSObject(googleResponseJSON.get("payload").toString());
+          String dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
+          SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat, Locale.getDefault());
+          Calendar calendar = Calendar.getInstance();
+          calendar.setTimeInMillis(Long.parseLong(payloadJSON.get("expiryTimeMillis").toString()));
+          return simpleDateFormat.format(calendar.getTime());
+        } else {
+          return null;
+        }
+      } catch (Exception e) {
+        Logger.error(e.getMessage());
+      }
+    } catch (Exception e) {
+      Logger.error(e.getMessage());
     }
+
+    // If the method manages to each this far before already returning, just return null
+    // because something went wrong
+    return null;
+  }
 }

package/android/src/main/java/jok/purchases/capacitor/PurchasesPlugin.java

@@ -8,162 +8,106 @@ import com.getcapacitor.annotation.CapacitorPlugin;
 
 import android.content.Intent;
 import android.net.Uri;
-import android.util.Log;
-
-import com.android.billingclient.api.AcknowledgePurchaseParams;
-import com.android.billingclient.api.BillingClient;
-import com.android.billingclient.api.Purchase;
-import com.android.billingclient.api.PurchasesUpdatedListener;
-
 
 @CapacitorPlugin(name = "Purchases")
 public class PurchasesPlugin extends Plugin {
 
-    private Purchases implementation;
-
-    private BillingClient billingClient;
-
-    public PurchasesPlugin () {
-
-    }
-
-    // This listener is fired upon completing the billing flow, it is vital to call the acknowledgePurchase
-    // method on the billingClient, with the purchase token otherwise Google will automatically cancel the subscription
-    // shortly after the purchase
-    private final PurchasesUpdatedListener purchasesUpdatedListener = (billingResult, purchases) -> {
-
-        JSObject response = new JSObject();
-
-        if(purchases != null) {
-            for (int i = 0; i < purchases.size(); i++) {
-
-                Purchase currentPurchase = purchases.get(i);
-                if (!currentPurchase.isAcknowledged() && billingResult.getResponseCode() == 0 && currentPurchase.getPurchaseState() != 2) {
-
-                    AcknowledgePurchaseParams acknowledgePurchaseParams = AcknowledgePurchaseParams.newBuilder()
-                            .setPurchaseToken(currentPurchase.getPurchaseToken())
-                            .build();
+  private Purchases implementation;
 
-                    billingClient.acknowledgePurchase(acknowledgePurchaseParams, billingResult1 -> {
-                        Log.i("Purchase ack", currentPurchase.getOriginalJson());
-                        billingResult1.getResponseCode();
 
-                        response.put("successful", billingResult1.getResponseCode());
+  public PurchasesPlugin () {
+  }
 
-                        // WARNING: Changed the notifyListeners method from protected to public in order to get the method call to work
-                        // This may be a security issue in the future - in order to fix it, it may be best to move this listener + the billingClient
-                        // initiation into the SubscriptionsPlugin.java, then pass it into this implementation class so we can still access the
-                        // billingClient.
-                        notifyListeners("ANDROID-PURCHASE-RESPONSE", response);
-                    });
-                } else {
-                    response.put("successful", false);
-                    notifyListeners("ANDROID-PURCHASE-RESPONSE", response);
-                }
 
-            }
-        } else {
-            response.put("successful", false);
-            notifyListeners("ANDROID-PURCHASE-RESPONSE", response);
-        }
+  @Override
+  public void load() {
+    implementation = new Purchases(this);
+  }
 
-    };
-
-    @Override
-    public void load() {
-
-        this.billingClient = BillingClient.newBuilder(getContext())
-                .setListener(purchasesUpdatedListener)
-                .enablePendingPurchases()
-                .build();
-        implementation = new Purchases(this, billingClient);
+  @PluginMethod
+  public void setGoogleVerificationDetails(PluginCall call) {
+    String googleVerifyEndpoint = call.getString("googleVerifyEndpoint");
+    String bid = call.getString("bid");
 
+    if(googleVerifyEndpoint != null && bid != null) {
+      implementation.setGoogleVerificationDetails(googleVerifyEndpoint, bid);
+    } else {
+      call.reject("Missing required parameters");
     }
+  }
 
-    @PluginMethod
-    public void setGoogleVerificationDetails(PluginCall call) {
-        String googleVerifyEndpoint = call.getString("googleVerifyEndpoint");
-        String bid = call.getString("bid");
+  @PluginMethod
+  public void echo(PluginCall call) {
+    String value = call.getString("value");
 
-        if(googleVerifyEndpoint != null && bid != null) {
-            implementation.setGoogleVerificationDetails(googleVerifyEndpoint, bid);
-        } else {
-            call.reject("Missing required parameters");
-        }
-    }
+    JSObject ret = new JSObject();
+    ret.put("value", implementation.echo(value));
+    call.resolve(ret);
+  }
 
-    @PluginMethod
-    public void echo(PluginCall call) {
-        String value = call.getString("value");
+  @PluginMethod
+  public void getProductDetails(PluginCall call) {
 
-        JSObject ret = new JSObject();
-        ret.put("value", implementation.echo(value));
-        call.resolve(ret);
+    String productIdentifier = call.getString("productIdentifier");
+
+    if (productIdentifier == null) {
+      call.reject("Must provide a productID");
     }
 
-    @PluginMethod
-    public void getProductDetails(PluginCall call) {
+    implementation.getProductDetails(productIdentifier, call);
 
-        String productIdentifier = call.getString("productIdentifier");
+  }
 
-        if (productIdentifier == null) {
-            call.reject("Must provide a productID");
-        }
+  @PluginMethod
+  public void purchaseProduct(PluginCall call) {
 
-        implementation.getProductDetails(productIdentifier, call);
+    String productIdentifier = call.getString("productIdentifier");
+    String accountToken = call.getString("accountToken", "");
 
+    if(productIdentifier == null) {
+      call.reject("Must provide a productID");
     }
 
-    @PluginMethod
-    public void purchaseProduct(PluginCall call) {
+    implementation.purchaseProduct(productIdentifier, accountToken, call);
 
-        String productIdentifier = call.getString("productIdentifier");
-        String accountToken = call.getString("accountToken", "");
+  }
 
-        if(productIdentifier == null) {
-            call.reject("Must provide a productID");
-        }
+  @PluginMethod
+  public void getLatestTransaction(PluginCall call) {
 
-        implementation.purchaseProduct(productIdentifier, accountToken, call);
+    String productIdentifier = call.getString("productIdentifier");
 
+    if(productIdentifier == null) {
+      call.reject("Must provide a productID");
     }
 
-    @PluginMethod
-    public void getLatestTransaction(PluginCall call) {
+    implementation.getLatestTransaction(productIdentifier, call);
 
-        String productIdentifier = call.getString("productIdentifier");
+  }
 
-        if(productIdentifier == null) {
-            call.reject("Must provide a productID");
-        }
+  @PluginMethod
+  public void getCurrentEntitlements(PluginCall call) {
 
-        implementation.getLatestTransaction(productIdentifier, call);
+    implementation.getCurrentEntitlements(call);
 
-    }
+  }
 
-    @PluginMethod
-    public void getCurrentEntitlements(PluginCall call) {
+  @PluginMethod
+  public void manageSubscriptions(PluginCall call) {
 
-        implementation.getCurrentEntitlements(call);
+    String productIdentifier = call.getString("productIdentifier");
+    String bid = call.getString("bid");
 
+    if(productIdentifier == null) {
+      call.reject("Must provide a productID");
     }
 
-    @PluginMethod
-    public void manageSubscriptions(PluginCall call) {
-
-        String productIdentifier = call.getString("productIdentifier");
-        String bid = call.getString("bid");
-
-        if(productIdentifier == null) {
-            call.reject("Must provide a productID");
-        }
-
-        if(bid == null) {
-            call.reject("Must provide a bundleID");
-        }
-
-        Intent browserIntent = new Intent(Intent.ACTION_VIEW,
-                Uri.parse("https://play.google.com/store/account/subscriptions?sku=" + productIdentifier + "&package=" + bid));
-        getActivity().startActivity(browserIntent);
+    if(bid == null) {
+      call.reject("Must provide a bundleID");
     }
+
+    Intent browserIntent = new Intent(Intent.ACTION_VIEW,
+      Uri.parse("https://play.google.com/store/account/subscriptions?sku=" + productIdentifier + "&package=" + bid));
+    getActivity().startActivity(browserIntent);
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-native-purchases",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "IAP Purchases integration for iOS and Android",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",