@amplytools/react-native-amply-sdk 0.4.0 → 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.0'
+  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.0'
+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
@@ -42,6 +43,7 @@ class AmplyModule(reactContext: ReactApplicationContext) :
   private var lifecycleRegistered = false
   private var systemEventsJob: Job? = null
   private var logEventsJob: Job? = null
+  private var campaignPresenterJob: Job? = null
 
   override fun getName(): String = NAME
 
@@ -93,6 +95,47 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun trackGated(event: String, properties: ReadableMap, promise: Promise) {
+    if (event.isBlank()) {
+      // 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()
+    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
+      }
+      promise.resolve(decision.toWritableMap())
+    }
+  }
+
+  override fun resolveCampaign(mediationId: String, result: String) {
+    client.resolveCampaign(mediationId, result)
+  }
+
+  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 gate present to JS mediationId=${payload.mediationId} url=${payload.url}"
+          )
+          emitCampaignPresent(payload.mediationId, payload.url, payload.params, payload.info)
+        }
+      }
+      android.util.Log.i(TAG, "Started gate present collection job")
+    }
+    client.registerGate(baseUrl, onAbort, timeoutMs.toLong())
+  }
+
   override fun getRecentEvents(limit: Double, promise: Promise) {
     scope.launch {
       try {
@@ -212,6 +255,8 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     systemEventsJob = null
     logEventsJob?.cancel()
     logEventsJob = null
+    campaignPresenterJob?.cancel()
+    campaignPresenterJob = null
     lastEmittedDeepLinkId = null
     client.shutdown()
   }
@@ -228,6 +273,34 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     android.util.Log.d(TAG, "emitOnDeepLink completed")
   }
 
+  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)
+    }
+    // emitOnCampaignPresent comes from NativeAmplyModuleSpec (codegen).
+    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

@@ -6,6 +6,7 @@ import tools.amply.sdk.reactnative.model.DataSetType
 import tools.amply.sdk.reactnative.model.DeepLinkPayload
 import tools.amply.sdk.reactnative.model.EventEnvelope
 import tools.amply.sdk.reactnative.model.LogLevel
