@amplytools/react-native-amply-sdk 0.4.1 → 0.5.0

package/AmplyReactNative.podspec

@@ -22,7 +22,7 @@ Pod::Spec.new do |s|
   s.dependency 'React-RCTFabric'
 
   # Amply KMP SDK from CocoaPods
-  s.dependency 'AmplySDK', '~> 0.4.1'
+  s.dependency 'AmplySDK', '>= 0.5.0'
 
   s.libraries = 'c++'
   s.pod_target_xcconfig = {

package/android/build.gradle

@@ -15,7 +15,7 @@ buildscript {
 apply plugin: 'com.android.library'
 apply plugin: 'org.jetbrains.kotlin.android'
 
-def amplySdkVersion = project.findProperty('amplySdkVersion') ?: System.getenv('AMPLY_SDK_VERSION') ?: '0.4.1'
+def amplySdkVersion = project.findProperty('amplySdkVersion') ?: System.getenv('AMPLY_SDK_VERSION') ?: '0.5.0'
 group = 'tools.amply'
 version = amplySdkVersion
 

package/android/src/main/java/tools/amply/sdk/reactnative/AmplyModule.kt

@@ -3,6 +3,7 @@ package tools.amply.sdk.reactnative
 import android.app.Application
 import tools.amply.sdk.reactnative.core.AmplyClient
 import tools.amply.sdk.reactnative.core.DefaultAmplyClient
+import tools.amply.sdk.reactnative.core.GateDecision
 import tools.amply.sdk.reactnative.model.AmplyInitializationOptions
 import tools.amply.sdk.reactnative.model.DataSetType
 import tools.amply.sdk.reactnative.model.DataSetType.EventParam
@@ -94,32 +95,24 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  override fun trackEventGated(event: String, properties: ReadableMap, promise: Promise) {
+  override fun trackGated(event: String, properties: ReadableMap, promise: Promise) {
     if (event.isBlank()) {
-      promise.reject(ARGUMENT_ERROR, "Event 'event' is required")
+      // The JS contract is "trackGated never rejects" — fail open instead.
+      android.util.Log.w(TAG, "trackGated with blank event; failing open")
+      promise.resolve(GateDecision.FAIL_OPEN.toWritableMap())
       return
     }
     val props = properties.toHashMap()
-    // The Promise IS the continuation. We resolve "complete"/"cancel" exactly once;
-    // the KMP overload guarantees exactly-once main-thread delivery, and resolveOnce
-    // guards against the (impossible-but-defensive) double settle.
-    val resolved = java.util.concurrent.atomic.AtomicBoolean(false)
-    fun resolveOnce(decision: String) {
-      if (resolved.compareAndSet(false, true)) {
-        promise.resolve(decision)
+    scope.launch {
+      // client.trackGated never throws (it collapses every error path to FAIL_OPEN),
+      // but guard defensively so the promise can never reject.
+      val decision = try {
+        client.trackGated(event, props)
+      } catch (throwable: Throwable) {
+        android.util.Log.w(TAG, "trackGated failed; failing open", throwable)
+        GateDecision.FAIL_OPEN
       }
-    }
-    try {
-      client.trackEventGated(
-        event,
-        props,
-        onProceed = { resolveOnce("complete") },
-        onCancel = { resolveOnce("cancel") },
-      )
-    } catch (throwable: Throwable) {
-      // Fail open: a synchronous failure proceeds rather than stranding the app.
-      android.util.Log.w(TAG, "trackEventGated failed; proceeding (fail-open)", throwable)
-      resolveOnce("complete")
+      promise.resolve(decision.toWritableMap())
     }
   }
 
@@ -127,20 +120,20 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     client.resolveCampaign(mediationId, result)
   }
 
-  override fun registerCampaignPresenter() {
+  override fun registerGate(baseUrl: String, onAbort: String, timeoutMs: Double) {
     if (campaignPresenterJob == null) {
       campaignPresenterJob = scope.launch {
         client.campaignPresents.collect { payload ->
           android.util.Log.i(
             TAG,
-            "Emitting campaign present to JS mediationId=${payload.mediationId} url=${payload.url}"
+            "Emitting gate present to JS mediationId=${payload.mediationId} url=${payload.url}"
           )
-          emitCampaignPresent(payload.mediationId, payload.url, payload.info)
+          emitCampaignPresent(payload.mediationId, payload.url, payload.params, payload.info)
         }
       }
-      android.util.Log.i(TAG, "Started campaign present collection job")
+      android.util.Log.i(TAG, "Started gate present collection job")
     }
-    client.registerCampaignPresenter()
+    client.registerGate(baseUrl, onAbort, timeoutMs.toLong())
   }
 
   override fun getRecentEvents(limit: Double, promise: Promise) {
@@ -280,9 +273,15 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     android.util.Log.d(TAG, "emitOnDeepLink completed")
   }
 
-  private fun emitCampaignPresent(mediationId: String, url: String, info: Map<String, Any?>) {
+  private fun emitCampaignPresent(
+    mediationId: String,
+    url: String,
+    params: Map<String, Any?>,
+    info: Map<String, Any?>,
+  ) {
     val map = Arguments.createMap().apply {
       putString("url", url)
+      putMap("params", params.toWritableMap())
       putMap("info", info.toWritableMap())
       putString("mediationId", mediationId)
     }
@@ -290,6 +289,18 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     emitOnCampaignPresent(map)
   }
 
+  // Renders the bridge GateDecision into the JS-facing map:
+  //   { outcome: "proceed", reason: "completed" | "failOpen" } | { outcome: "cancelled" }
+  private fun GateDecision.toWritableMap(): WritableMap = Arguments.createMap().apply {
+    when (this@toWritableMap) {
+      is GateDecision.Proceed -> {
+        putString("outcome", "proceed")
+        putString("reason", reason.wire)
+      }
+      GateDecision.Cancelled -> putString("outcome", "cancelled")
+    }
+  }
+
   private fun emitSystemEvent(event: EventEnvelope) {
     emitOnSystemEvent(event.toWritableMap())
   }

package/android/src/main/java/tools/amply/sdk/reactnative/core/AmplyClient.kt

@@ -28,24 +28,25 @@ interface AmplyClient {
   suspend fun track(name: String, properties: Map<String, Any?>?)
 
   /**
-   * Gated form of track. Wraps the KMP `trackEvent` continuation overload:
-   * records the event, evaluates campaigns, and (if a blocking action matched and a
-   * presenter is registered) dispatches the campaign present and awaits its result
-   * before invoking exactly one of [onProceed] / [onCancel]. Fails open to
-   * [onProceed] on every error path.
+   * Gated form of track. Wraps the KMP `suspend fun trackGated(event, props): GateDecision`:
+   * records the event, evaluates campaigns, and (if a gate action matched and a presenter
+   * is registered) dispatches the gate presentation and awaits its outcome. Returns the
+   * collapsed [GateDecision]. Never throws — every error path returns
+   * [GateDecision.Proceed] with reason [GateDecision.ProceedReason.FAIL_OPEN].
    */
-  fun trackEventGated(
+  suspend fun trackGated(
     name: String,
     properties: Map<String, Any?>?,
-    onProceed: () -> Unit,
-    onCancel: () -> Unit,
-  )
+  ): GateDecision
 
   /**
-   * Register the bridge's JS-backed campaign presenter with the KMP SDK so a
-   * dispatched blocking action is surfaced to JS via [campaignPresents].
+   * Register the bridge's JS-backed gate presenter with the KMP SDK for [baseUrl], so a
+   * dispatched gate presentation is surfaced to JS via [campaignPresents].
+   *
+   * @param onAbort `"cancel"` or `"proceed"`.
+   * @param timeoutMs gate timeout in ms; `0` means use the SDK default.
    */
-  fun registerCampaignPresenter()
+  fun registerGate(baseUrl: String, onAbort: String, timeoutMs: Long)
 
   /**
    * Report the terminal result (one of `Completed` / `Dismissed` / `Unavailable`) for

package/android/src/main/java/tools/amply/sdk/reactnative/core/DefaultAmplyClient.kt

@@ -25,10 +25,13 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import tools.amply.sdk.Amply
+import tools.amply.sdk.actions.AbortPolicy
+import tools.amply.sdk.actions.CampaignPresenter
 import tools.amply.sdk.actions.CampaignResolution
 import tools.amply.sdk.actions.CampaignResult
 import tools.amply.sdk.actions.DeepLinkListener
-import tools.amply.sdk.actions.CampaignPresenter
+import tools.amply.sdk.core.GateDecision as KmpGateDecision
+import tools.amply.sdk.core.ProceedReason as KmpProceedReason
 import tools.amply.sdk.config.AmplyConfig
 import tools.amply.sdk.config.amplyConfig
 import tools.amply.sdk.core.AmplySDKInterface
@@ -47,10 +50,13 @@ class DefaultAmplyClient(
   private val pendingPropertyOps = mutableListOf<(Amply) -> Unit>()
   private val deepLinkRegistered = AtomicBoolean(false)
   private val systemEventsRegistered = AtomicBoolean(false)
-  private val campaignPresenterRegistered = AtomicBoolean(false)
+  private val gatePresenterRegistered = AtomicBoolean(false)
   private val deepLinkSequence = AtomicLong(0L)
   private val campaignPresentSequence = AtomicLong(0L)
-  private val pendingCompletions = ConcurrentHashMap<String, CampaignResolution>()
+  // Global routing table: mediationId -> the resolution token awaiting a JS reply. Shared
+  // across every registered gate because resolveCampaign(mediationId) routes by exact id —
+  // that lookup is correct regardless of which gate minted the id.
+  private val pendingCompletions = ConcurrentHashMap<String, OwnedResolution>()
   private val lastResumedActivity = AtomicReference<WeakReference<Activity>?>(null)
   private val sessionPrimed = AtomicBoolean(false)
   private val mainHandler = Handler(Looper.getMainLooper())
@@ -149,80 +155,66 @@ class DefaultAmplyClient(
     }
   }
 
-  override fun trackEventGated(
+  override suspend fun trackGated(
     name: String,
     properties: Map<String, Any?>?,
-    onProceed: () -> Unit,
-    onCancel: () -> Unit,
-  ) {
+  ): GateDecision {
     val instance = amplyInstance
     if (instance == null) {
       // Fail open: not initialized yet -> proceed immediately (mirrors KMP row 1).
       android.util.Log.w(
         "AmplyReactNative",
-        "trackEventGated('$name') before init; proceeding (fail-open)"
+        "trackGated('$name') before init; failing open"
       )
-      onProceed()
-      return
+      return GateDecision.FAIL_OPEN
     }
     android.util.Log.i(
       "AmplyReactNative",
-      "trackEventGated('$name') with properties=${properties?.filterValues { it != null }}"
-    )
-    // KMP continuation overload guarantees exactly-once, main-thread delivery of the
-    // callbacks. The bridge simply forwards them; the raw result never surfaces here.
-    instance.trackEvent(
-      name,
-      properties?.toNonNullMap() ?: emptyMap(),
-      onProceed,
-      onCancel,
+      "trackGated('$name') with properties=${properties?.filterValues { it != null }}"
     )
+    return try {
+      // KMP: `suspend fun trackGated(event, props): GateDecision`. The bridge collapses
+      // the raw decision into its own GateDecision; the CampaignResult never surfaces here.
+      val decision = instance.trackGated(name, properties?.toNonNullMap() ?: emptyMap())
+      decision.toBridgeDecision()
+    } catch (cancellation: kotlinx.coroutines.CancellationException) {
+      // Respect structured-concurrency cancellation, but the bridge contract is
+      // "never throw" — a cancelled gate fails open.
+      android.util.Log.w("AmplyReactNative", "trackGated('$name') cancelled; failing open")
+      GateDecision.FAIL_OPEN
+    } catch (throwable: Throwable) {
+      android.util.Log.w("AmplyReactNative", "trackGated('$name') failed; failing open", throwable)
+      GateDecision.FAIL_OPEN
+    }
   }
 
-  override fun registerCampaignPresenter() {
+  override fun registerGate(baseUrl: String, onAbort: String, timeoutMs: Long) {
     val instance = requireInstance()
-    if (!campaignPresenterRegistered.compareAndSet(false, true)) {
-      return
+    gatePresenterRegistered.set(true)
+    val policy = when (onAbort) {
+      "proceed" -> AbortPolicy.Proceed
+      else -> AbortPolicy.Cancel
     }
-    android.util.Log.i("AmplyReactNative", "Registering campaign presenter")
-    // Catch-all registration: the JS layer is the single capability registry and
-    // routes by URL on its side. Per-URL-pattern KMP registration is reserved for
-    // native integrators.
-    instance.registerCampaignPresenter(object : CampaignPresenter {
-      override fun present(
-        url: String,
-        info: Map<String, Any>,
-        completion: CampaignResolution,
-      ) {
-        val mediationId = UUID.randomUUID().toString()
-        pendingCompletions[mediationId] = completion
-        android.util.Log.i(
-          "AmplyReactNative",
-          "Dispatching campaign present mediationId=$mediationId url=$url infoKeys=${info.keys}"
-        )
-        val payload = CampaignPresentPayload(
-          sequenceId = campaignPresentSequence.incrementAndGet(),
-          mediationId = mediationId,
-          url = url,
-          info = info.mapValues { it.value },
-        )
-        if (!_campaignPresents.tryEmit(payload)) {
-          // Backpressure / no collector: fail open by reporting Unavailable so the
-          // SDK's continuation still proceeds rather than hanging until timeout.
-          android.util.Log.w(
-            "AmplyReactNative",
-            "Dropping campaign present mediationId=$mediationId; reporting Unavailable (fail-open)"
-          )
-          pendingCompletions.remove(mediationId)
-          completion.resolve(CampaignResult.Unavailable)
-        }
-      }
-    })
+    android.util.Log.i(
+      "AmplyReactNative",
+      "Registering gate baseUrl=$baseUrl onAbort=$onAbort timeoutMs=$timeoutMs"
+    )
+    // JS is the single capability registry and routes by baseUrl on its side; the
+    // native gate carries the abort policy and timeout. Each registerGate registration
+    // gets its OWN presenter instance owning its OWN "current presentation" slot, so a
+    // dismiss() delivered to this gate's presenter can only abandon THIS gate's live
+    // presentation — never one belonging to a different url-pattern's gate.
+    instance.registerGate(
+      baseUrl = baseUrl,
+      presenter = GatePresenter(baseUrl),
+      onAbort = policy,
+      timeoutMs = if (timeoutMs > 0L) timeoutMs else DEFAULT_GATE_TIMEOUT_MS,
+    )
   }
 
   override fun resolveCampaign(mediationId: String, result: String) {
-    val completion = pendingCompletions.remove(mediationId)
-    if (completion == null) {
+    val owner = pendingCompletions[mediationId]
+    if (owner == null) {
       // Late/duplicate/unknown reply — the SDK token is the source of truth and is
       // already settled (or never existed). Ignore.
       android.util.Log.i(
@@ -236,7 +228,8 @@ class DefaultAmplyClient(
       "AmplyReactNative",
       "resolveCampaign mediationId=$mediationId result=$result -> $mapped"
     )
-    completion.resolve(mapped)
+    // settle() is at-most-once: a duplicate JS reply or a dismiss()/resolve() race is a no-op.
+    owner.settle(mapped)
   }
 
   override suspend fun getRecentEvents(limit: Int): List<EventEnvelope> {
@@ -421,20 +414,20 @@ class DefaultAmplyClient(
     }
     deepLinkRegistered.set(false)
     systemEventsRegistered.set(false)
-    campaignPresenterRegistered.set(false)
+    gatePresenterRegistered.set(false)
     android.util.Log.i("AmplyReactNative", "Amply client shutdown; deep link listener cleared")
     deepLinkSequence.set(0L)
     campaignPresentSequence.set(0L)
     sessionPrimed.set(false)
     lastResumedActivity.set(null)
-    // Fail open any in-flight mediated actions so no continuation is left hanging.
+    // Fail open any in-flight mediated actions so no continuation is left hanging. Each
+    // OwnedResolution clears its owning presenter's current-id slot as it settles.
     val inFlight = pendingCompletions.values.toList()
-    pendingCompletions.clear()
-    inFlight.forEach { completion ->
+    inFlight.forEach { owner ->
       try {
-        completion.resolve(CampaignResult.Unavailable)
+        owner.settle(CampaignResult.Unavailable)
       } catch (error: Throwable) {
-        android.util.Log.w("AmplyReactNative", "Error settling mediated action on shutdown: ${error.message}")
+        android.util.Log.w("AmplyReactNative", "Error settling gate presentation on shutdown: ${error.message}")
       }
     }
     _deepLinkEvents.resetReplayCache()
@@ -476,6 +469,19 @@ class DefaultAmplyClient(
       }
     }
 
+  // Collapses the KMP GateDecision into the bridge GateDecision. Verified against published
+  // KMP 0.5.0-SNAPSHOT: `tools.amply.sdk.core.GateDecision = Proceed(reason: ProceedReason) |
+  // Cancelled`, where `ProceedReason` is a TOP-LEVEL enum { Completed, FailOpen }.
+  private fun KmpGateDecision.toBridgeDecision(): GateDecision =
+    when (this) {
+      is KmpGateDecision.Proceed ->
+        when (reason) {
+          KmpProceedReason.Completed -> GateDecision.COMPLETED
+          KmpProceedReason.FailOpen -> GateDecision.FAIL_OPEN
+        }
+      is KmpGateDecision.Cancelled -> GateDecision.Cancelled
+    }
+
   private fun Map<String, Any>.toNullableValues(): Map<String, Any?> =
     mapValues { it.value }
 
@@ -551,4 +557,128 @@ class DefaultAmplyClient(
       )
     }
   }
+
+  /**
+   * One KMP [CampaignPresenter] per [registerGate] registration (per url-pattern).
+   *
+   * Concurrency model: KMP presents at most one gate per url-pattern at a time (the gate is
+   * modal — you cannot show two rewarded ads, or two presentations of the same pattern, at
+   * once). KMP's [dismiss] is parameterless and is dispatched to the SPECIFIC presenter
+   * instance registered for that pattern. So the "which presentation does my dismiss() target"
+   * state must live PER-PRESENTER, here in [currentMediationId] — NOT in one global slot on the
+   * client. With one global slot, an overlap of two different-pattern gates (A present, B
+   * present, A dismiss) routes A's dismiss to B's token. Per-instance state makes A's dismiss
+   * abandon only A's own live presentation.
+   *
+   * Concurrent presentations of the SAME url-pattern are not supported: a second present() on
+   * this instance overwrites [currentMediationId], so a later dismiss() targets the latest. That
+   * is acceptable and intended given the modal contract above. [pendingCompletions] stays global
+   * (lookup by exact id is always correct), so a JS resolveCampaign for the overwritten id still
+   * settles its own token directly.
+   */
+  private inner class GatePresenter(private val baseUrl: String) : CampaignPresenter {
+    // The mediationId this presenter most recently present()ed and has not yet resolved/abandoned.
+    // dismiss() targets exactly this id, so it can only ever release THIS gate's live presentation.
+    private val currentMediationId = AtomicReference<String?>(null)
+
+    override fun dismiss() {
+      // The SDK calls dismiss() when this gate's caller coroutine is cancelled/times out and the
+      // resolution token is abandoned. Presentation UI lives in JS (nothing native to tear down),
+      // but the parked token MUST be released so pendingCompletions does not leak. Abandon exactly
+      // THIS presenter's current presentation; the owner's at-most-once guard means a later JS
+      // reply (resolveCampaign) becomes a harmless no-op.
+      val id = currentMediationId.get()
+      if (id == null) {
+        android.util.Log.i("AmplyReactNative", "Gate[$baseUrl] dismiss() with no active presentation")
+        return
+      }
+      val owner = pendingCompletions[id]
+      android.util.Log.i("AmplyReactNative", "Gate[$baseUrl] dismiss() releasing mediationId=$id")
+      owner?.abandon()
+    }
+
+    override fun present(
+      params: Map<String, String>,
+      info: Map<String, Any>,
+      resolution: CampaignResolution,
+    ) {
+      val mediationId = UUID.randomUUID().toString()
+      val owner = OwnedResolution(mediationId, resolution, this)
+      pendingCompletions[mediationId] = owner
+      currentMediationId.set(mediationId)
+      val url = (info["url"] as? String).orEmpty()
+      android.util.Log.i(
+        "AmplyReactNative",
+        "Gate[$baseUrl] dispatching present mediationId=$mediationId url=$url infoKeys=${info.keys}"
+      )
+      val payload = CampaignPresentPayload(
+        sequenceId = campaignPresentSequence.incrementAndGet(),
+        mediationId = mediationId,
+        url = url,
+        params = params.mapValues { it.value },
+        info = info.mapValues { it.value },
+      )
+      if (!_campaignPresents.tryEmit(payload)) {
+        // Backpressure / no collector: fail open by reporting Unavailable so the
+        // gate still proceeds rather than hanging until timeout.
+        android.util.Log.w(
+          "AmplyReactNative",
+          "Gate[$baseUrl] dropping present mediationId=$mediationId; reporting Unavailable (fail-open)"
+        )
+        owner.settle(CampaignResult.Unavailable)
+      }
+    }
+
+    /** Clears the current-presentation slot iff it still points at [mediationId]. */
+    fun clearIfCurrent(mediationId: String) {
+      currentMediationId.compareAndSet(mediationId, null)
+    }
+  }
+
+  /**
+   * Owns one [CampaignResolution] token for the lifetime of a single gate presentation.
+   *
+   * Knows its own [mediationId] so it can remove itself from [pendingCompletions] no matter
+   * which path settles it — a JS reply ([resolveCampaign]), the SDK abandoning the presentation
+   * ([CampaignPresenter.dismiss]), a backpressure fail-open, or [shutdown]. The [done] guard makes
+   * resolve and abandon mutually-exclusive and at-most-once: whichever fires first wins, the rest
+   * are no-ops. This is what prevents the pending-resolution leak on timeout/cancel/dismiss.
+   *
+   * Holds a reference to its owning [GatePresenter] so settling also clears that presenter's
+   * current-presentation slot (per-presenter, not global — see [GatePresenter]).
+   */
+  private inner class OwnedResolution(
+    val mediationId: String,
+    private val resolution: CampaignResolution,
+    private val owner: GatePresenter,
+  ) {
+    private val done = AtomicBoolean(false)
+
+    /** Resolve the underlying token exactly once and stop tracking this presentation. */
+    fun settle(result: CampaignResult) {
+      if (!done.compareAndSet(false, true)) return
+      cleanup()
+      resolution.resolve(result)
+    }
+
+    /**
+     * The SDK abandoned the presentation (dismiss): drop the parked token without resolving.
+     * The SDK's own timeout/cancel machinery owns the abort outcome here, so we must NOT also
+     * resolve — we only release our reference so the map cannot leak.
+     */
+    fun abandon() {
+      if (!done.compareAndSet(false, true)) return
+      cleanup()
+    }
+
+    private fun cleanup() {
+      pendingCompletions.remove(mediationId, this)
+      owner.clearIfCurrent(mediationId)
+    }
+  }
+
+  private companion object {
+    // Fallback when JS passes timeoutMs = 0 (i.e. "use a sensible default").
+    const val DEFAULT_GATE_TIMEOUT_MS = 30_000L
+  }
 }

package/android/src/main/java/tools/amply/sdk/reactnative/core/GateDecision.kt

@@ -0,0 +1,23 @@
+package tools.amply.sdk.reactnative.core
+
+/**
+ * Bridge-level collapsed gate decision, mirroring the KMP `GateDecision`. The raw
+ * `CampaignResult` is never surfaced to JS — it is collapsed into this here.
+ *
+ * Maps to the JS-facing shape:
+ *   { outcome: "proceed", reason: "completed" | "failOpen" } | { outcome: "cancelled" }
+ */
+sealed interface GateDecision {
+  enum class ProceedReason(val wire: String) {
+    COMPLETED("completed"),
+    FAIL_OPEN("failOpen"),
+  }
+
+  data class Proceed(val reason: ProceedReason) : GateDecision
+  data object Cancelled : GateDecision
+
+  companion object {
+    val FAIL_OPEN: Proceed = Proceed(ProceedReason.FAIL_OPEN)
+    val COMPLETED: Proceed = Proceed(ProceedReason.COMPLETED)
+  }
+}

package/android/src/main/java/tools/amply/sdk/reactnative/model/CampaignPresentPayload.kt

@@ -1,10 +1,11 @@
 package tools.amply.sdk.reactnative.model
 
 /**
- * A campaign present (blocking) action that has been dispatched to the JS layer and
- * is awaiting a terminal result reported back via `resolveCampaign`.
+ * A gate (blocking) presentation that has been dispatched to the JS layer and is
+ * awaiting a terminal result reported back via `resolveCampaign`.
  *
  * `mediationId` is the SDK-minted token correlating the dispatch with the JS reply;
+ * `params` carries the parsed query parameters of the gate action URL;
  * `info` carries the enriched, decoupled action info
  * (`url`, `campaignId`, `campaignName`, `triggeringEvent`, `triggeringProperties`, `content`).
  */
@@ -12,5 +13,6 @@ data class CampaignPresentPayload(
   val sequenceId: Long,
   val mediationId: String,
   val url: String,
+  val params: Map<String, Any?>,
   val info: Map<String, Any?>,
 )

package/android/src/newarch/java/tools/amply/sdk/reactnative/NativeAmplyModuleSpec.java

@@ -60,7 +60,7 @@ public abstract class NativeAmplyModuleSpec extends ReactContextBaseJavaModule i
 
   @ReactMethod
   @DoNotStrip
-  public abstract void trackEventGated(String event, ReadableMap properties, Promise promise);
+  public abstract void trackGated(String event, ReadableMap properties, Promise promise);
 
   @ReactMethod
   @DoNotStrip
@@ -68,7 +68,7 @@ public abstract class NativeAmplyModuleSpec extends ReactContextBaseJavaModule i
 
   @ReactMethod
   @DoNotStrip
-  public abstract void registerCampaignPresenter();
+  public abstract void registerGate(String baseUrl, String onAbort, double timeoutMs);
 
   @ReactMethod
   @DoNotStrip

package/android/src/newarch/jni/AmplyReactNative-generated.cpp

@@ -27,9 +27,9 @@ static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_track(facebo
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "track", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
 }
 
-static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_trackEventGated(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_trackGated(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
   static jmethodID cachedMethodId = nullptr;
-  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "trackEventGated", "(Ljava/lang/String;Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "trackGated", "(Ljava/lang/String;Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
 }
 
 static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_resolveCampaign(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
@@ -37,9 +37,9 @@ static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_resolveCampa
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "resolveCampaign", "(Ljava/lang/String;Ljava/lang/String;)V", args, count, cachedMethodId);
 }
 
-static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_registerCampaignPresenter(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_registerGate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
   static jmethodID cachedMethodId = nullptr;
-  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "registerCampaignPresenter", "()V", args, count, cachedMethodId);
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "registerGate", "(Ljava/lang/String;Ljava/lang/String;D)V", args, count, cachedMethodId);
 }
 
 static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
@@ -107,9 +107,9 @@ NativeAmplyModuleSpecJSI::NativeAmplyModuleSpecJSI(const JavaTurboModule::InitPa
   methodMap_["initialize"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_initialize};
   methodMap_["isInitialized"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_isInitialized};
   methodMap_["track"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_track};
-  methodMap_["trackEventGated"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_trackEventGated};
+  methodMap_["trackGated"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_trackGated};
   methodMap_["resolveCampaign"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_resolveCampaign};
-  methodMap_["registerCampaignPresenter"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_registerCampaignPresenter};
+  methodMap_["registerGate"] = MethodMetadata {3, __hostFunction_NativeAmplyModuleSpecJSI_registerGate};
   methodMap_["getRecentEvents"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents};
   methodMap_["getDataSetSnapshot"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot};
   methodMap_["registerDeepLinkListener"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_registerDeepLinkListener};