react-native-iap 14.4.11 → 14.4.12

package/plugin/src/withIAP.ts

@@ -4,6 +4,8 @@ import {
   withAndroidManifest,
   withAppBuildGradle,
   withPodfile,
+  withEntitlementsPlist,
+  withInfoPlist,
 } from 'expo/config-plugins';
 import type {ConfigPlugin} from 'expo/config-plugins';
 import type {ExpoConfig} from '@expo/config-types';
@@ -165,6 +167,154 @@ const withIapAndroid: ConfigPlugin = (config) => {
   return config;
 };
 
+export interface IosAlternativeBillingConfig {
+  /** Country codes where external purchases are supported (ISO 3166-1 alpha-2) */
+  countries?: string[];
+  /** External purchase URLs per country (iOS 15.4+) */
+  links?: Record<string, string>;
+  /** Multiple external purchase URLs per country (iOS 17.5+, up to 5 per country) */
+  multiLinks?: Record<string, string[]>;
+  /** Custom link regions (iOS 18.1+) */
+  customLinkRegions?: string[];
+  /** Streaming link regions for music apps (iOS 18.2+) */
+  streamingLinkRegions?: string[];
+  /** Enable external purchase link entitlement */
+  enableExternalPurchaseLink?: boolean;
+  /** Enable external purchase link streaming entitlement (music apps only) */
+  enableExternalPurchaseLinkStreaming?: boolean;
+}
+
+/** Add external purchase entitlements and Info.plist configuration */
+const withIosAlternativeBilling: ConfigPlugin<
+  IosAlternativeBillingConfig | undefined
+> = (config, options) => {
+  if (!options || !options.countries || options.countries.length === 0) {
+    return config;
+  }
+
+  // Add entitlements
+  config = withEntitlementsPlist(config, (config) => {
+    // Always add basic external purchase entitlement when countries are specified
+    config.modResults['com.apple.developer.storekit.external-purchase'] = true;
+    if (!hasLoggedPluginExecution) {
+      console.log(
+        '✅ Added com.apple.developer.storekit.external-purchase to entitlements',
+      );
+    }
+
+    // Add external purchase link entitlement if enabled
+    if (options.enableExternalPurchaseLink) {
+      config.modResults['com.apple.developer.storekit.external-purchase-link'] =
+        true;
+      if (!hasLoggedPluginExecution) {
+        console.log(
+          '✅ Added com.apple.developer.storekit.external-purchase-link to entitlements',
+        );
+      }
+    }
+
+    // Add streaming entitlement if enabled
+    if (options.enableExternalPurchaseLinkStreaming) {
+      config.modResults[
+        'com.apple.developer.storekit.external-purchase-link-streaming'
+      ] = true;
+      if (!hasLoggedPluginExecution) {
+        console.log(
+          '✅ Added com.apple.developer.storekit.external-purchase-link-streaming to entitlements',
+        );
+      }
+    }
+
+    return config;
+  });
+
+  // Add Info.plist configuration
+  config = withInfoPlist(config, (config) => {
+    const plist = config.modResults;
+
+    // Helper function to normalize country codes to uppercase
+    const normalize = (code: string) => code.trim().toUpperCase();
+
+    // 1. SKExternalPurchase (Required)
+    const normalizedCountries = options.countries?.map(normalize);
+    plist.SKExternalPurchase = normalizedCountries;
+    if (!hasLoggedPluginExecution) {
+      console.log(
+        `✅ Added SKExternalPurchase with countries: ${normalizedCountries?.join(
+          ', ',
+        )}`,
+      );
+    }
+
+    // 2. SKExternalPurchaseLink (Optional - iOS 15.4+)
+    if (options.links && Object.keys(options.links).length > 0) {
+      plist.SKExternalPurchaseLink = Object.fromEntries(
+        Object.entries(options.links).map(([code, url]) => [
+          normalize(code),
+          url,
+        ]),
+      );
+      if (!hasLoggedPluginExecution) {
+        console.log(
+          `✅ Added SKExternalPurchaseLink for ${
+            Object.keys(options.links).length
+          } countries`,
+        );
+      }
+    }
+
+    // 3. SKExternalPurchaseMultiLink (iOS 17.5+)
+    if (options.multiLinks && Object.keys(options.multiLinks).length > 0) {
+      plist.SKExternalPurchaseMultiLink = Object.fromEntries(
+        Object.entries(options.multiLinks).map(([code, urls]) => [
+          normalize(code),
+          urls,
+        ]),
+      );
+      if (!hasLoggedPluginExecution) {
+        console.log(
+          `✅ Added SKExternalPurchaseMultiLink for ${
+            Object.keys(options.multiLinks).length
+          } countries`,
+        );
+      }
+    }
+
+    // 4. SKExternalPurchaseCustomLinkRegions (iOS 18.1+)
+    if (options.customLinkRegions && options.customLinkRegions.length > 0) {
+      plist.SKExternalPurchaseCustomLinkRegions =
+        options.customLinkRegions.map(normalize);
+      if (!hasLoggedPluginExecution) {
+        console.log(
+          `✅ Added SKExternalPurchaseCustomLinkRegions: ${options.customLinkRegions
+            .map(normalize)
+            .join(', ')}`,
+        );
+      }
+    }
+
+    // 5. SKExternalPurchaseLinkStreamingRegions (iOS 18.2+)
+    if (
+      options.streamingLinkRegions &&
+      options.streamingLinkRegions.length > 0
+    ) {
+      plist.SKExternalPurchaseLinkStreamingRegions =
+        options.streamingLinkRegions.map(normalize);
+      if (!hasLoggedPluginExecution) {
+        console.log(
+          `✅ Added SKExternalPurchaseLinkStreamingRegions: ${options.streamingLinkRegions
+            .map(normalize)
+            .join(', ')}`,
+        );
+      }
+    }
+
+    return config;
+  });
+
+  return config;
+};
+
 type IapPluginProps = {
   ios?: {
     // Enable to inject Folly coroutine-disabling macros into Podfile during prebuild
@@ -172,6 +322,13 @@ type IapPluginProps = {
     // @deprecated Use 'with-folly-no-coroutines'. Kept for backward compatibility.
     'with-folly-no-couroutines'?: boolean;
   };
+  /**
+   * iOS Alternative Billing configuration.
+   * Configure external purchase countries, links, and entitlements.
+   * Requires approval from Apple.
+   * @platform ios
+   */
+  iosAlternativeBilling?: IosAlternativeBillingConfig;
 };
 
 const withIapIosFollyWorkaround: ConfigPlugin<IapPluginProps | undefined> = (
@@ -236,6 +393,10 @@ const withIAP: ConfigPlugin<IapPluginProps | undefined> = (config, props) => {
   try {
     let result = withIapAndroid(config);
     result = withIapIosFollyWorkaround(result, props);
+    // Add iOS alternative billing configuration if provided
+    if (props?.iosAlternativeBilling) {
+      result = withIosAlternativeBilling(result, props.iosAlternativeBilling);
+    }
     // Set flag after first execution to prevent duplicate logs
     hasLoggedPluginExecution = true;
     return result;
@@ -270,4 +431,5 @@ const pluginExport: IapPluginCallable = ((
   props?: IapPluginProps,
 ) => _wrapped(config, props)) as unknown as IapPluginCallable;
 
+export {withIosAlternativeBilling};
 export {pluginExport as default};

package/src/hooks/useIAP.ts

@@ -19,6 +19,10 @@ import {
   restorePurchases as restorePurchasesTopLevel,
   getPromotedProductIOS,
   requestPurchaseOnPromotedProductIOS,
+  checkAlternativeBillingAvailabilityAndroid,
+  showAlternativeBillingDialogAndroid,
+  createAlternativeBillingTokenAndroid,
+  userChoiceBillingListenerAndroid,
 } from '../';
 
 // Types
@@ -27,6 +31,8 @@ import type {
   ProductQueryType,
   RequestPurchaseProps,
   RequestPurchaseResult,
+  AlternativeBillingModeAndroid,
+  UserChoiceBillingDetails,
 } from '../types';
 import type {
   ActiveSubscription,
@@ -75,12 +81,20 @@ type UseIap = {
     subscriptionIds?: string[],
   ) => Promise<ActiveSubscription[]>;
   hasActiveSubscriptions: (subscriptionIds?: string[]) => Promise<boolean>;
+  // Alternative billing (Android)
+  checkAlternativeBillingAvailabilityAndroid?: () => Promise<boolean>;
+  showAlternativeBillingDialogAndroid?: () => Promise<boolean>;
+  createAlternativeBillingTokenAndroid?: (
+    sku?: string,
+  ) => Promise<string | null>;
 };
 
 export interface UseIapOptions {
   onPurchaseSuccess?: (purchase: Purchase) => void;
   onPurchaseError?: (error: PurchaseError) => void;
   onPromotedProductIOS?: (product: Product) => void;
+  onUserChoiceBillingAndroid?: (details: UserChoiceBillingDetails) => void;
+  alternativeBillingModeAndroid?: AlternativeBillingModeAndroid;
 }
 
 /**
@@ -133,6 +147,7 @@ export function useIAP(options?: UseIapOptions): UseIap {
     purchaseUpdate?: EventSubscription;
     purchaseError?: EventSubscription;
     promotedProductIOS?: EventSubscription;
+    userChoiceBillingAndroid?: EventSubscription;
   }>({});
 
   const subscriptionsRefState = useRef<ProductSubscription[]>([]);
@@ -346,7 +361,29 @@ export function useIAP(options?: UseIapOptions): UseIap {
       );
     }
 
-    const result = await initConnection();
+    // 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);
+          }
+        });
+    }
+
+    // Initialize connection with config
+    const config =
+      Platform.OS === 'android' &&
+      optionsRef.current?.alternativeBillingModeAndroid
+        ? {
+            alternativeBillingModeAndroid:
+              optionsRef.current.alternativeBillingModeAndroid,
+          }
+        : undefined;
+    const result = await initConnection(config);
     setConnected(result);
     if (!result) {
       // Clean up some listeners but leave purchaseError for potential retries
@@ -364,6 +401,7 @@ export function useIAP(options?: UseIapOptions): UseIap {
       currentSubscriptions.purchaseUpdate?.remove();
       currentSubscriptions.purchaseError?.remove();
       currentSubscriptions.promotedProductIOS?.remove();
+      currentSubscriptions.userChoiceBillingAndroid?.remove();
       // Keep connection alive across screens to avoid race conditions
       setConnected(false);
     };
@@ -393,5 +431,13 @@ export function useIAP(options?: UseIapOptions): UseIap {
     requestPurchaseOnPromotedProductIOS,
     getActiveSubscriptions: getActiveSubscriptionsInternal,
     hasActiveSubscriptions: hasActiveSubscriptionsInternal,
+    // Alternative billing (Android only)
+    ...(Platform.OS === 'android'
+      ? {
+          checkAlternativeBillingAvailabilityAndroid,
+          showAlternativeBillingDialogAndroid,
+          createAlternativeBillingTokenAndroid,
+        }
+      : {}),
   };
 }

package/src/index.ts

@@ -292,6 +292,82 @@ export const promotedProductListenerIOS = (
   };
 };
 
+/**
+ * Add a listener for user choice billing events (Android only).
+ * Fires when a user selects alternative billing in the User Choice Billing dialog.
+ *
+ * @param listener - Function to call when user chooses alternative billing
+ * @returns EventSubscription with remove() method to unsubscribe
+ * @platform Android
+ *
+ * @example
+ * ```typescript
+ * const subscription = userChoiceBillingListenerAndroid((details) => {
+ *   console.log('User chose alternative billing');
+ *   console.log('Products:', details.products);
+ *   console.log('Token:', details.externalTransactionToken);
+ *
+ *   // Send token to backend for Google Play reporting
+ *   await reportToGooglePlay(details.externalTransactionToken);
+ * });
+ *
+ * // Later, remove the listener
+ * subscription.remove();
+ * ```
+ */
+type NitroUserChoiceBillingListener = Parameters<
+  RnIap['addUserChoiceBillingListenerAndroid']
+>[0];
+const userChoiceBillingListenerMap = new WeakMap<
+  (details: any) => void,
+  NitroUserChoiceBillingListener
+>();
+
+export const userChoiceBillingListenerAndroid = (
+  listener: (details: any) => void,
+): EventSubscription => {
+  if (Platform.OS !== 'android') {
+    RnIapConsole.warn(
+      'userChoiceBillingListenerAndroid: This listener is only available on Android',
+    );
+    return {remove: () => {}};
+  }
+
+  const wrappedListener: NitroUserChoiceBillingListener = (details) => {
+    listener(details);
+  };
+
+  userChoiceBillingListenerMap.set(listener, wrappedListener);
+  let attached = false;
+  try {
+    IAP.instance.addUserChoiceBillingListenerAndroid(wrappedListener);
+    attached = true;
+  } catch (e) {
+    const msg = toErrorMessage(e);
+    if (msg.includes('Nitro runtime not installed')) {
+      RnIapConsole.warn(
+        '[userChoiceBillingListenerAndroid] Nitro not ready yet; listener inert until initConnection()',
+      );
+    } else {
+      throw e;
+    }
+  }
+
+  return {
+    remove: () => {
+      const wrapped = userChoiceBillingListenerMap.get(listener);
+      if (wrapped) {
+        if (attached) {
+          try {
+            IAP.instance.removeUserChoiceBillingListenerAndroid(wrapped);
+          } catch {}
+        }
+        userChoiceBillingListenerMap.delete(listener);
+      }
+    },
+  };
+};
+
 // ------------------------------
 // Query API
 // ------------------------------
@@ -832,10 +908,32 @@ export const getTransactionJwsIOS: QueryField<'getTransactionJwsIOS'> = async (
 
 /**
  * Initialize connection to the store
+ * @param config - Optional configuration including alternative billing mode for Android
+ * @param config.alternativeBillingModeAndroid - Alternative billing mode: 'none', 'user-choice', or 'alternative-only'
+ *
+ * @example
+ * ```typescript
+ * // Standard billing (default)
+ * await initConnection();
+ *
+ * // User choice billing (Android)
+ * await initConnection({
+ *   alternativeBillingModeAndroid: 'user-choice'
+ * });
+ *
+ * // Alternative billing only (Android)
+ * await initConnection({
+ *   alternativeBillingModeAndroid: 'alternative-only'
+ * });
+ * ```
  */
-export const initConnection: MutationField<'initConnection'> = async () => {
+export const initConnection: MutationField<'initConnection'> = async (
+  config,
+) => {
   try {
-    return await IAP.instance.initConnection();
+    return await IAP.instance.initConnection(
+      config as Record<string, unknown> | undefined,
+    );
   } catch (error) {
     RnIapConsole.error('Failed to initialize IAP connection:', error);
     throw error;
@@ -1648,3 +1746,216 @@ const normalizeProductQueryType = (
   }
   return 'in-app';
 };
+
+// ============================================================================
+// ALTERNATIVE BILLING APIs
+// ============================================================================
+
+// ------------------------------
+// Android Alternative Billing
+// ------------------------------
+
+/**
+ * Check if alternative billing is available for this user/device (Android only).
+ * Step 1 of alternative billing flow.
+ *
+ * @returns Promise<boolean> - true if available, false otherwise
+ * @throws Error if billing client not ready
+ * @platform Android
+ *
+ * @example
+ * ```typescript
+ * const isAvailable = await checkAlternativeBillingAvailabilityAndroid();
+ * if (isAvailable) {
+ *   // Proceed with alternative billing flow
+ * }
+ * ```
+ */
+export const checkAlternativeBillingAvailabilityAndroid: MutationField<
+  'checkAlternativeBillingAvailabilityAndroid'
+> = async () => {
+  if (Platform.OS !== 'android') {
+    throw new Error('Alternative billing is only supported on Android');
+  }
+  try {
+    return await IAP.instance.checkAlternativeBillingAvailabilityAndroid();
+  } catch (error) {
+    RnIapConsole.error(
+      'Failed to check alternative billing availability:',
+      error,
+    );
+    throw error;
+  }
+};
+
+/**
+ * Show alternative billing information dialog to user (Android only).
+ * Step 2 of alternative billing flow.
+ * Must be called BEFORE processing payment in your payment system.
+ *
+ * @returns Promise<boolean> - true if user accepted, false if user canceled
+ * @throws Error if billing client not ready
+ * @platform Android
+ *
+ * @example
+ * ```typescript
+ * const userAccepted = await showAlternativeBillingDialogAndroid();
+ * if (userAccepted) {
+ *   // Process payment in your payment system
+ *   const success = await processCustomPayment();
+ *   if (success) {
+ *     // Create reporting token
+ *     const token = await createAlternativeBillingTokenAndroid();
+ *     // Send token to your backend for Google Play reporting
+ *   }
+ * }
+ * ```
+ */
+export const showAlternativeBillingDialogAndroid: MutationField<
+  'showAlternativeBillingDialogAndroid'
+> = async () => {
+  if (Platform.OS !== 'android') {
+    throw new Error('Alternative billing is only supported on Android');
+  }
+  try {
+    return await IAP.instance.showAlternativeBillingDialogAndroid();
+  } catch (error) {
+    RnIapConsole.error('Failed to show alternative billing dialog:', error);
+    throw error;
+  }
+};
+
+/**
+ * Create external transaction token for Google Play reporting (Android only).
+ * Step 3 of alternative billing flow.
+ * Must be called AFTER successful payment in your payment system.
+ * Token must be reported to Google Play backend within 24 hours.
+ *
+ * @param sku - Optional product SKU that was purchased
+ * @returns Promise<string | null> - Token string or null if creation failed
+ * @throws Error if billing client not ready
+ * @platform Android
+ *
+ * @example
+ * ```typescript
+ * const token = await createAlternativeBillingTokenAndroid('premium_subscription');
+ * if (token) {
+ *   // Send token to your backend
+ *   await fetch('/api/report-transaction', {
+ *     method: 'POST',
+ *     body: JSON.stringify({ token, sku: 'premium_subscription' })
+ *   });
+ * }
+ * ```
+ */
+export const createAlternativeBillingTokenAndroid: MutationField<
+  'createAlternativeBillingTokenAndroid'
+> = async (sku?: string) => {
+  if (Platform.OS !== 'android') {
+    throw new Error('Alternative billing is only supported on Android');
+  }
+  try {
+    return await IAP.instance.createAlternativeBillingTokenAndroid(sku ?? null);
+  } catch (error) {
+    RnIapConsole.error('Failed to create alternative billing token:', error);
+    throw error;
+  }
+};
+
+// ------------------------------
+// iOS External Purchase
+// ------------------------------
+
+/**
+ * Check if the device can present an external purchase notice sheet (iOS 18.2+).
+ *
+ * @returns Promise<boolean> - true if notice sheet can be presented
+ * @platform iOS
+ *
+ * @example
+ * ```typescript
+ * const canPresent = await canPresentExternalPurchaseNoticeIOS();
+ * if (canPresent) {
+ *   // Present notice before external purchase
+ *   const result = await presentExternalPurchaseNoticeSheetIOS();
+ * }
+ * ```
+ */
+export const canPresentExternalPurchaseNoticeIOS: QueryField<
+  'canPresentExternalPurchaseNoticeIOS'
+> = async () => {
+  if (Platform.OS !== 'ios') {
+    return false;
+  }
+  try {
+    return await IAP.instance.canPresentExternalPurchaseNoticeIOS();
+  } catch (error) {
+    RnIapConsole.error(
+      'Failed to check external purchase notice availability:',
+      error,
+    );
+    return false;
+  }
+};
+
+/**
+ * Present an external purchase notice sheet to inform users about external purchases (iOS 18.2+).
+ * This must be called before opening an external purchase link.
+ *
+ * @returns Promise<ExternalPurchaseNoticeResultIOS> - Result with action and error if any
+ * @platform iOS
+ *
+ * @example
+ * ```typescript
+ * const result = await presentExternalPurchaseNoticeSheetIOS();
+ * if (result.result === 'continue') {
+ *   // User chose to continue, open external purchase link
+ *   await presentExternalPurchaseLinkIOS('https://your-website.com/purchase');
+ * }
+ * ```
+ */
+export const presentExternalPurchaseNoticeSheetIOS: MutationField<
+  'presentExternalPurchaseNoticeSheetIOS'
+> = async () => {
+  if (Platform.OS !== 'ios') {
+    throw new Error('External purchase is only supported on iOS');
+  }
+  try {
+    return (await IAP.instance.presentExternalPurchaseNoticeSheetIOS()) as any;
+  } catch (error) {
+    RnIapConsole.error(
+      'Failed to present external purchase notice sheet:',
+      error,
+    );
+    throw error;
+  }
+};
+
+/**
+ * Present an external purchase link to redirect users to your website (iOS 16.0+).
+ *
+ * @param url - The external purchase URL to open
+ * @returns Promise<ExternalPurchaseLinkResultIOS> - Result with success status and error if any
+ * @platform iOS
+ *
+ * @example
+ * ```typescript
+ * const result = await presentExternalPurchaseLinkIOS('https://your-website.com/purchase');
+ * if (result.success) {
+ *   console.log('User completed external purchase');
+ * }
+ * ```
+ */
+export const presentExternalPurchaseLinkIOS: MutationField<
+  'presentExternalPurchaseLinkIOS'
+> = async (url) => {
+  if (Platform.OS !== 'ios') {
+    throw new Error('External purchase is only supported on iOS');
+  }
+  try {
+    return (await IAP.instance.presentExternalPurchaseLinkIOS(url)) as any;
+  } catch (error) {
+    RnIapConsole.error('Failed to present external purchase link:', error);
+    throw error;
+  }
+};