+import tools.amply.sdk.reactnative.model.CampaignPresentPayload
 import kotlinx.coroutines.flow.SharedFlow
 
 interface AmplyClient {
@@ -13,12 +14,47 @@ interface AmplyClient {
   val systemEvents: SharedFlow<EventEnvelope>
   val logEvents: SharedFlow<EventEnvelope>
 
+  /**
+   * Stream of campaign present (blocking) action dispatches awaiting a JS-reported result.
+   * Each emission carries a unique `mediationId` to be echoed back via
+   * [resolveCampaign].
+   */
+  val campaignPresents: SharedFlow<CampaignPresentPayload>
+
   suspend fun initialize(options: AmplyInitializationOptions)
 
   fun isInitialized(): Boolean
 
   suspend fun track(name: String, properties: Map<String, Any?>?)
 
+  /**
+   * 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].
+   */
+  suspend fun trackGated(
+    name: String,
+    properties: Map<String, Any?>?,
+  ): GateDecision
+
+  /**
+   * 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 registerGate(baseUrl: String, onAbort: String, timeoutMs: Long)
+
+  /**
+   * Report the terminal result (one of `Completed` / `Dismissed` / `Unavailable`) for
+   * a previously dispatched campaign present. Idempotent — late/duplicate or unknown
+   * `mediationId`s are ignored.
+   */
+  fun resolveCampaign(mediationId: String, result: String)
+
   suspend fun getRecentEvents(limit: Int): List<EventEnvelope>
 
   suspend fun getDataSetSnapshot(type: DataSetType): Map<String, Any?>

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

@@ -8,10 +8,13 @@ import tools.amply.sdk.reactnative.model.AmplyInitializationOptions
 import tools.amply.sdk.reactnative.model.DataSetType
 import tools.amply.sdk.reactnative.model.DeepLinkPayload
 import tools.amply.sdk.reactnative.model.EventEnvelope
+import tools.amply.sdk.reactnative.model.CampaignPresentPayload
 import tools.amply.sdk.reactnative.model.toNativeDataSetType
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicReference
+import java.util.UUID
 import java.lang.ref.WeakReference
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -22,7 +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.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
@@ -41,7 +50,13 @@ class DefaultAmplyClient(
   private val pendingPropertyOps = mutableListOf<(Amply) -> Unit>()
   private val deepLinkRegistered = AtomicBoolean(false)
   private val systemEventsRegistered = AtomicBoolean(false)
+  private val gatePresenterRegistered = AtomicBoolean(false)
   private val deepLinkSequence = AtomicLong(0L)
+  private val campaignPresentSequence = AtomicLong(0L)
+  // 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())
@@ -63,6 +78,12 @@ class DefaultAmplyClient(
   )
   override val logEvents: SharedFlow<EventEnvelope> = _logEvents.asSharedFlow()
 
+  private val _campaignPresents = MutableSharedFlow<CampaignPresentPayload>(
+    replay = 0,
+    extraBufferCapacity = 16,
+  )
+  override val campaignPresents: SharedFlow<CampaignPresentPayload> = _campaignPresents.asSharedFlow()
+
   override suspend fun initialize(options: AmplyInitializationOptions) {
     var createdInstance = false
     mutex.withLock {
@@ -134,6 +155,83 @@ class DefaultAmplyClient(
     }
   }
 
+  override suspend fun trackGated(
+    name: String,
+    properties: Map<String, Any?>?,
+  ): GateDecision {
+    val instance = amplyInstance
+    if (instance == null) {
+      // Fail open: not initialized yet -> proceed immediately (mirrors KMP row 1).
+      android.util.Log.w(
+        "AmplyReactNative",
+        "trackGated('$name') before init; failing open"
+      )
+      return GateDecision.FAIL_OPEN
+    }
+    android.util.Log.i(
+      "AmplyReactNative",
+      "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 registerGate(baseUrl: String, onAbort: String, timeoutMs: Long) {
+    val instance = requireInstance()
+    gatePresenterRegistered.set(true)
+    val policy = when (onAbort) {
+      "proceed" -> AbortPolicy.Proceed
+      else -> AbortPolicy.Cancel
+    }
+    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 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(
+        "AmplyReactNative",
+        "resolveCampaign for unknown/settled mediationId=$mediationId result=$result; ignored"
+      )
+      return
+    }
+    val mapped = result.toCampaignResult()
+    android.util.Log.i(
+      "AmplyReactNative",
+      "resolveCampaign mediationId=$mediationId result=$result -> $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> {
     val instance = requireInstance()
     return withContext(Dispatchers.IO) {
@@ -316,10 +414,22 @@ class DefaultAmplyClient(
     }
     deepLinkRegistered.set(false)
     systemEventsRegistered.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. Each
+    // OwnedResolution clears its owning presenter's current-id slot as it settles.
+    val inFlight = pendingCompletions.values.toList()
+    inFlight.forEach { owner ->
+      try {
+        owner.settle(CampaignResult.Unavailable)
+      } catch (error: Throwable) {
+        android.util.Log.w("AmplyReactNative", "Error settling gate presentation on shutdown: ${error.message}")
+      }
+    }
     _deepLinkEvents.resetReplayCache()
     _systemEvents.resetReplayCache()
   }
@@ -342,6 +452,36 @@ class DefaultAmplyClient(
   private fun Map<String, Any?>.toNonNullMap(): Map<String, Any> =
     entries.mapNotNull { (key, value) -> value?.let { key to it } }.toMap()
 
+  // Maps the JS-reported result string to the KMP enum. Strict semantics: anything
+  // that isn't a deliberate user 'Dismissed' or an explicit 'Completed' fails open to
+  // Unavailable (proceed) — never strand the continuation on a malformed value.
+  private fun String.toCampaignResult(): CampaignResult =
+    when (this) {
+      "Completed" -> CampaignResult.Completed
+      "Dismissed" -> CampaignResult.Dismissed
+      "Unavailable" -> CampaignResult.Unavailable
+      else -> {
+        android.util.Log.w(
+          "AmplyReactNative",
+          "Unknown campaign result '$this'; treating as Unavailable (fail-open)"
+        )
+        CampaignResult.Unavailable
+      }
+    }
+
+  // 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 }
 
@@ -417,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

@@ -0,0 +1,18 @@
+package tools.amply.sdk.reactnative.model
+
+/**
+ * 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`).
+ */
+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/main/java/tools/amply/sdk/reactnative/model/DeepLinkPayload.kt

@@ -1,5 +1,20 @@
 package tools.amply.sdk.reactnative.model
 
+/**
+ * A deep link emitted by an Amply campaign.
+ *
+ * As of the campaign->app action contract, the KMP SDK enriches `info` with the
+ * decoupled action keys (in addition to any campaign-authored content):
+ * - `url`                   — routing URL
+ * - `campaignId`            — id of the matched campaign
+ * - `campaignName`          — name of the matched campaign
+ * - `triggeringEvent`       — the event name that triggered the action
+ * - `triggeringProperties`  — the properties of the triggering event (Map)
+ * - `content`               — opaque, campaign-authored content passthrough (Map)
+ *
+ * The keys are carried inside [info]; older campaigns that only supplied a URL still
+ * round-trip unchanged (the extra keys are simply absent).
+ */
 data class DeepLinkPayload(
   val sequenceId: Long,
   val url: String,

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

@@ -42,6 +42,10 @@ public abstract class NativeAmplyModuleSpec extends ReactContextBaseJavaModule i
     mEventEmitterCallback.invoke("onDeepLink", value);
   }
 
+  protected final void emitOnCampaignPresent(ReadableMap value) {
+    mEventEmitterCallback.invoke("onCampaignPresent", value);
+  }
+
   @ReactMethod
   @DoNotStrip
   public abstract void initialize(ReadableMap config, Promise promise);
@@ -54,6 +58,18 @@ public abstract class NativeAmplyModuleSpec extends ReactContextBaseJavaModule i
   @DoNotStrip
   public abstract void track(ReadableMap payload, Promise promise);
 
+  @ReactMethod
+  @DoNotStrip
+  public abstract void trackGated(String event, ReadableMap properties, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void resolveCampaign(String mediationId, String result);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void registerGate(String baseUrl, String onAbort, double timeoutMs);
+
   @ReactMethod
   @DoNotStrip
   public abstract void getRecentEvents(double limit, Promise promise);

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

@@ -27,6 +27,21 @@ 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_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, "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) {
+  static jmethodID cachedMethodId = nullptr;
+  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_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, "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) {
   static jmethodID cachedMethodId = nullptr;
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "getRecentEvents", "(DLcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
@@ -92,6 +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_["trackGated"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_trackGated};
+  methodMap_["resolveCampaign"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_resolveCampaign};
+  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};
@@ -106,6 +124,7 @@ NativeAmplyModuleSpecJSI::NativeAmplyModuleSpecJSI(const JavaTurboModule::InitPa
   methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_removeListeners};
   eventEmitterMap_["onSystemEvent"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
   eventEmitterMap_["onDeepLink"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  eventEmitterMap_["onCampaignPresent"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
   configureEventEmitterCallback();
 }
 

package/dist/src/__tests__/campaignResolved.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=campaignResolved.test.d.ts.map

package/dist/src/__tests__/campaignResolved.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"campaignResolved.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/campaignResolved.test.ts"],"names":[],"mappings":""}