react-native-iap 14.5.0 → 14.6.0-rc.1

package/android/src/main/java/com/margelo/nitro/iap/HybridRnIap.kt

@@ -31,6 +31,11 @@ import dev.hyo.openiap.InitConnectionConfig as OpenIapInitConnectionConfig
 import dev.hyo.openiap.listener.OpenIapPurchaseErrorListener
 import dev.hyo.openiap.listener.OpenIapPurchaseUpdateListener
 import dev.hyo.openiap.listener.OpenIapUserChoiceBillingListener
+import dev.hyo.openiap.BillingProgramAndroid as OpenIapBillingProgramAndroid
+import dev.hyo.openiap.LaunchExternalLinkParamsAndroid as OpenIapLaunchExternalLinkParams
+import dev.hyo.openiap.ExternalLinkLaunchModeAndroid as OpenIapExternalLinkLaunchMode
+import dev.hyo.openiap.ExternalLinkTypeAndroid as OpenIapExternalLinkType
+import dev.hyo.openiap.store.OpenIapStore
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.CompletableDeferred
@@ -815,20 +820,59 @@ class HybridRnIap : HybridRnIapSpec() {
             is ProductAndroid -> product.subscriptionOfferDetailsAndroid.orEmpty()
             else -> emptyList()
         }
