@amplytools/react-native-amply-sdk 0.1.0

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

@@ -0,0 +1,296 @@
+package tools.amply.sdk.reactnative.core
+
+import android.app.Activity
+import android.app.Application
+import android.os.Handler
+import android.os.Looper
+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.toNativeDataSetType
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.atomic.AtomicReference
+import java.lang.ref.WeakReference
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import tools.amply.sdk.Amply
+import tools.amply.sdk.actions.DeepLinkListener
+import tools.amply.sdk.config.AmplyConfig
+import tools.amply.sdk.config.amplyConfig
+import tools.amply.sdk.core.AmplySDKInterface
+import tools.amply.sdk.events.EventInterface
+import tools.amply.sdk.events.SystemEventsListener
+
+class DefaultAmplyClient(
+  private val application: Application,
+) : AmplyClient {
+
+  private val mutex = Mutex()
+  private var amplyInstance: Amply? = null
+  private val deepLinkRegistered = AtomicBoolean(false)
+  private val systemEventsRegistered = AtomicBoolean(false)
+  private val deepLinkSequence = AtomicLong(0L)
+  private val lastResumedActivity = AtomicReference<WeakReference<Activity>?>(null)
+  private val sessionPrimed = AtomicBoolean(false)
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  private val _deepLinkEvents = MutableSharedFlow<DeepLinkPayload>(
+    replay = 1,
+    extraBufferCapacity = 16,
+  )
+  override val deepLinkEvents: SharedFlow<DeepLinkPayload> = _deepLinkEvents.asSharedFlow()
+  private val _systemEvents = MutableSharedFlow<EventEnvelope>(
+    replay = 32,
+    extraBufferCapacity = 128,
+  )
+  override val systemEvents: SharedFlow<EventEnvelope> = _systemEvents.asSharedFlow()
+
+  override suspend fun initialize(options: AmplyInitializationOptions) {
+    var createdInstance = false
+    mutex.withLock {
+      if (amplyInstance == null) {
+        val config = buildConfig(options)
+        android.util.Log.i(
+          "AmplyReactNative",
+          "Initializing Amply with appId=${options.appId} apiKeyPublic=${options.apiKeyPublic.takeIf { it.isNotEmpty() } ?: "<empty>"}"
+        )
+        val instance = withContext(Dispatchers.Default) {
+          Amply(config, application)
+        }
+        ensureSystemEventsListener(instance)
+        amplyInstance = instance
+        createdInstance = true
+      }
+    }
+    if (createdInstance) {
+      maybePrimeSessionTracker()
+    }
+  }
+
+  override fun isInitialized(): Boolean = amplyInstance != null
+
+  override suspend fun track(name: String, properties: Map<String, Any?>?) {
+    val instance = requireInstance()
+    withContext(Dispatchers.IO) {
+      android.util.Log.i(
+        "AmplyReactNative",
+        "Tracking event '$name' with properties=${properties?.filterValues { it != null }}"
+      )
+      instance.track(name, properties?.toNonNullMap() ?: emptyMap())
+    }
+  }
+
+  override suspend fun getRecentEvents(limit: Int): List<EventEnvelope> {
+    val instance = requireInstance()
+    return withContext(Dispatchers.IO) {
+      val events = instance.getRecentEvents(limit)
+      android.util.Log.i(
+        "AmplyReactNative",
+        "Fetched ${events.size} recent events (limit=$limit)"
+      )
+      events.map { it.toEventEnvelope() }
+    }
+  }
+
+  override suspend fun getDataSetSnapshot(type: DataSetType): Map<String, Any?> {
+    val instance = requireInstance()
+    val nativeType = type.toNativeDataSetType()
+    return withContext(Dispatchers.IO) {
+      val snapshot = instance.getDataSetSnapshot(nativeType)
+      android.util.Log.i(
+        "AmplyReactNative",
+        "DataSetSnapshot(${type.javaClass.simpleName}) keys=${snapshot.keys}"
+      )
+      snapshot.toNullableValues()
+    }
+  }
+
+  /**
+   * Registers a listener for deep links triggered by Amply SDK campaigns.
+   *
+   * This listener allows app developers to:
+   * 1. Know that a deep link originated from Amply SDK (vs. external sources like
+   *    push notifications, browser links, or other SDKs)
+   * 2. Access campaign metadata via the `info` map (campaign ID, variant, etc.)
+   *    that is not available in the URL itself
+   * 3. Track/log Amply-specific deep link events for analytics
+   *
+   * Example use case:
+   *   // In JS:
+   *   Amply.addDeepLinkListener(event => {
+   *     // We know this deep link came from an Amply campaign, not from elsewhere
+   *     analytics.track('Amply campaign triggered', { url: event.url, info: event.info });
+   *   });
+   *
+   * The deep link flow:
+   *   Campaign triggers → KMP SDK → onDeepLink callback → JS event emitted
+   *                                      ↓ (then)
+   *                              startActivity(Intent.ACTION_VIEW) → Linking API
+   *
+   * Note: The listener is an observer, not a controller. The SDK will still open
+   * the URL via system after emitting the event.
+   */
+  override fun registerDeepLinkListener() {
+    val instance = requireInstance()
+    if (!deepLinkRegistered.compareAndSet(false, true)) {
+      return
+    }
+    android.util.Log.i("AmplyReactNative", "Registering deep link listener")
+
+    instance.registerDeepLinkListener(object : DeepLinkListener {
+      override fun onDeepLink(url: String, info: Map<String, Any>): Boolean {
+        android.util.Log.i(
+          "AmplyReactNative",
+          "Received deep link from Amply url=$url infoKeys=${info.keys}"
+        )
+        val payload = DeepLinkPayload(
+          sequenceId = deepLinkSequence.incrementAndGet(),
+          url = url,
+          info = info.mapValues { it.value },
+          consumed = false
+        )
+        if (!_deepLinkEvents.tryEmit(payload)) {
+          android.util.Log.w(
+            "AmplyReactNative",
+            "Dropping deep link event due to backpressure sequenceId=${payload.sequenceId}"
+          )
+        }
+        return false
+      }
+    })
+  }
+
+  override fun registerSystemEventListener() {
+    val instance = requireInstance()
+    android.util.Log.i(
+      "AmplyReactNative",
+      "registerSystemEventListener() called; alreadyRegistered=${systemEventsRegistered.get()}"
+    )
+    ensureSystemEventsListener(instance)
+  }
+
+  override fun onHostResume(activity: Activity?) {
+    if (activity != null) {
+      lastResumedActivity.set(WeakReference(activity))
+    }
+    maybePrimeSessionTracker()
+  }
+
+  override fun shutdown() {
+    runBlocking {
+      mutex.withLock {
+        amplyInstance = null
+      }
+    }
+    deepLinkRegistered.set(false)
+    systemEventsRegistered.set(false)
+    android.util.Log.i("AmplyReactNative", "Amply client shutdown; deep link listener cleared")
+    deepLinkSequence.set(0L)
+    sessionPrimed.set(false)
+    lastResumedActivity.set(null)
+    _deepLinkEvents.resetReplayCache()
+    _systemEvents.resetReplayCache()
+  }
+
+  private fun requireInstance(): Amply {
+    return amplyInstance ?: throw IllegalStateException("Amply has not been initialized yet")
+  }
+
+  private fun buildConfig(options: AmplyInitializationOptions): AmplyConfig {
+    return amplyConfig {
+      api {
+        appId = options.appId
+        apiKeyPublic = options.apiKeyPublic
+        options.apiKeySecret?.let { apiKeySecret = it }
+      }
+      options.defaultConfig?.let { defaultConfig = it }
+    }
+  }
+
+  private fun Map<String, Any?>.toNonNullMap(): Map<String, Any> =
+    entries.mapNotNull { (key, value) -> value?.let { key to it } }.toMap()
+
+  private fun Map<String, Any>.toNullableValues(): Map<String, Any?> =
+    mapValues { it.value }
+
+  private fun EventInterface.toEventEnvelope(): EventEnvelope =
+    EventEnvelope(
+      id = null,
+      name = name,
+      type = type.name.lowercase(),
+      timestamp = timestamp,
+      properties = properties.mapValues { it.value }
+    )
+
+  private fun ensureSystemEventsListener(instance: Amply) {
+    if (!systemEventsRegistered.compareAndSet(false, true)) {
+      android.util.Log.i(
+        "AmplyReactNative",
+        "System events listener already registered; skipping setSystemEventsListener"
+      )
+      return
+    }
+    instance.setSystemEventsListener(object : SystemEventsListener {
+      override fun onEvent(event: EventInterface) {
+        android.util.Log.i(
+          "AmplyReactNative",
+          "System event ${event.name} ts=${event.timestamp} props=${event.properties.keys}"
+        )
+        val envelope = event.toEventEnvelope()
+        if (!_systemEvents.tryEmit(envelope)) {
+          android.util.Log.w(
+            "AmplyReactNative",
+            "Dropping system event due to backpressure name=${event.name}"
+          )
+        }
+      }
+    })
+  }
+
+  private fun maybePrimeSessionTracker() {
+    if (sessionPrimed.get()) {
+      return
+    }
+    val instance = amplyInstance ?: return
+    val activity = lastResumedActivity.get()?.get() ?: return
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+      mainHandler.post { maybePrimeSessionTracker() }
+      return
+    }
+
+    try {
+      val coreField = Amply::class.java.getDeclaredField("amplyCore").apply {
+        isAccessible = true
+      }
+      val core = coreField.get(instance) as? AmplySDKInterface ?: return
+      val sessionManager = core.getSessionManager()
+      val trackerField = sessionManager.javaClass.getDeclaredField("sessionTracker").apply {
+        isAccessible = true
+      }
+      val sessionTracker = trackerField.get(sessionManager)
+      if (sessionTracker is Application.ActivityLifecycleCallbacks) {
+        sessionTracker.onActivityCreated(activity, null)
+        sessionTracker.onActivityStarted(activity)
+        sessionTracker.onActivityResumed(activity)
+        sessionPrimed.set(true)
+        android.util.Log.i(
+          "AmplyReactNative",
+          "Primed Amply session tracker with activity=${activity::class.java.simpleName}"
+        )
+      }
+    } catch (error: Throwable) {
+      android.util.Log.w(
+        "AmplyReactNative",
+        "Unable to prime Amply session tracker: ${error.message}"
+      )
+    }
+  }
+}

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

