react-native-nitro-amplitude 0.1.0

package/.watchmanconfig

@@ -0,0 +1,6 @@
+{
+  "ignore_dirs": [
+    "android/.cxx",
+    "android/build"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 João Paulo C. Marra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# react-native-nitro-amplitude
+
+[![npm](https://img.shields.io/npm/v/react-native-nitro-amplitude)](https://www.npmjs.com/package/react-native-nitro-amplitude)
+[![MIT license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![React Native](https://img.shields.io/badge/react--native-%3E%3D0.75-61dafb)](https://reactnative.dev/)
+[![Nitro Modules](https://img.shields.io/badge/nitro--modules-%3E%3D0.35.7-black)](https://nitro.margelo.com/)
+
+High-performance Amplitude Analytics and Experiment SDK for React Native, powered by Nitro Modules and C++.
+
+This package combines the public APIs of `amplitude-rn-analytics` and `amplitude-rn-experiment` with a native Nitro layer for:
+
+- synchronous JSI key-value storage (analytics events + experiment variants)
+- synchronous device/application context collection
+- background HTTP transport for uploads and experiment fetches
+
+## Install
+
+```sh
+bun add react-native-nitro-amplitude react-native-nitro-modules@>=0.35.7
+```
+
+Peer dependencies: `react`, `react-native`, and `react-native-nitro-modules >=0.35.7`.
+
+Expo SDK 56:
+
+```sh
+bunx expo install react-native-nitro-amplitude react-native-nitro-modules
+```
+
+Add the config plugin and prebuild:
+
+```json
+{
+  "expo": {
+    "plugins": ["react-native-nitro-amplitude"]
+  }
+}
+```
+
+## Analytics quick start
+
+```ts
+import { init, track, identify, flush } from "react-native-nitro-amplitude";
+
+await init("YOUR_API_KEY", "user-id", {
+  instanceName: "$default_instance",
+  trackingSessionEvents: true,
+}).promise;
+
+track("button_clicked", { screen: "home" });
+await flush().promise;
+```
+
+## Experiment quick start
+
+```ts
+import { Experiment, init } from "react-native-nitro-amplitude";
+
+await init("YOUR_API_KEY").promise;
+
+const experiment = Experiment.initializeWithAmplitudeAnalytics("YOUR_API_KEY");
+await experiment.start();
+
+const variant = experiment.variant("my-flag");
+```
+
+## Compatibility imports
+
+The root entry exports both Analytics and Experiment APIs for new code:
+
+```ts
+import { init, track, Experiment } from "react-native-nitro-amplitude";
+```
+
+For migrations that need a clearer boundary between the two original packages,
+the package also exposes compatibility subpaths:
+
+```ts
+import { init, track } from "react-native-nitro-amplitude/analytics";
+import { Experiment } from "react-native-nitro-amplitude/experiment";
+```
+
+`react-native-nitro-amplitude/analytics` mirrors the public entrypoint shape of
+`amplitude-rn-analytics`. `react-native-nitro-amplitude/experiment` mirrors the
+public entrypoint shape of `amplitude-rn-experiment`.
+
+## Native HybridObjects
+
+| Object             | Purpose                                         |
+| ------------------ | ----------------------------------------------- |
+| `AmplitudeContext` | Device context + legacy SDK migration hooks     |
+| `AmplitudeStorage` | Memory + disk KV for analytics/experiment state |
+| `AmplitudeWorker`  | Background HTTP queue                           |
+
+## Upstream compatibility
+
+This package is a Nitro-first replacement, not a forked merge of the two source
+packages. The JavaScript API surface is intentionally aligned with:
+
+- `amplitude-rn-analytics` 1.6.0 for analytics client methods, storage provider
+  contracts, exported `Revenue`, `Identify`, and `Types`.
+- `amplitude-rn-experiment` 1.8.13 for `Experiment`, `ExperimentClient`,
+  config/user/variant/exposure/storage types, loggers, and memory storage.
+
+The default implementations differ where Nitro provides the native layer:
+
+- analytics storage uses Nitro-backed memory/disk storage by default;
+- experiment storage uses Nitro-backed storage by default;
+- analytics upload and experiment fetches use the native `AmplitudeWorker`;
+- native context is read through the `AmplitudeContext` HybridObject.
+
+## Platform support
+
+| Platform | Analytics                                 | Experiment  | Native Nitro |
+| -------- | ----------------------------------------- | ----------- | ------------ |
+| iOS      | Yes                                       | Yes         | Yes          |
+| Android  | Yes                                       | Yes         | Yes          |
+| Web      | Unsupported entry (`index.web.ts` throws) | Unsupported | No           |
+
+## Development
+
+From the monorepo root:
+
+```sh
+bun install
+bun run codegen
+bun run build
+bun run check
+bun run example:generate-icons   # after editing apps/example/scripts/generate-icons.sh
+bun run example:prebuild:clean
+bun run example:android
+bun run example:ios
+```
+
+See [AGENTS.md](./AGENTS.md) for package invariants and release bar.
+
+## License
+
+MIT

package/android/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.18.0)
+
+project(NitroAmplitude)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+file(GLOB SOURCES
+  "../cpp/bindings/*.cpp"
+  "./src/main/cpp/*.cpp"
+)
+list(FILTER SOURCES EXCLUDE REGEX ".*/[^/]*Test\\.cpp$")
+
+add_library(
+  NitroAmplitude
+  SHARED
+  ${SOURCES}
+)
+
+target_include_directories(
+  NitroAmplitude
+  PRIVATE
+  "../cpp/core"
+  "../cpp/bindings"
+  "./src/main/cpp"
+)
+
+include("../nitrogen/generated/android/NitroAmplitude+autolinking.cmake")
+
+target_link_libraries(
+  NitroAmplitude
+  android
+  log
+)

package/android/build.gradle

@@ -0,0 +1,85 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.10.1"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+// Apply autolinking script for Nitro
+apply from: "../nitrogen/generated/android/NitroAmplitude+autolinking.gradle"
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroAmplitude_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroAmplitude_" + name]).toInteger()
+}
+
+android {
+  namespace = "com.nitroamplitude"
+
+  // Use values from root project or defaults
+  ndkVersion = getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    consumerProguardFiles "consumer-rules.pro"
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  buildFeatures {
+    buildConfig = true
+    prefab = true
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+  
+  sourceSets {
+    main {
+      java.srcDirs += ["src/main/java"]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "androidx.security:security-crypto:1.1.0"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.0"
+  implementation project(":react-native-nitro-modules")
+}

package/android/consumer-rules.pro

@@ -0,0 +1,35 @@
+# NitroAmplitude - JNI-callable methods must survive R8/ProGuard shrinking
+
+-keep class com.nitroamplitude.AndroidAmplitudeAdapter {
+    public static *** setContext(...);
+    public static *** getContext(...);
+    public static *** prefetchContext(...);
+    public static *** getApplicationContextJson(...);
+    public static *** getLegacySessionDataJson(...);
+    public static *** getLegacyEventsJson(...);
+    public static *** removeLegacyEvent(...);
+    public static *** setDisk(...);
+    public static *** getDisk(...);
+    public static *** deleteDisk(...);
+    public static *** hasDisk(...);
+    public static *** getAllDiskKeys(...);
+    public static *** performHttpRequest(...);
+}
+
+-keep class com.nitroamplitude.AndroidAmplitudeAdapter$Companion {
+    public <methods>;
+}
+
+-keep class com.nitroamplitude.NitroAmplitudePackage {
+    <init>();
+    <clinit>();
+    *;
+}
+
+-keep class com.nitroamplitude.NitroAmplitudePackageKt {
+    public static *** initializeNitroAmplitude(...);
+}
+
+-keep class com.margelo.nitro.com.nitroamplitude.NitroAmplitudeOnLoad {
+    public static *** initializeNative(...);
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+NitroAmplitude_ndkVersion=27.1.12297006
+NitroAmplitude_compileSdkVersion=36
+NitroAmplitude_targetSdkVersion=36
+NitroAmplitude_minSdkVersion=24

package/android/src/main/cpp/AndroidAmplitudeAdapterCpp.cpp

@@ -0,0 +1,126 @@
+#include "AndroidAmplitudeAdapterCpp.hpp"
+
+namespace NitroAmplitude {
+
+using namespace facebook::jni;
+using JavaStringArray = JArrayClass<jstring>;
+
+namespace {
+
+std::vector<std::string> fromJavaStringArray(alias_ref<JavaStringArray> values) {
+  if (!values) {
+    return {};
+  }
+  std::vector<std::string> result;
+  const jsize size = values->size();
+  result.reserve(size);
+  for (jsize i = 0; i < size; ++i) {
+    auto current = values->getElement(i);
+    result.push_back(current ? current->toStdString() : std::string());
+  }
+  return result;
+}
+
+} // namespace
+
+AndroidAmplitudeAdapterCpp::AndroidAmplitudeAdapterCpp(alias_ref<JObject> /*context*/) {}
+
+void AndroidAmplitudeAdapterCpp::prefetchContext() {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<void()>("prefetchContext");
+  method(AndroidAmplitudeAdapterJava::javaClassStatic());
+}
+
+std::string AndroidAmplitudeAdapterCpp::getApplicationContextJson(const std::string& optionsJson) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<jstring(std::string)>(
+      "getApplicationContextJson", "(Ljava/lang/String;)Ljava/lang/String;");
+  auto result = method(AndroidAmplitudeAdapterJava::javaClassStatic(), optionsJson);
+  return result ? result->toStdString() : std::string("{}");
+}
+
+std::string AndroidAmplitudeAdapterCpp::getLegacySessionDataJson(const std::string& instanceName) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<jstring(std::string)>(
+      "getLegacySessionDataJson", "(Ljava/lang/String;)Ljava/lang/String;");
+  auto result = method(AndroidAmplitudeAdapterJava::javaClassStatic(), instanceName);
+  return result ? result->toStdString() : std::string("{}");
+}
+
+std::vector<std::string> AndroidAmplitudeAdapterCpp::getLegacyEventsJson(
+    const std::string& instanceName,
+    const std::string& eventKind) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<JavaStringArray(std::string, std::string)>(
+      "getLegacyEventsJson", "(Ljava/lang/String;Ljava/lang/String;)[Ljava/lang/String;");
+  return fromJavaStringArray(method(AndroidAmplitudeAdapterJava::javaClassStatic(), instanceName, eventKind));
+}
+
+void AndroidAmplitudeAdapterCpp::removeLegacyEvent(
+    const std::string& instanceName,
+    const std::string& eventKind,
+    int64_t eventId) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string, jlong)>(
+      "removeLegacyEvent", "(Ljava/lang/String;Ljava/lang/String;J)V");
+  method(AndroidAmplitudeAdapterJava::javaClassStatic(), instanceName, eventKind, eventId);
+}
+
+void AndroidAmplitudeAdapterCpp::setDisk(const std::string& key, const std::string& value) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>(
+      "setDisk", "(Ljava/lang/String;Ljava/lang/String;)V");
+  method(AndroidAmplitudeAdapterJava::javaClassStatic(), key, value);
+}
+
+std::optional<std::string> AndroidAmplitudeAdapterCpp::getDisk(const std::string& key) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<jstring(std::string)>(
+      "getDisk", "(Ljava/lang/String;)Ljava/lang/String;");
+  auto result = method(AndroidAmplitudeAdapterJava::javaClassStatic(), key);
+  if (!result) {
+    return std::nullopt;
+  }
+  return result->toStdString();
+}
+
+void AndroidAmplitudeAdapterCpp::deleteDisk(const std::string& key) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<void(std::string)>(
+      "deleteDisk", "(Ljava/lang/String;)V");
+  method(AndroidAmplitudeAdapterJava::javaClassStatic(), key);
+}
+
+bool AndroidAmplitudeAdapterCpp::hasDisk(const std::string& key) {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>(
+      "hasDisk", "(Ljava/lang/String;)Z");
+  return method(AndroidAmplitudeAdapterJava::javaClassStatic(), key);
+}
+
+std::vector<std::string> AndroidAmplitudeAdapterCpp::getAllDiskKeys() {
+  static auto method = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<JavaStringArray()>(
+      "getAllDiskKeys", "()[Ljava/lang/String;");
+  return fromJavaStringArray(method(AndroidAmplitudeAdapterJava::javaClassStatic()));
+}
+
+HttpResult AndroidAmplitudeAdapterCpp::performHttpRequest(
+    const std::string& url,
+    const std::string& method,
+    const std::string& headersJson,
+    const std::string& body,
+    int timeoutMillis) {
+  static auto requestMethod = AndroidAmplitudeAdapterJava::javaClassStatic()->getStaticMethod<JavaStringArray(
+      std::string, std::string, std::string, std::string, jint)>(
+      "performHttpRequest",
+      "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)[Ljava/lang/String;");
+  const auto result = fromJavaStringArray(requestMethod(
+      AndroidAmplitudeAdapterJava::javaClassStatic(),
+      url,
+      method,
+      headersJson,
+      body,
+      timeoutMillis));
+  HttpResult httpResult;
+  if (result.size() >= 3) {
+    httpResult.statusCode = std::stoi(result[0]);
+    httpResult.body = result[1];
+    httpResult.error = result[2];
+  } else {
+    httpResult.error = "Invalid HTTP response from Android adapter";
+  }
+  return httpResult;
+}
+
+} // namespace NitroAmplitude

package/android/src/main/cpp/AndroidAmplitudeAdapterCpp.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "../../cpp/core/NativeAmplitudeAdapter.hpp"
+#include <fbjni/fbjni.h>
+
+namespace NitroAmplitude {
+
+struct AndroidAmplitudeAdapterJava : facebook::jni::JavaClass<AndroidAmplitudeAdapterJava> {
+  static constexpr auto kJavaDescriptor = "Lcom/nitroamplitude/AndroidAmplitudeAdapter;";
+
+  static facebook::jni::alias_ref<facebook::jni::JObject> getContext() {
+    static auto method = javaClassStatic()->getStaticMethod<facebook::jni::JObject()>(
+        "getContext", "()Landroid/content/Context;");
+    return method(javaClassStatic());
+  }
+};
+
+class AndroidAmplitudeAdapterCpp : public NativeAmplitudeAdapter {
+public:
+  explicit AndroidAmplitudeAdapterCpp(facebook::jni::alias_ref<facebook::jni::JObject> context);
+  ~AndroidAmplitudeAdapterCpp() override = default;
+
+  void prefetchContext() override;
+  std::string getApplicationContextJson(const std::string& optionsJson) override;
+  std::string getLegacySessionDataJson(const std::string& instanceName) override;
+  std::vector<std::string> getLegacyEventsJson(
+      const std::string& instanceName,
+      const std::string& eventKind) override;
+  void removeLegacyEvent(
+      const std::string& instanceName,
+      const std::string& eventKind,
+      int64_t eventId) override;
+
+  void setDisk(const std::string& key, const std::string& value) override;
+  std::optional<std::string> getDisk(const std::string& key) override;
+  void deleteDisk(const std::string& key) override;
+  bool hasDisk(const std::string& key) override;
+  std::vector<std::string> getAllDiskKeys() override;
+
+  HttpResult performHttpRequest(
+      const std::string& url,
+      const std::string& method,
+      const std::string& headersJson,
+      const std::string& body,
+      int timeoutMillis) override;
+};
+
+} // namespace NitroAmplitude

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "../../../nitrogen/generated/android/NitroAmplitudeOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::NitroAmplitude::registerAllNatives();
+  });
+}