-        val oneTimeOffer = when (product) {
+        val oneTimeOffers = when (product) {
             is ProductSubscriptionAndroid -> product.oneTimePurchaseOfferDetailsAndroid
             is ProductAndroid -> product.oneTimePurchaseOfferDetailsAndroid
             else -> null
         }
 
         val subscriptionOffersJson = subscriptionOffers.takeIf { it.isNotEmpty() }?.let { serializeSubscriptionOffers(it) }
-        val oneTimeOfferNitro = oneTimeOffer?.let { otp ->
+        val oneTimeOffersNitro = oneTimeOffers?.map { otp ->
             NitroOneTimePurchaseOfferDetail(
                 formattedPrice = otp.formattedPrice,
                 priceAmountMicros = otp.priceAmountMicros,
-                priceCurrencyCode = otp.priceCurrencyCode
+                priceCurrencyCode = otp.priceCurrencyCode,
+                offerId = otp.offerId,
+                offerToken = otp.offerToken,
+                offerTags = otp.offerTags.toTypedArray(),
+                fullPriceMicros = otp.fullPriceMicros,
+                discountDisplayInfo = otp.discountDisplayInfo?.let { discount ->
+                    NitroDiscountDisplayInfoAndroid(
+                        percentageDiscount = discount.percentageDiscount?.toDouble(),
+                        discountAmount = discount.discountAmount?.let { amount ->
+                            NitroDiscountAmountAndroid(
+                                discountAmountMicros = amount.discountAmountMicros,
+                                formattedDiscountAmount = amount.formattedDiscountAmount
+                            )
+                        }
+                    )
+                },
+                validTimeWindow = otp.validTimeWindow?.let { window ->
+                    NitroValidTimeWindowAndroid(
+                        startTimeMillis = window.startTimeMillis,
+                        endTimeMillis = window.endTimeMillis
+                    )
+                },
+                limitedQuantityInfo = otp.limitedQuantityInfo?.let { info ->
+                    NitroLimitedQuantityInfoAndroid(
+                        maximumQuantity = info.maximumQuantity.toDouble(),
+                        remainingQuantity = info.remainingQuantity.toDouble()
+                    )
+                },
+                preorderDetailsAndroid = otp.preorderDetailsAndroid?.let { preorder ->
+                    NitroPreorderDetailsAndroid(
+                        preorderPresaleEndTimeMillis = preorder.preorderPresaleEndTimeMillis,
+                        preorderReleaseTimeMillis = preorder.preorderReleaseTimeMillis
+                    )
+                },
+                rentalDetailsAndroid = otp.rentalDetailsAndroid?.let { rental ->
+                    NitroRentalDetailsAndroid(
+                        rentalPeriod = rental.rentalPeriod,
+                        rentalExpirationPeriod = rental.rentalExpirationPeriod
+                    )
+                }
             )
-        }
+        }?.toTypedArray()
 
         var originalPriceAndroid: String? = null
         var originalPriceAmountMicrosAndroid: Double? = null
@@ -839,7 +883,7 @@ class HybridRnIap : HybridRnIapSpec() {
         var freeTrialPeriodAndroid: String? = null
 
         if (product.type == ProductType.InApp) {
-            oneTimeOffer?.let { otp ->
+            oneTimeOffers?.firstOrNull()?.let { otp ->
                 originalPriceAndroid = otp.formattedPrice
                 originalPriceAmountMicrosAndroid = otp.priceAmountMicros.toDoubleOrNull()
             }
@@ -903,7 +947,7 @@ class HybridRnIap : HybridRnIapSpec() {
             subscriptionPeriodAndroid = subscriptionPeriodAndroid,
             freeTrialPeriodAndroid = freeTrialPeriodAndroid,
             subscriptionOfferDetailsAndroid = subscriptionOffersJson,
-            oneTimePurchaseOfferDetailsAndroid = oneTimeOfferNitro
+            oneTimePurchaseOfferDetailsAndroid = oneTimeOffersNitro
         )
     }
     
@@ -957,7 +1001,8 @@ class HybridRnIap : HybridRnIapSpec() {
             packageNameAndroid = androidPurchase?.packageNameAndroid,
             obfuscatedAccountIdAndroid = androidPurchase?.obfuscatedAccountIdAndroid,
             obfuscatedProfileIdAndroid = androidPurchase?.obfuscatedProfileIdAndroid,
-            developerPayloadAndroid = androidPurchase?.developerPayloadAndroid
+            developerPayloadAndroid = androidPurchase?.developerPayloadAndroid,
+            isSuspendedAndroid = androidPurchase?.isSuspendedAndroid
         )
     }
 
@@ -1341,6 +1386,127 @@ class HybridRnIap : HybridRnIapSpec() {
         }
     }
 
+    // -------------------------------------------------------------------------
+    // Billing Programs API (Android 8.2.0+)
+    // -------------------------------------------------------------------------
+
+    // Create OpenIapStore lazily for Billing Programs API
+    private val openIapStore: OpenIapStore by lazy { OpenIapStore(context) }
+
+    override fun enableBillingProgramAndroid(program: BillingProgramAndroid) {
+        RnIapLog.payload("enableBillingProgramAndroid", mapOf("program" to program.name))
+        try {
+            val openIapProgram = mapBillingProgram(program)
+            openIapStore.enableBillingProgram(openIapProgram)
+            RnIapLog.result("enableBillingProgramAndroid", true)
+        } catch (err: Throwable) {
+            RnIapLog.failure("enableBillingProgramAndroid", err)
+            // enableBillingProgram is void, so we just log the error
+        }
+    }
+
+    override fun isBillingProgramAvailableAndroid(program: BillingProgramAndroid): Promise<NitroBillingProgramAvailabilityResultAndroid> {
+        return Promise.async {
+            RnIapLog.payload("isBillingProgramAvailableAndroid", mapOf("program" to program.name))
+            try {
+                initConnection(null).await()
+                val openIapProgram = mapBillingProgram(program)
+                val result = openIapStore.isBillingProgramAvailable(openIapProgram)
+                val nitroResult = NitroBillingProgramAvailabilityResultAndroid(
+                    billingProgram = program,
+                    isAvailable = result.isAvailable
+                )
+                RnIapLog.result("isBillingProgramAvailableAndroid", mapOf("isAvailable" to result.isAvailable))
+                nitroResult
+            } catch (err: Throwable) {
+                RnIapLog.failure("isBillingProgramAvailableAndroid", err)
+                val errorType = parseOpenIapError(err)
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+            }
+        }
+    }
+
+    override fun createBillingProgramReportingDetailsAndroid(program: BillingProgramAndroid): Promise<NitroBillingProgramReportingDetailsAndroid> {
+        return Promise.async {
+            RnIapLog.payload("createBillingProgramReportingDetailsAndroid", mapOf("program" to program.name))
+            try {
+                initConnection(null).await()
+                val openIapProgram = mapBillingProgram(program)
+                val result = openIapStore.createBillingProgramReportingDetails(openIapProgram)
+                val nitroResult = NitroBillingProgramReportingDetailsAndroid(
+                    billingProgram = program,
+                    externalTransactionToken = result.externalTransactionToken
+                )
+                RnIapLog.result("createBillingProgramReportingDetailsAndroid", mapOf("hasToken" to true))
+                nitroResult
+            } catch (err: Throwable) {
+                RnIapLog.failure("createBillingProgramReportingDetailsAndroid", err)
+                val errorType = parseOpenIapError(err)
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+            }
+        }
+    }
+
+    override fun launchExternalLinkAndroid(params: NitroLaunchExternalLinkParamsAndroid): Promise<Boolean> {
+        return Promise.async {
+            RnIapLog.payload("launchExternalLinkAndroid", mapOf(
+                "billingProgram" to params.billingProgram.name,
+                "launchMode" to params.launchMode.name,
+                "linkType" to params.linkType.name,
+                "linkUri" to params.linkUri
+            ))
+            try {
+                initConnection(null).await()
+
+                val activity = withContext(Dispatchers.Main) {
+                    runCatching { context.currentActivity }.getOrNull()
+                } ?: throw OpenIapException(toErrorJson(OpenIAPError.DeveloperError, debugMessage = "Activity not available"))
+
+                val openIapParams = OpenIapLaunchExternalLinkParams(
+                    billingProgram = mapBillingProgram(params.billingProgram),
+                    launchMode = mapExternalLinkLaunchMode(params.launchMode),
+                    linkType = mapExternalLinkType(params.linkType),
+                    linkUri = params.linkUri
+                )
+
+                val result = withContext(Dispatchers.Main) {
+                    openIapStore.launchExternalLink(activity, openIapParams)
+                }
+                RnIapLog.result("launchExternalLinkAndroid", result)
+                result
+            } catch (err: Throwable) {
+                RnIapLog.failure("launchExternalLinkAndroid", err)
+                val errorType = parseOpenIapError(err)
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+            }
+        }
+    }
+
+    // Billing Programs helper functions
+    private fun mapBillingProgram(program: BillingProgramAndroid): OpenIapBillingProgramAndroid {
+        return when (program) {
+            BillingProgramAndroid.UNSPECIFIED -> OpenIapBillingProgramAndroid.Unspecified
+            BillingProgramAndroid.EXTERNAL_CONTENT_LINK -> OpenIapBillingProgramAndroid.ExternalContentLink
+            BillingProgramAndroid.EXTERNAL_OFFER -> OpenIapBillingProgramAndroid.ExternalOffer
+        }
+    }
+
+    private fun mapExternalLinkLaunchMode(mode: ExternalLinkLaunchModeAndroid): OpenIapExternalLinkLaunchMode {
+        return when (mode) {
+            ExternalLinkLaunchModeAndroid.UNSPECIFIED -> OpenIapExternalLinkLaunchMode.Unspecified
+            ExternalLinkLaunchModeAndroid.LAUNCH_IN_EXTERNAL_BROWSER_OR_APP -> OpenIapExternalLinkLaunchMode.LaunchInExternalBrowserOrApp
+            ExternalLinkLaunchModeAndroid.CALLER_WILL_LAUNCH_LINK -> OpenIapExternalLinkLaunchMode.CallerWillLaunchLink
+        }
+    }
+
+    private fun mapExternalLinkType(type: ExternalLinkTypeAndroid): OpenIapExternalLinkType {
+        return when (type) {
+            ExternalLinkTypeAndroid.UNSPECIFIED -> OpenIapExternalLinkType.Unspecified
+            ExternalLinkTypeAndroid.LINK_TO_DIGITAL_CONTENT_OFFER -> OpenIapExternalLinkType.LinkToDigitalContentOffer
+            ExternalLinkTypeAndroid.LINK_TO_APP_DOWNLOAD -> OpenIapExternalLinkType.LinkToAppDownload
+        }
+    }
+
     // -------------------------------------------------------------------------
     // External Purchase (iOS) - Not supported on Android
     // -------------------------------------------------------------------------

package/ios/HybridRnIap.swift

@@ -1047,6 +1047,30 @@ class HybridRnIap: HybridRnIapSpec {
         // No-op on iOS
     }
 
+    // MARK: - Billing Programs API (Android 8.2.0+) - Not supported on iOS
+
+    func enableBillingProgramAndroid(program: BillingProgramAndroid) throws {
+        // No-op on iOS - Billing Programs are Android-only
+    }
+
+    func isBillingProgramAvailableAndroid(program: BillingProgramAndroid) throws -> Promise<NitroBillingProgramAvailabilityResultAndroid> {
+        return Promise.async {
+            throw PurchaseError.make(code: .featureNotSupported, message: "Billing Programs API is Android-only")
+        }
+    }
+
+    func createBillingProgramReportingDetailsAndroid(program: BillingProgramAndroid) throws -> Promise<NitroBillingProgramReportingDetailsAndroid> {
+        return Promise.async {
+            throw PurchaseError.make(code: .featureNotSupported, message: "Billing Programs API is Android-only")
+        }
+    }
+
+    func launchExternalLinkAndroid(params: NitroLaunchExternalLinkParamsAndroid) throws -> Promise<Bool> {
+        return Promise.async {
+            throw PurchaseError.make(code: .featureNotSupported, message: "Billing Programs API is Android-only")
+        }
+    }
+
     // MARK: - External Purchase (iOS 16.0+)
 
     func canPresentExternalPurchaseNoticeIOS() throws -> Promise<Bool> {

package/ios/reactnativeiap.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>

package/ios/reactnativeiap.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

package/lib/module/index.js

@@ -1745,6 +1745,172 @@ export const createAlternativeBillingTokenAndroid = async sku => {
   }
 };
 
+// ------------------------------
+// Billing Programs API (Android 8.2.0+)
+// ------------------------------
+
+/**
+ * Billing program type for external content links and external offers.
+ * @platform Android
+ * @since Google Play Billing Library 8.2.0+
+ */
+
+/**
+ * Launch mode for external link flow.
+ * @platform Android
+ * @since Google Play Billing Library 8.2.0+
+ */
+
+/**
+ * Link type for external link flow.
+ * @platform Android
+ * @since Google Play Billing Library 8.2.0+
+ */
+
+/**
+ * Parameters for launching an external link (Android 8.2.0+).
+ */
+
+/**
+ * Result of checking billing program availability (Android 8.2.0+).
+ */
+
+/**
+ * Reporting details for external transactions (Android 8.2.0+).
+ */
+
+/**
+ * Enable a billing program before initConnection (Android only).
+ * Must be called BEFORE initConnection() to configure the BillingClient.
+ *
+ * @param program - The billing program to enable (external-content-link or external-offer)
+ * @platform Android
+ * @since Google Play Billing Library 8.2.0+
+ *
+ * @example
+ * ```typescript
+ * // Enable external offers before connecting
+ * enableBillingProgramAndroid('external-offer');
+ * await initConnection();
+ * ```
+ */
+export const enableBillingProgramAndroid = program => {
+  if (Platform.OS !== 'android') {
+    RnIapConsole.warn('enableBillingProgramAndroid is only supported on Android');
+    return;
+  }
+  try {
+    IAP.instance.enableBillingProgramAndroid(program);
+  } catch (error) {
+    RnIapConsole.error('Failed to enable billing program:', error);
+  }
+};
+
+/**
+ * Check if a billing program is available for this user/device (Android only).
+ *
+ * @param program - The billing program to check
+ * @returns Promise with availability result
+ * @platform Android
+ * @since Google Play Billing Library 8.2.0+
+ *
+ * @example
+ * ```typescript
+ * const result = await isBillingProgramAvailableAndroid('external-offer');
+ * if (result.isAvailable) {
+ *   // External offers are available for this user
+ * }
+ * ```
+ */
+export const isBillingProgramAvailableAndroid = async program => {
+  if (Platform.OS !== 'android') {
+    throw new Error('Billing Programs API is only supported on Android');
+  }
+  try {
+    const result = await IAP.instance.isBillingProgramAvailableAndroid(program);
+    return {
+      billingProgram: result.billingProgram,
+      isAvailable: result.isAvailable
+    };
+  } catch (error) {
+    RnIapConsole.error('Failed to check billing program availability:', error);
+    throw error;
+  }
+};
+
+/**
+ * Create billing program reporting details for external transactions (Android only).
+ * Used to get the external transaction token needed for reporting to Google.
+ *
+ * @param program - The billing program to create reporting details for
+ * @returns Promise with reporting details including external transaction token
+ * @platform Android
+ * @since Google Play Billing Library 8.2.0+
+ *
+ * @example
+ * ```typescript
+ * const details = await createBillingProgramReportingDetailsAndroid('external-offer');
+ * // Use details.externalTransactionToken to report the transaction
+ * await fetch('/api/report-external-transaction', {
+ *   method: 'POST',
+ *   body: JSON.stringify({ token: details.externalTransactionToken })
+ * });
+ * ```
+ */
+export const createBillingProgramReportingDetailsAndroid = async program => {
+  if (Platform.OS !== 'android') {
+    throw new Error('Billing Programs API is only supported on Android');
+  }
+  try {
+    const result = await IAP.instance.createBillingProgramReportingDetailsAndroid(program);
+    return {
+      billingProgram: result.billingProgram,
+      externalTransactionToken: result.externalTransactionToken
+    };
+  } catch (error) {
+    RnIapConsole.error('Failed to create billing program reporting details:', error);
+    throw error;
+  }
+};
+
+/**
+ * Launch external link for external offers or app download (Android only).
+ *
+ * @param params - Parameters for launching the external link
+ * @returns Promise<boolean> - true if user accepted, false otherwise
+ * @platform Android
+ * @since Google Play Billing Library 8.2.0+
+ *
+ * @example
+ * ```typescript
+ * const success = await launchExternalLinkAndroid({
+ *   billingProgram: 'external-offer',
+ *   launchMode: 'launch-in-external-browser-or-app',
+ *   linkType: 'link-to-digital-content-offer',
+ *   linkUri: 'https://your-website.com/purchase'
+ * });
+ * if (success) {
+ *   console.log('User accepted external link');
+ * }
+ * ```
+ */
+export const launchExternalLinkAndroid = async params => {
+  if (Platform.OS !== 'android') {
+    throw new Error('Billing Programs API is only supported on Android');
+  }
+  try {
+    return await IAP.instance.launchExternalLinkAndroid({
+      billingProgram: params.billingProgram,
+      launchMode: params.launchMode,
+      linkType: params.linkType,
+      linkUri: params.linkUri
+    });
+  } catch (error) {
+    RnIapConsole.error('Failed to launch external link:', error);
+    throw error;
+  }
+};
+
 // ------------------------------
 // iOS External Purchase
 // ------------------------------