@@ -0,0 +1,10 @@
+package tools.amply.sdk.reactnative.model
+
+data class AmplyInitializationOptions(
+  val appId: String,
+  val apiKeyPublic: String,
+  val apiKeySecret: String?,
+  val endpoint: String?,
+  val datasetPrefetch: List<DataSetType>?,
+  val defaultConfig: String?,
+)

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

@@ -0,0 +1,42 @@
+package tools.amply.sdk.reactnative.model
+
+sealed interface DataSetType {
+  data object Device : DataSetType
+  data object User : DataSetType
+  data object Session : DataSetType
+
+  data class TriggeredEvent(
+    val countStrategy: CountStrategy,
+    val params: List<EventParam>,
+    val eventName: String?
+  ) : DataSetType {
+    enum class CountStrategy(val wireName: String) {
+      TOTAL("total"),
+      SESSION("session"),
+      USER("user");
+
+      companion object {
+        fun fromWireName(name: String?): CountStrategy? = entries.firstOrNull { it.wireName == name }
+      }
+    }
+  }
+
+  data class Events(val events: List<Event>) : DataSetType {
+    data class Event(
+      val name: String,
+      val type: EventType,
+      val params: List<EventParam>
+    )
+
+    enum class EventType(val wireName: String) {
+      CUSTOM("custom"),
+      SYSTEM("system");
+
+      companion object {
+        fun fromWireName(name: String?): EventType? = entries.firstOrNull { it.wireName == name }
+      }
+    }
+  }
+
+  data class EventParam(val name: String, val value: Any?)
+}

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