package/android/src/main/java/com/nitroamplitude/AndroidAmplitudeAdapter.kt

@@ -0,0 +1,147 @@
+package com.nitroamplitude
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.os.Build
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.Locale
+import java.util.concurrent.Executors
+
+object AndroidAmplitudeAdapter {
+  private var appContext: Context? = null
+  private val executor = Executors.newSingleThreadExecutor()
+  private var cachedContextJson: String = "{}"
+
+  @JvmStatic
+  fun setContext(context: Context) {
+    appContext = context.applicationContext
+  }
+
+  @JvmStatic
+  fun getContext(): Context {
+    return appContext ?: throw IllegalStateException("NitroAmplitude context not initialized")
+  }
+
+  private fun prefs(): SharedPreferences {
+    return getContext().getSharedPreferences("NitroAmplitude", Context.MODE_PRIVATE)
+  }
+
+  @JvmStatic
+  fun prefetchContext() {
+    executor.execute { cachedContextJson = buildApplicationContextJson("{}") }
+  }
+
+  @JvmStatic
+  fun getApplicationContextJson(optionsJson: String): String {
+    return buildApplicationContextJson(optionsJson)
+  }
+
+  private fun buildApplicationContextJson(optionsJson: String): String {
+    val context = getContext()
+    val options = try {
+      JSONObject(optionsJson)
+    } catch (_: Exception) {
+      JSONObject()
+    }
+
+    val locale = context.resources.configuration.locales[0]
+    val json = JSONObject()
+    json.put("version", context.packageManager.getPackageInfo(context.packageName, 0).versionName)
+    json.put("platform", "Android")
+    json.put("language", locale.language)
+    json.put("country", locale.country)
+    json.put("osName", "android")
+    json.put("osVersion", Build.VERSION.RELEASE)
+    json.put("deviceManufacturer", Build.MANUFACTURER)
+    json.put("deviceModel", Build.MODEL)
+    json.put("deviceBrand", Build.BRAND)
+    if (options.optBoolean("carrier", false)) {
+      json.put("carrier", "")
+    }
+    if (options.optBoolean("idfv", false)) {
+      json.put("idfv", "")
+    }
+    if (options.optBoolean("adid", false)) {
+      json.put("adid", "")
+    }
+    if (options.optBoolean("appSetId", false)) {
+      json.put("appSetId", "")
+    }
+    return json.toString()
+  }
+
+  @JvmStatic
+  fun getLegacySessionDataJson(instanceName: String): String = "{}"
+
+  @JvmStatic
+  fun getLegacyEventsJson(instanceName: String, eventKind: String): Array<String> = emptyArray()
+
+  @JvmStatic
+  fun removeLegacyEvent(instanceName: String, eventKind: String, eventId: Long) {}
+
+  @JvmStatic
+  fun setDisk(key: String, value: String) {
+    prefs().edit().putString(key, value).apply()
+  }
+
+  @JvmStatic
+  fun getDisk(key: String): String? = prefs().getString(key, null)
+
+  @JvmStatic
+  fun deleteDisk(key: String) {
+    prefs().edit().remove(key).apply()
+  }
+
+  @JvmStatic
+  fun hasDisk(key: String): Boolean = prefs().contains(key)
+
+  @JvmStatic
+  fun getAllDiskKeys(): Array<String> = prefs().all.keys.toTypedArray()
+
+  @JvmStatic
+  fun performHttpRequest(
+    url: String,
+    method: String,
+    headersJson: String,
+    body: String,
+    timeoutMillis: Int,
+  ): Array<String> {
+    val connection = (URL(url).openConnection() as HttpURLConnection).apply {
+      requestMethod = method
+      connectTimeout = timeoutMillis
+      readTimeout = timeoutMillis
+      doInput = true
+      val headers = try {
+        JSONObject(headersJson)
+      } catch (_: Exception) {
+        JSONObject()
+      }
+      val keys = headers.keys()
+      while (keys.hasNext()) {
+        val key = keys.next()
+        setRequestProperty(key, headers.optString(key))
+      }
+      if (body.isNotEmpty()) {
+        doOutput = true
+        outputStream.use { stream -> stream.write(body.toByteArray()) }
+      }
+    }
+
+    return try {
+      val status = connection.responseCode
+      val stream = if (status >= 400) connection.errorStream else connection.inputStream
+      val responseBody = stream?.let {
+        BufferedReader(InputStreamReader(it)).use { reader -> reader.readText() }
+      } ?: ""
+      arrayOf(status.toString(), responseBody, "")
+    } catch (error: Exception) {
+      arrayOf("0", "", error.message ?: "HTTP request failed")
+    } finally {
+      connection.disconnect()
+    }
+  }
+}

package/android/src/main/java/com/nitroamplitude/NitroAmplitudePackage.kt

@@ -0,0 +1,24 @@
+package com.nitroamplitude
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.margelo.nitro.com.nitroamplitude.NitroAmplitudeOnLoad
+
+class NitroAmplitudePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { emptyMap() }
+
+  companion object {
+    init {
+      System.loadLibrary("NitroAmplitude")
+    }
+  }
+}
+
+fun initializeNitroAmplitude(context: ReactApplicationContext) {
+  AndroidAmplitudeAdapter.setContext(context)
+  NitroAmplitudeOnLoad.initializeNative()
+}