react-native-revnix 1.4.2 → 1.6.0

package/android/build.gradle

@@ -0,0 +1,34 @@
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  namespace "com.revnix.reactnative"
+  compileSdkVersion safeExtGet("compileSdkVersion", 35)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-native:+"
+  implementation "com.android.billingclient:billing:8.3.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest />

package/android/src/main/kotlin/com/revnix/reactnative/RevnixStoreModule.kt

@@ -0,0 +1,247 @@
+package com.revnix.reactnative
+
+import android.util.Log
+import com.android.billingclient.api.AcknowledgePurchaseParams
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClient.BillingResponseCode
+import com.android.billingclient.api.BillingClient.ProductType
+import com.android.billingclient.api.BillingClientStateListener
+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.PurchasesUpdatedListener
+import com.android.billingclient.api.QueryProductDetailsParams
+import com.android.billingclient.api.QueryPurchasesParams
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicReference
+
+class RevnixStoreModule(context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context), PurchasesUpdatedListener {
+
+  private class PendingPurchase(val productId: String, val promise: Promise)
+
+  private val pending = AtomicReference<PendingPurchase?>(null)
+  private val acknowledged = ConcurrentHashMap.newKeySet<String>()
+  private val waitingForSetup = mutableListOf<(BillingResult) -> Unit>()
+
+  private val billing: BillingClient = BillingClient.newBuilder(context)
+    .setListener(this)
+    .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())
+    .enableAutoServiceReconnection()
+    .build()
+
+  override fun getName() = "RevnixStore"
+
+  override fun invalidate() {
+    billing.endConnection()
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    withBilling {}
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {}
+
+  @ReactMethod
+  fun purchase(productId: String, customerId: String, promise: Promise) {
+    withBilling { setup ->
+      if (setup.responseCode != BillingResponseCode.OK) {
+        promise.reject("store_error", setup.debugMessage)
+        return@withBilling
+      }
+      queryProduct(productId, ProductType.SUBS) { subs ->
+        if (subs != null) {
+          launch(subs, customerId, promise)
+          return@queryProduct
+        }
+        queryProduct(productId, ProductType.INAPP) { inapp ->
+          if (inapp != null) launch(inapp, customerId, promise)
+          else promise.reject("product_not_found", "No Play product with id $productId")
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun restore(promise: Promise) {
+    withBilling { setup ->
+      if (setup.responseCode != BillingResponseCode.OK) {
+        promise.reject("store_error", setup.debugMessage)
+        return@withBilling
+      }
+      val restored = Arguments.createArray()
+      queryPurchases(ProductType.SUBS) { subs ->
+        subs.forEach { restored.pushMap(toMap(it)) }
+        queryPurchases(ProductType.INAPP) { inapp ->
+          inapp.forEach { restored.pushMap(toMap(it)) }
+          promise.resolve(restored)
+        }
+      }
+    }
+  }
+
+  // ponytail: acknowledges every purchase; consumable INAPP products need consumeAsync to be bought again
+  @ReactMethod
+  fun finish(purchaseToken: String, promise: Promise) {
+    if (purchaseToken in acknowledged) {
+      promise.resolve(null)
+      return
+    }
+    withBilling { setup ->
+      if (setup.responseCode != BillingResponseCode.OK) {
+        promise.reject("store_error", "${setup.responseCode} ${setup.debugMessage}")
+        return@withBilling
+      }
+      val params = AcknowledgePurchaseParams.newBuilder().setPurchaseToken(purchaseToken).build()
+      billing.acknowledgePurchase(params) { result ->
+        if (result.responseCode == BillingResponseCode.OK) {
+          acknowledged.add(purchaseToken)
+          promise.resolve(null)
+        } else {
+          promise.reject("store_error", "acknowledgePurchase failed: ${result.responseCode} ${result.debugMessage}")
+        }
+      }
+    }
+  }
+
+  override fun onPurchasesUpdated(result: BillingResult, purchases: List<Purchase>?) {
+    if (result.responseCode != BillingResponseCode.OK) {
+      settle(pending.getAndSet(null) ?: return, result)
+      return
+    }
+    for (purchase in purchases.orEmpty()) {
+      val waiting = pending.get()
+      if (waiting != null && purchase.products.contains(waiting.productId) &&
+        pending.compareAndSet(waiting, null)
+      ) {
+        val purchased = purchase.purchaseState == Purchase.PurchaseState.PURCHASED
+        waiting.promise.resolve(if (purchased) toMap(purchase) else null)
+      } else if (purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
+        emit(toMap(purchase))
+      }
+    }
+  }
+
+  private fun withBilling(onReady: (BillingResult) -> Unit) {
+    if (billing.isReady) {
+      onReady(BillingResult.newBuilder().setResponseCode(BillingResponseCode.OK).build())
+      return
+    }
+    synchronized(waitingForSetup) {
+      waitingForSetup.add(onReady)
+      if (waitingForSetup.size > 1) return
+    }
+    billing.startConnection(object : BillingClientStateListener {
+      override fun onBillingSetupFinished(result: BillingResult) {
+        val ready = synchronized(waitingForSetup) {
+          waitingForSetup.toList().also { waitingForSetup.clear() }
+        }
+        if (result.responseCode == BillingResponseCode.OK) {
+          queryPurchases(ProductType.SUBS) { subs ->
+            queryPurchases(ProductType.INAPP) { inapp ->
+              (subs + inapp).filterNot { it.isAcknowledged }.forEach { emit(toMap(it)) }
+            }
+          }
+        }
+        ready.forEach { it(result) }
+      }
+
+      override fun onBillingServiceDisconnected() {}
+    })
+  }
+
+  private fun settle(waiting: PendingPurchase, result: BillingResult) {
+    when (result.responseCode) {
+      BillingResponseCode.USER_CANCELED -> waiting.promise.resolve(null)
+      BillingResponseCode.ITEM_ALREADY_OWNED -> queryPurchases(ProductType.SUBS) { subs ->
+        queryPurchases(ProductType.INAPP) { inapp ->
+          val owned = (subs + inapp).firstOrNull { waiting.productId in it.products }
+          if (owned != null) waiting.promise.resolve(toMap(owned))
+          else waiting.promise.reject("store_error", "${result.responseCode} ${result.debugMessage}")
+        }
+      }
+      else -> waiting.promise.reject("store_error", "${result.responseCode} ${result.debugMessage}")
+    }
+  }
+
+  private fun queryProduct(productId: String, type: String, then: (ProductDetails?) -> Unit) {
+    val product = QueryProductDetailsParams.Product.newBuilder()
+      .setProductId(productId)
+      .setProductType(type)
+      .build()
+    val params = QueryProductDetailsParams.newBuilder().setProductList(listOf(product)).build()
+    billing.queryProductDetailsAsync(params) { _, details ->
+      then(details.productDetailsList.firstOrNull())
+    }
+  }
+
+  private fun queryPurchases(type: String, then: (List<Purchase>) -> Unit) {
+    val params = QueryPurchasesParams.newBuilder().setProductType(type).build()
+    billing.queryPurchasesAsync(params) { result, purchases ->
+      if (result.responseCode != BillingResponseCode.OK) {
+        Log.w(TAG, "queryPurchases($type) failed: ${result.responseCode} ${result.debugMessage}")
+      }
+      then(purchases.filter { it.purchaseState == Purchase.PurchaseState.PURCHASED })
+    }
+  }
+
+  private fun launch(details: ProductDetails, customerId: String, promise: Promise) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject("no_activity", "No foreground Activity to show Google Play billing")
+      return
+    }
+    val productParams = BillingFlowParams.ProductDetailsParams.newBuilder()
+      .setProductDetails(details)
+      .apply {
+        // ponytail: first base plan/offer wins; products with several base plans need a basePlanId/offerId selector passed through purchase()
+        details.subscriptionOfferDetails?.firstOrNull()?.let { setOfferToken(it.offerToken) }
+      }
+      .build()
+    val params = BillingFlowParams.newBuilder()
+      .setProductDetailsParamsList(listOf(productParams))
+      .setObfuscatedAccountId(customerId)
+      .build()
+    activity.runOnUiThread {
+      val waiting = PendingPurchase(details.productId, promise)
+      pending.getAndSet(waiting)?.promise?.resolve(null)
+      val result = billing.launchBillingFlow(activity, params)
+      if (result.responseCode != BillingResponseCode.OK && pending.compareAndSet(waiting, null)) {
+        settle(waiting, result)
+      }
+    }
+  }
+
+  private fun toMap(purchase: Purchase): WritableMap {
+    if (purchase.isAcknowledged) acknowledged.add(purchase.purchaseToken)
+    return Arguments.createMap().apply {
+      putString("store", "google")
+      putString("productId", purchase.products.firstOrNull())
+      putString("transactionId", purchase.purchaseToken)
+      putString("token", purchase.purchaseToken)
+      putDouble("occurredAt", purchase.purchaseTime.toDouble())
+    }
+  }
+
+  private fun emit(transaction: WritableMap) {
+    if (!reactApplicationContext.hasActiveReactInstance()) return
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("revnixStoreTransaction", transaction)
+  }
+
+  private companion object {
+    const val TAG = "RevnixStore"
+  }
+}

package/android/src/main/kotlin/com/revnix/reactnative/RevnixStorePackage.kt

@@ -0,0 +1,14 @@
+package com.revnix.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class RevnixStorePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(RevnixStoreModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    emptyList()
+}

package/dist/client.d.ts

@@ -1,4 +1,5 @@
 import type { AdRevenue, AliasResult, CustomerEntitlements, IdentifyResult, IdentifyStrategy, IdentityInfo, LastDeepLink, MmpAttribution, PaywallInteraction, PlacementResolution, RegisterPurchaseInput, RegisterPurchaseResult, RevnixAttribution, RevnixConfig } from "./types.js";
+export declare function paywallImageUrls(value: unknown): string[];
 export declare class RevnixClient {
     private readonly apiKey;
     private readonly baseUrl;
@@ -33,6 +34,7 @@ export declare class RevnixClient {
     private implicitConfigPromise;
     private implicitConfigRetryAt;
     private lifecycleUnsubscribe;
+    private stopStoreObserver;
     /** The cold-start batch while it runs, resolving to whether it presented a
      *  paywall. A deep link delivered on the first frame — SwiftUI's onOpenURL,
      *  RN's getInitialURL — must wait for it, or the customer gets the launch
@@ -55,6 +57,9 @@ export declare class RevnixClient {
      *  /v1/installs uses, and independent of the device header (which an app
      *  can turn off entirely). */
     private freshInstall;
+    private eventFlush;
+    private eventTimer;
+    private eventRetryAt;
     constructor(config: RevnixConfig);
     /** The id every call is made as: the stored identified/canonical id, or a
      *  generated-and-persisted anonymous id (rvx_anon_…) on first launch. */
@@ -90,10 +95,22 @@ export declare class RevnixClient {
      *  PurchaseBlockedError when the token belongs to another customer and the
      *  app's transfer behavior forbids reassignment. */
     registerPurchase(input: RegisterPurchaseInput): Promise<RegisterPurchaseResult>;
+    /** Buys `productId` through the native store (StoreKit 2 / Play Billing),
+     *  registers it with Revnix, then finishes the store transaction. Resolves
+     *  null when the customer cancelled or the purchase is pending approval.
+     *  Needs `import "react-native-revnix/store"` before configure(). A refused
+     *  claim (PurchaseBlockedError) is never finished, so Google refunds it. */
+    purchase(productId: string, opts?: Pick<RegisterPurchaseInput, "viewId" | "paywallId" | "placementKey">): Promise<RegisterPurchaseResult | null>;
+    /** Re-registers every purchase the store still holds for this device and
+     *  resolves how many registered. Per-purchase failures go to onDiagnostic. */
+    restore(): Promise<number>;
+    private requireStore;
+    private registerStoreTransaction;
     private postPurchase;
     /** C7: retry purchases that failed to register and were persisted locally.
      *  Runs automatically at construction; call again when connectivity returns.
-     *  Idempotent and safe to call repeatedly. */
+     *  Idempotent and safe to call repeatedly. Purchases queued more than 30
+     *  days ago are dropped with a diagnostic. */
     retryPendingPurchases(): Promise<void>;
     private freshEntitlements;
     private inflightEntitlements;
@@ -138,12 +155,22 @@ export declare class RevnixClient {
      *  RevnixAuthError locally, before any network call, like identify(). */
     getIdentity(): Promise<IdentityInfo>;
     /** Resolve a named in-app location to the currently published offering —
-     *  the one-line paywall call. REV-157: reads the network first and caches
-     *  the result; if that read FAILS (offline / incident) it falls back to the
-     *  last cached resolution with `stale: true`, so the paywall renders the
-     *  last published version rather than not at all. Throws only when there
-     *  is nothing cached. */
+     *  the one-line paywall call. Served instantly from a cache under 24 h old
+     *  that was fetched for this customer since the last `setAttributes` or
+     *  purchase, refreshed in the background. Otherwise reads the network and
+     *  caches the result; if that read FAILS (offline / incident) it falls back
+     *  to the last cached resolution with `stale: true`, so the paywall renders
+     *  the last published version rather than not at all. Throws only when
+     *  there is nothing cached. A deliberate rejection seen by the background
+     *  refresh drops the cache, so the next resolve throws it. */
     resolvePlacement(placementKey: string): Promise<PlacementResolution>;
+    /** Fetch these placements now so the next `resolvePlacement` answers from
+     *  the cache. Never throws; failures report to `onDiagnostic`. Paywall
+     *  images are warmed by `prefetchPaywallImages` from
+     *  `react-native-revnix/ui`. */
+    preload(placementKeys: string[]): Promise<void>;
+    private refreshPlacement;
+    private fetchPlacement;
     /** REV-157: the last resolution cached for `placementKey`, with NO network
      *  call — for an instant, offline-safe paywall at launch. Always
      *  `stale: true`; follow with resolvePlacement() to revalidate. Null if
@@ -195,7 +222,8 @@ export declare class RevnixClient {
      *    - `restore` — restore purchases was tapped
      *    - `error` — the paywall itself failed (config, products, render)
      *
-     *  Fire-and-forget like the other beacons: never blocks, never throws.
+     *  Queued and sent in batches (see `flushEvents`): resolves once queued,
+     *  never throws.
      *
      *  `viewId` is the id `logPaywallShown` returned for THIS display. Passing
      *  it is what threads the whole life of one impression together and puts
@@ -221,15 +249,28 @@ export declare class RevnixClient {
         message?: string;
         /** Idempotency key for this occurrence; defaults to `viewId`. */
         eventId?: string;
-    }): void;
+    }): Promise<void>;
     /** Reports one ad impression's payout (POST /v1/ad-revenue).
      *  Fire-and-forget like the other beacons: never blocks, never throws. */
     logAdRevenue(input: AdRevenue): void;
     /** Reports one custom in-app event (POST /v1/events), not for purchases.
-     *  Fire-and-forget like the other beacons: never blocks, never throws. */
+     *  Queued and sent in batches (see `flushEvents`): resolves once queued,
+     *  never throws. */
     track(event: string, properties?: Record<string, string | number | boolean>, options?: {
         eventId?: string;
-    }): void;
+    }): Promise<void>;
+    /** Send every queued `track` and paywall interaction event now. Events are
+     *  otherwise sent in batches: at 20 queued, 10 s after the first, when the
+     *  app goes to the background, and on the next launch. Never throws; a
+     *  transient failure keeps the events and holds further sends for 30 s. */
+    flushEvents(): Promise<void>;
+    private readEvents;
+    private mutateEvents;
+    private enqueueEvent;
+    private armEventTimer;
+    private startEventFlush;
+    private runEventFlush;
+    private removeEvents;
     /** PT11: forward an MMP's attribution callback (Adjust, AppsFlyer, …) so
      *  Revnix credits revenue to the right network/campaign. */
     setAttribution(attribution: MmpAttribution): void;
@@ -349,6 +390,7 @@ export declare class RevnixClient {
      *  cold start to ONE paywall. Never throws past its caller's catch. */
     private triggerImplicit;
     private consumePreviousSessionMs;
+    private subscribeLifecycle;
     /** REV-272: the launch-time moments, plus the foreground listener that
      *  `session_start` is built on.
      *
@@ -393,7 +435,12 @@ export declare class RevnixClient {
     private readPlacementMap;
     private readPlacementCache;
     private writePlacementCache;
-    private queueLock;
+    private deletePlacementCache;
+    private mutatePlacements;
+    private placementsInvalidatedAt;
+    private invalidatePlacements;
+    private storageLock;
+    private withStorageLock;
     private mutateQueue;
     private readPurchaseQueue;
     private writePurchaseQueue;