@@ -0,0 +1,38 @@
+package tools.amply.sdk.reactnative.model
+
+import tools.amply.sdk.datasets.DataSetType as NativeDataSetType
+import tools.amply.sdk.events.EventType as NativeEventType
+
+fun DataSetType.toNativeDataSetType(): NativeDataSetType = when (this) {
+  DataSetType.Device -> NativeDataSetType.Device
+  DataSetType.User -> NativeDataSetType.User
+  DataSetType.Session -> NativeDataSetType.Session
+is DataSetType.TriggeredEvent ->
+    NativeDataSetType.TriggeredEvent(
+      countStrategy = this.countStrategy.toNativeCountStrategy(),
+      params = params.mapNotNull { it.toNativeParamOrNull() },
+      eventName = eventName
+    )
+  is DataSetType.Events -> NativeDataSetType.Events(events.map { it.toNativeEventOrNull() }.filterNotNull())
+}
+
+private fun DataSetType.TriggeredEvent.CountStrategy.toNativeCountStrategy(): NativeDataSetType.TriggeredEvent.CountStrategy {
+  return NativeDataSetType.TriggeredEvent.CountStrategy.values().firstOrNull {
+    it.name.equals(name, ignoreCase = true)
+  } ?: throw IllegalArgumentException("Unsupported TriggeredEvent count strategy: $name")
+}
+
+private fun DataSetType.EventParam.toNativeParamOrNull(): NativeDataSetType.EventParam? =
+  value?.let { NativeDataSetType.EventParam(name, it) }
+
+private fun DataSetType.Events.Event.toNativeEventOrNull(): NativeDataSetType.Events.Event? {
+  val transformedParams = params.mapNotNull { it.toNativeParamOrNull() }
+  if (transformedParams.size != params.size) {
+    return null
+  }
+  return NativeDataSetType.Events.Event(
+    name = name,
+    type = NativeEventType.valueOf(type.name.uppercase()),
+    params = transformedParams
+  )
+}

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

@@ -0,0 +1,8 @@
+package tools.amply.sdk.reactnative.model
+
+data class DeepLinkPayload(
+  val sequenceId: Long,
+  val url: String,
+  val info: Map<String, Any?>,
+  val consumed: Boolean,
+)

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

@@ -0,0 +1,9 @@
+package tools.amply.sdk.reactnative.model
+
+data class EventEnvelope(
+  val id: String?,
+  val name: String,
+  val type: String,
+  val timestamp: Long,
+  val properties: Map<String, Any?>,
+)

package/android/src/main/jni/AmplyTurboModule.cpp

@@ -0,0 +1,29 @@
+#include <fbjni/fbjni.h>
+#include <react/newarchdefaults/DefaultTurboModuleManagerDelegate.h>
+#include <memory>
+#include <string>
+
+#include "AmplyReactNative.h"
+
+using namespace facebook;
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return jni::initialize(vm, [] {
+    const auto previousProvider =
+        react::DefaultTurboModuleManagerDelegate::javaModuleProvider;
+
+    react::DefaultTurboModuleManagerDelegate::javaModuleProvider =
+        [previousProvider](
+            const std::string &name,
+            const react::JavaTurboModule::InitParams &params)
+        -> std::shared_ptr<react::TurboModule> {
+      if (auto module = react::AmplyReactNative_ModuleProvider(name, params)) {
+        return module;
+      }
+      if (previousProvider) {
+        return previousProvider(name, params);
+      }
+      return nullptr;
+    };
+  });
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,76 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(AmplyReactNative LANGUAGES CXX)
+
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+# React Native dir передаётся Gradle
+set(REACT_SRC_ROOT "${REACT_NATIVE_DIR}")
+set(REACT_COMMON_DIR "${REACT_SRC_ROOT}/ReactCommon")
+set(REACT_ANDROID_SRC_DIR "${REACT_SRC_ROOT}/ReactAndroid/src/main/jni")
+set(REACT_JAVA_TURBO_DIR "${REACT_COMMON_DIR}/react/nativemodule/core/platform/android")
+set(REACT_CALL_INVOKER_DIR "${REACT_COMMON_DIR}/callinvoker")
+set(REACT_TURBO_CORE_DIR "${REACT_COMMON_DIR}/react/nativemodule/core")
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
+
+# Add codegen subdirectory (this will define react_codegen_AmplyReactNative target)
+add_subdirectory(
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../newarch/jni
+  ${CMAKE_CURRENT_BINARY_DIR}/codegen
+)
+
+# Now that targets are defined, propagate includes to the codegen target
+# This ensures OBJECT libraries can access all necessary headers (including folly)
+get_target_property(FBJNI_IFACE_INCLUDES fbjni::fbjni INTERFACE_INCLUDE_DIRECTORIES)
+if(FBJNI_IFACE_INCLUDES)
+  target_include_directories(react_codegen_AmplyReactNative PUBLIC ${FBJNI_IFACE_INCLUDES})
+endif()
+
+# Get includes from ReactAndroid::reactnative target (includes JSI, folly, etc.)
+# These includes contain folly/dynamic.h and other necessary React Native headers
+get_target_property(REACTNATIVE_IFACE_INCLUDES ReactAndroid::reactnative INTERFACE_INCLUDE_DIRECTORIES)
+if(REACTNATIVE_IFACE_INCLUDES)
+  target_include_directories(react_codegen_AmplyReactNative PUBLIC ${REACTNATIVE_IFACE_INCLUDES})
+endif()
+
+target_include_directories(
+  react_codegen_AmplyReactNative
+  PUBLIC
+  ${REACT_SRC_ROOT}
+  ${REACT_ANDROID_SRC_DIR}
+  ${REACT_COMMON_DIR}
+  ${REACT_CALL_INVOKER_DIR}
+  ${REACT_TURBO_CORE_DIR}
+  ${REACT_JAVA_TURBO_DIR}
+)
+
+add_library(
+  AmplyReactNative
+  SHARED
+  AmplyTurboModule.cpp
+)
+
+target_include_directories(
+  AmplyReactNative
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../newarch/jni
+  ${REACT_ANDROID_SRC_DIR}
+  ${REACT_SRC_ROOT}
+  ${REACT_COMMON_DIR}
+  ${REACT_CALL_INVOKER_DIR}
+  ${REACT_TURBO_CORE_DIR}
+  ${REACT_JAVA_TURBO_DIR}
+)
+
+target_link_libraries(
+  AmplyReactNative
+  react_codegen_AmplyReactNative # важно
+  ReactAndroid::reactnative
+  ReactAndroid::jsi
+  fbjni::fbjni
+)
+
+target_compile_reactnative_options(AmplyReactNative PRIVATE)

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

@@ -0,0 +1,75 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package tools.amply.sdk.reactnative;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+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.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeAmplyModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "Amply";
+
+  public NativeAmplyModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  protected final void emitOnSystemEvent(ReadableMap value) {
+    mEventEmitterCallback.invoke("onSystemEvent", value);
+  }
+
+  protected final void emitOnDeepLink(ReadableMap value) {
+    mEventEmitterCallback.invoke("onDeepLink", value);
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void initialize(ReadableMap config, Promise promise);
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean isInitialized();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void track(ReadableMap payload, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getRecentEvents(double limit, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getDataSetSnapshot(ReadableMap type, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void registerDeepLinkListener();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void addListener(String eventName);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void removeListeners(double count);
+}

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

@@ -0,0 +1,77 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniCpp.js
+ */
+
+#include "AmplyReactNative.h"
+
+namespace facebook::react {
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_initialize(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, "initialize", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_isInitialized(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, BooleanKind, "isInitialized", "()Z", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_track(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, "track", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)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);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot(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, "getDataSetSnapshot", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_registerDeepLinkListener(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, "registerDeepLinkListener", "()V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_addListener(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, "addListener", "(Ljava/lang/String;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_removeListeners(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, "removeListeners", "(D)V", args, count, cachedMethodId);
+}
+
+NativeAmplyModuleSpecJSI::NativeAmplyModuleSpecJSI(const JavaTurboModule::InitParams &params)
+  : JavaTurboModule(params) {
+  methodMap_["initialize"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_initialize};
+  methodMap_["isInitialized"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_isInitialized};
+  methodMap_["track"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_track};
+  methodMap_["getRecentEvents"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents};
+  methodMap_["getDataSetSnapshot"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot};
+  methodMap_["registerDeepLinkListener"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_registerDeepLinkListener};
+  methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_addListener};
+  methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_removeListeners};
+  eventEmitterMap_["onSystemEvent"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  eventEmitterMap_["onDeepLink"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  configureEventEmitterCallback();
+}
+
+std::shared_ptr<TurboModule> AmplyReactNative_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+  if (moduleName == "Amply") {
+    return std::make_shared<NativeAmplyModuleSpecJSI>(params);
+  }
+  return nullptr;
+}
+
+} // namespace facebook::react