react-native-iap 14.7.17 → 14.7.19

package/src/hooks/useIAP.ts

@@ -18,7 +18,7 @@ import {
   verifyPurchaseWithProvider as verifyPurchaseWithProviderTopLevel,
   getActiveSubscriptions,
   hasActiveSubscriptions,
-  restorePurchases as restorePurchasesTopLevel,
+  syncIOS,
   getPromotedProductIOS,
   requestPurchaseOnPromotedProductIOS,
   checkAlternativeBillingAvailabilityAndroid,
@@ -40,6 +40,7 @@ import type {
   VerifyPurchaseResult,
   VerifyPurchaseWithProviderProps,
   VerifyPurchaseWithProviderResult,
+  PurchaseOptions,
 } from '../types';
 import type {
   ActiveSubscription,
@@ -63,7 +64,7 @@ type UseIap = {
   promotedProductIOS?: Product;
   activeSubscriptions: ActiveSubscription[];
   finishTransaction: (args: MutationFinishTransactionArgs) => Promise<void>;
-  getAvailablePurchases: (skus?: string[]) => Promise<void>;
+  getAvailablePurchases: (options?: PurchaseOptions) => Promise<void>;
   fetchProducts: (params: {
     skus: string[];
     type?: ProductQueryType | null;
@@ -83,13 +84,19 @@ type UseIap = {
   verifyPurchaseWithProvider: (
     options: VerifyPurchaseWithProviderProps,
   ) => Promise<VerifyPurchaseWithProviderResult>;
-  restorePurchases: () => Promise<void>;
+  restorePurchases: (options?: PurchaseOptions) => Promise<void>;
   getPromotedProductIOS: () => Promise<Product | null>;
   requestPurchaseOnPromotedProductIOS: () => Promise<boolean>;
   getActiveSubscriptions: (
     subscriptionIds?: string[],
   ) => Promise<ActiveSubscription[]>;
   hasActiveSubscriptions: (subscriptionIds?: string[]) => Promise<boolean>;
+  /**
+   * Manually retry the store connection.
+   * Useful when the initial auto-connect fails (e.g., Play Store not ready at mount time).
+   * Updates the `connected` state on success.
+   */
+  reconnect: () => Promise<boolean>;
   // Alternative billing (Android)
   checkAlternativeBillingAvailabilityAndroid?: () => Promise<boolean>;
   showAlternativeBillingDialogAndroid?: () => Promise<boolean>;
@@ -271,11 +278,13 @@ export function useIAP(options?: UseIapOptions): UseIap {
   );
 
   const getAvailablePurchasesInternal = useCallback(
-    async (_skus?: string[]): Promise<void> => {
+    async (options?: PurchaseOptions): Promise<void> => {
       try {
         const result = await getAvailablePurchases({
-          alsoPublishToEventListenerIOS: false,
-          onlyIncludeActiveItemsIOS: true,
+          alsoPublishToEventListenerIOS:
+            options?.alsoPublishToEventListenerIOS ?? false,
+          onlyIncludeActiveItemsIOS: options?.onlyIncludeActiveItemsIOS ?? true,
+          includeSuspendedAndroid: options?.includeSuspendedAndroid ?? false,
         });
         setAvailablePurchases(result);
       } catch (error) {
@@ -333,7 +342,21 @@ export function useIAP(options?: UseIapOptions): UseIap {
     [],
   );
 
-  // No local restorePurchases; use the top-level helper via returned API
+  const restorePurchases = useCallback(
+    async (options?: PurchaseOptions): Promise<void> => {
+      try {
+        if (Platform.OS === 'ios') {
+          await syncIOS();
+        }
+
+        await getAvailablePurchasesInternal(options);
+      } catch (error) {
+        RnIapConsole.warn('Failed to restore purchases:', error);
+        invokeOnError(error);
+      }
+    },
+    [getAvailablePurchasesInternal, invokeOnError],
+  );
 
   const validateReceipt = useCallback(
     async (options: VerifyPurchaseProps): Promise<VerifyPurchaseResult> =>
@@ -357,9 +380,8 @@ export function useIAP(options?: UseIapOptions): UseIap {
     [],
   );
 
-  const initIapWithSubscriptions = useCallback(async (): Promise<void> => {
-    // Initialize connection with config
-    // Prefer enableBillingProgramAndroid over deprecated alternativeBillingModeAndroid
+  // Shared helper: build Android billing config from options
+  const buildAndroidConfig = useCallback(() => {
     let config:
       | {
           enableBillingProgramAndroid?: BillingProgramAndroid;
@@ -374,7 +396,6 @@ export function useIAP(options?: UseIapOptions): UseIap {
             optionsRef.current.enableBillingProgramAndroid,
         };
       } else if (optionsRef.current?.alternativeBillingModeAndroid) {
-        // Deprecated: use alternativeBillingModeAndroid for backwards compatibility
         config = {
           alternativeBillingModeAndroid:
             optionsRef.current.alternativeBillingModeAndroid,
@@ -382,29 +403,14 @@ export function useIAP(options?: UseIapOptions): UseIap {
       }
     }
 
-    try {
-      // Initialize connection FIRST to ensure Nitro is ready
-      // This fixes tvOS where Nitro may initialize later than iOS
-      const result = await initConnection(config);
-
-      // Check if component unmounted during async initConnection
-      // to prevent listener leaks
-      if (!isMountedRef.current) {
-        return;
-      }
-
-      setConnected(result);
-
-      if (!result) {
-        RnIapConsole.warn('[useIAP] initConnection returned false');
-        return;
-      }
+    return config;
+  }, []);
 
-      // Register listeners AFTER initConnection succeeds
-      // This ensures Nitro runtime is fully initialized
+  // Shared helper: register event listeners if not already active
+  const registerListeners = useCallback(() => {
+    if (!subscriptionsRef.current.purchaseUpdate) {
       subscriptionsRef.current.purchaseUpdate = purchaseUpdatedListener(
         async (purchase: Purchase) => {
-          // Always refresh subscription state after a purchase event
           try {
             await getActiveSubscriptionsInternal();
             await getAvailablePurchasesInternal();
@@ -416,11 +422,11 @@ export function useIAP(options?: UseIapOptions): UseIap {
           }
         },
       );
+    }
 
+    if (!subscriptionsRef.current.purchaseError) {
       subscriptionsRef.current.purchaseError = purchaseErrorListener(
         (error) => {
-          // error is already normalized by purchaseErrorListener in src/index.ts
-          // Ignore init error until connected
           if (
             error.code === ErrorCode.InitConnection &&
             !connectedRef.current
@@ -432,65 +438,113 @@ export function useIAP(options?: UseIapOptions): UseIap {
           }
         },
       );
+    }
+
+    if (isStandardIOS() && !subscriptionsRef.current.promotedProductIOS) {
+      subscriptionsRef.current.promotedProductIOS = promotedProductListenerIOS(
+        (product: Product) => {
+          setPromotedProductIOS(product);
+          if (optionsRef.current?.onPromotedProductIOS) {
+            optionsRef.current.onPromotedProductIOS(product);
+          }
+        },
+      );
+    }
+
+    if (
+      Platform.OS === 'android' &&
+      optionsRef.current?.onUserChoiceBillingAndroid &&
+      !subscriptionsRef.current.userChoiceBillingAndroid
+    ) {
+      subscriptionsRef.current.userChoiceBillingAndroid =
+        userChoiceBillingListenerAndroid((details) => {
+          if (optionsRef.current?.onUserChoiceBillingAndroid) {
+            optionsRef.current.onUserChoiceBillingAndroid(details);
+          }
+        });
+    }
+  }, [getActiveSubscriptionsInternal, getAvailablePurchasesInternal]);
+
+  // Shared helper: clean up all listeners
+  const cleanupListeners = useCallback(() => {
+    subscriptionsRef.current.purchaseUpdate?.remove();
+    subscriptionsRef.current.purchaseError?.remove();
+    subscriptionsRef.current.promotedProductIOS?.remove();
+    subscriptionsRef.current.userChoiceBillingAndroid?.remove();
+    subscriptionsRef.current.purchaseUpdate = undefined;
+    subscriptionsRef.current.purchaseError = undefined;
+    subscriptionsRef.current.promotedProductIOS = undefined;
+    subscriptionsRef.current.userChoiceBillingAndroid = undefined;
+  }, []);
 
-      // iOS promoted products listener (only supported on standard iOS, not tvOS/macOS)
-      if (isStandardIOS()) {
-        subscriptionsRef.current.promotedProductIOS =
-          promotedProductListenerIOS((product: Product) => {
-            setPromotedProductIOS(product);
+  const initIapWithSubscriptions = useCallback(async (): Promise<void> => {
+    const config = buildAndroidConfig();
 
-            if (optionsRef.current?.onPromotedProductIOS) {
-              optionsRef.current.onPromotedProductIOS(product);
-            }
-          });
+    try {
+      const result = await initConnection(config);
+
+      if (!isMountedRef.current) {
+        return;
       }
 
-      // Add user choice billing listener for Android (if provided)
-      if (
-        Platform.OS === 'android' &&
-        optionsRef.current?.onUserChoiceBillingAndroid
-      ) {
-        subscriptionsRef.current.userChoiceBillingAndroid =
-          userChoiceBillingListenerAndroid((details) => {
-            if (optionsRef.current?.onUserChoiceBillingAndroid) {
-              optionsRef.current.onUserChoiceBillingAndroid(details);
-            }
-          });
+      if (!result) {
+        setConnected(false);
+        RnIapConsole.warn('[useIAP] initConnection returned false');
+        return;
       }
+
+      registerListeners();
+      setConnected(true);
     } catch (error) {
       RnIapConsole.error('initConnection failed:', error);
+      cleanupListeners();
+      if (isMountedRef.current) {
+        setConnected(false);
+      }
       invokeOnError(error);
-      // Clean up listeners on error (if any were registered)
-      subscriptionsRef.current.purchaseUpdate?.remove();
-      subscriptionsRef.current.purchaseError?.remove();
-      subscriptionsRef.current.promotedProductIOS?.remove();
-      subscriptionsRef.current.userChoiceBillingAndroid?.remove();
-      subscriptionsRef.current.purchaseUpdate = undefined;
-      subscriptionsRef.current.purchaseError = undefined;
-      subscriptionsRef.current.promotedProductIOS = undefined;
-      subscriptionsRef.current.userChoiceBillingAndroid = undefined;
     }
-  }, [
-    getActiveSubscriptionsInternal,
-    getAvailablePurchasesInternal,
-    invokeOnError,
-  ]);
+  }, [buildAndroidConfig, registerListeners, cleanupListeners, invokeOnError]);
+
+  const reconnect = useCallback(async (): Promise<boolean> => {
+    const config = buildAndroidConfig();
+
+    try {
+      const result = await initConnection(config);
+
+      if (!isMountedRef.current) {
+        return false;
+      }
+
+      if (result) {
+        registerListeners();
+        setConnected(true);
+        return true;
+      }
+
+      setConnected(false);
+      return false;
+    } catch (error) {
+      RnIapConsole.error('[useIAP] reconnect failed:', error);
+      cleanupListeners();
+      if (isMountedRef.current) {
+        setConnected(false);
+      }
+      invokeOnError(error);
+      return false;
+    }
+  }, [buildAndroidConfig, registerListeners, cleanupListeners, invokeOnError]);
 
   useEffect(() => {
     isMountedRef.current = true;
     initIapWithSubscriptions();
-    const currentSubscriptions = subscriptionsRef.current;
 
     return () => {
       isMountedRef.current = false;
-      currentSubscriptions.purchaseUpdate?.remove();
-      currentSubscriptions.purchaseError?.remove();
-      currentSubscriptions.promotedProductIOS?.remove();
-      currentSubscriptions.userChoiceBillingAndroid?.remove();
+      cleanupListeners();
       // Keep connection alive across screens to avoid race conditions
       setConnected(false);
     };
-  }, [initIapWithSubscriptions]);
+  }, [initIapWithSubscriptions, cleanupListeners]);
 
   return {
     connected,
@@ -506,19 +560,12 @@ export function useIAP(options?: UseIapOptions): UseIap {
     validateReceipt,
     verifyPurchase,
     verifyPurchaseWithProvider,
-    restorePurchases: async () => {
-      try {
-        await restorePurchasesTopLevel();
-        await getAvailablePurchasesInternal();
-      } catch (error) {
-        RnIapConsole.warn('Failed to restore purchases:', error);
-        invokeOnError(error);
-      }
-    },
+    restorePurchases,
     getPromotedProductIOS,
     requestPurchaseOnPromotedProductIOS,
     getActiveSubscriptions: getActiveSubscriptionsInternal,
     hasActiveSubscriptions: hasActiveSubscriptionsInternal,
+    reconnect,
     // Alternative billing (Android only)
     ...(Platform.OS === 'android'
       ? {

package/src/index.ts

@@ -737,11 +737,14 @@ export const getAvailablePurchases: QueryField<
       return validPurchases.map(convertNitroPurchaseToPurchase);
     } else if (Platform.OS === 'android') {
       // For Android, we need to call twice for inapp and subs
+      const includeSuspended = Boolean(
+        options?.includeSuspendedAndroid ?? false,
+      );
       const inappNitroPurchases = await IAP.instance.getAvailablePurchases({
-        android: {type: 'inapp'},
+        android: {type: 'inapp', includeSuspended},
       });
       const subsNitroPurchases = await IAP.instance.getAvailablePurchases({
-        android: {type: 'subs'},
+        android: {type: 'subs', includeSuspended},
       });
 
       // Validate and convert both sets of purchases

package/src/utils/error.ts

@@ -95,3 +95,9 @@ export function isUserCancelledError(
     errorObj.responseCode === 1
   ); // Android BillingClient.BillingResponseCode.USER_CANCELED
 }
+
+// Re-export from errorMapping for public API convenience
+export {
+  isDuplicatePurchaseError,
+  DUPLICATE_PURCHASE_CODE,
+} from './errorMapping';

package/src/utils/errorMapping.ts

@@ -6,6 +6,13 @@
 
 import {ErrorCode, type IapPlatform} from '../types';
 
+/**
+ * Error code for duplicate purchase events detected on iOS.
+ * Defined here because it originates from react-native-iap's dedup logic,
+ * not from the OpenIAP upstream that generates src/types.ts.
+ */
+export const DUPLICATE_PURCHASE_CODE = 'duplicate-purchase' as const;
+
 const ERROR_CODE_ALIASES: Record<string, ErrorCode> = {
   E_USER_CANCELED: ErrorCode.UserCancelled,
   USER_CANCELED: ErrorCode.UserCancelled,
@@ -271,6 +278,10 @@ export function isUserCancelledError(error: unknown): boolean {
   return extractCode(error) === ErrorCode.UserCancelled;
 }
 
+export function isDuplicatePurchaseError(error: unknown): boolean {
+  return extractCode(error) === DUPLICATE_PURCHASE_CODE;
+}
+
 export function isNetworkError(error: unknown): boolean {
   const networkErrors: ErrorCode[] = [
     ErrorCode.NetworkError,
@@ -296,6 +307,7 @@ export function isRecoverableError(error: unknown): boolean {
     ErrorCode.InitConnection,
     ErrorCode.SyncError,
     ErrorCode.ConnectionClosed,
+    DUPLICATE_PURCHASE_CODE,
   ];
 
   const code = extractCode(error);
@@ -326,6 +338,8 @@ export function getUserFriendlyErrorMessage(error: ErrorLike): string {
       return 'Selected offer does not match the SKU';
     case ErrorCode.DeferredPayment:
       return 'Payment is pending approval';
+    case DUPLICATE_PURCHASE_CODE:
+      return 'This purchase has already been processed. Try restoring purchases.';
     case ErrorCode.NotPrepared:
       return 'In-app purchase is not ready. Please try again later.';
     case ErrorCode.ServiceError: