react-native-nitro-amplitude 0.1.0

package/app.plugin.js

@@ -0,0 +1,36 @@
+const { withMainApplication, createRunOncePlugin } = require("@expo/config-plugins");
+
+const withNitroAmplitude = (config) => {
+  return withMainApplication(config, (config) => {
+    const { modResults } = config;
+    const { language, contents } = modResults;
+
+    if (language === "kt") {
+      if (!contents.includes("AndroidAmplitudeAdapter.setContext")) {
+        const importStatement =
+          "import com.nitroamplitude.AndroidAmplitudeAdapter";
+        const initStatement = "    AndroidAmplitudeAdapter.setContext(this)";
+
+        if (!contents.includes(importStatement)) {
+          modResults.contents = contents.replace(
+            /(package .*\n)/,
+            `$1\n${importStatement}\n`,
+          );
+        }
+
+        modResults.contents = modResults.contents.replace(
+          /(super\.onCreate\(\))/,
+          `$1\n${initStatement}`,
+        );
+      }
+    }
+
+    return config;
+  });
+};
+
+module.exports = createRunOncePlugin(
+  withNitroAmplitude,
+  "react-native-nitro-amplitude",
+  "1.0.0",
+);

package/cpp/bindings/HybridAmplitudeContext.cpp

@@ -0,0 +1,83 @@
+#include "HybridAmplitudeContext.hpp"
+
+#ifndef NITRO_AMPLITUDE_DISABLE_PLATFORM_ADAPTER
+#if __APPLE__
+#include "../../ios/IOSAmplitudeAdapterCpp.hpp"
+#elif __ANDROID__
+#include "../../android/src/main/cpp/AndroidAmplitudeAdapterCpp.hpp"
+#include <fbjni/fbjni.h>
+#endif
+#endif
+
+#include <cmath>
+#include <stdexcept>
+
+namespace margelo::nitro::NitroAmplitude {
+
+namespace {
+std::shared_ptr<::NitroAmplitude::NativeAmplitudeAdapter> createPlatformAdapter() {
+#ifndef NITRO_AMPLITUDE_DISABLE_PLATFORM_ADAPTER
+#if __APPLE__
+  return std::make_shared<::NitroAmplitude::IOSAmplitudeAdapterCpp>();
+#elif __ANDROID__
+  auto context = ::NitroAmplitude::AndroidAmplitudeAdapterJava::getContext();
+  return std::make_shared<::NitroAmplitude::AndroidAmplitudeAdapterCpp>(context);
+#else
+  return nullptr;
+#endif
+#else
+  return nullptr;
+#endif
+}
+} // namespace
+
+HybridAmplitudeContext::HybridAmplitudeContext()
+    : HybridObject(TAG), HybridAmplitudeContextSpec() {
+  adapter_ = createPlatformAdapter();
+}
+
+void HybridAmplitudeContext::prefetch() {
+  if (adapter_) {
+    adapter_->prefetchContext();
+  }
+}
+
+std::string HybridAmplitudeContext::getApplicationContextJson(
+    const std::string& optionsJson) {
+  if (!adapter_) {
+    return "{}";
+  }
+  return adapter_->getApplicationContextJson(optionsJson);
+}
+
+std::string HybridAmplitudeContext::getLegacySessionDataJson(
+    const std::string& instanceName) {
+  if (!adapter_) {
+    return "{}";
+  }
+  return adapter_->getLegacySessionDataJson(instanceName);
+}
+
+std::vector<std::string> HybridAmplitudeContext::getLegacyEventsJson(
+    const std::string& instanceName,
+    const std::string& eventKind) {
+  if (!adapter_) {
+    return {};
+  }
+  return adapter_->getLegacyEventsJson(instanceName, eventKind);
+}
+
+void HybridAmplitudeContext::removeLegacyEvent(
+    const std::string& instanceName,
+    const std::string& eventKind,
+    double eventId) {
+  if (!adapter_) {
+    return;
+  }
+  if (std::isnan(eventId) || std::isinf(eventId)) {
+    throw std::runtime_error("NitroAmplitude: Invalid eventId");
+  }
+  adapter_->removeLegacyEvent(instanceName, eventKind, static_cast<int64_t>(eventId));
+}
+
+} // namespace margelo::nitro::NitroAmplitude

package/cpp/bindings/HybridAmplitudeContext.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "HybridAmplitudeContextSpec.hpp"
+#include "../core/NativeAmplitudeAdapter.hpp"
+#include <memory>
+
+namespace margelo::nitro::NitroAmplitude {
+
+class HybridAmplitudeContext : public HybridAmplitudeContextSpec {
+public:
+  HybridAmplitudeContext();
+  ~HybridAmplitudeContext() override = default;
+
+  void prefetch() 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,
+      double eventId) override;
+
+private:
+  std::shared_ptr<::NitroAmplitude::NativeAmplitudeAdapter> adapter_;
+};
+
+} // namespace margelo::nitro::NitroAmplitude

package/cpp/bindings/HybridAmplitudeStorage.cpp

@@ -0,0 +1,163 @@
+#include "HybridAmplitudeStorage.hpp"
+
+#ifndef NITRO_AMPLITUDE_DISABLE_PLATFORM_ADAPTER
+#if __APPLE__
+#include "../../ios/IOSAmplitudeAdapterCpp.hpp"
+#elif __ANDROID__
+#include "../../android/src/main/cpp/AndroidAmplitudeAdapterCpp.hpp"
+#include <fbjni/fbjni.h>
+#endif
+#endif
+
+#include <stdexcept>
+
+namespace margelo::nitro::NitroAmplitude {
+
+namespace {
+constexpr auto kBatchMissingSentinel = "__nitro_amplitude_batch_missing__::v1";
+
+std::shared_ptr<::NitroAmplitude::NativeAmplitudeAdapter> createPlatformAdapter() {
+#ifndef NITRO_AMPLITUDE_DISABLE_PLATFORM_ADAPTER
+#if __APPLE__
+  return std::make_shared<::NitroAmplitude::IOSAmplitudeAdapterCpp>();
+#elif __ANDROID__
+  auto context = ::NitroAmplitude::AndroidAmplitudeAdapterJava::getContext();
+  return std::make_shared<::NitroAmplitude::AndroidAmplitudeAdapterCpp>(context);
+#else
+  return nullptr;
+#endif
+#else
+  return nullptr;
+#endif
+}
+} // namespace
+
+HybridAmplitudeStorage::HybridAmplitudeStorage()
+    : HybridObject(TAG), HybridAmplitudeStorageSpec() {
+  adapter_ = createPlatformAdapter();
+}
+
+void HybridAmplitudeStorage::set(
+    const std::string& key,
+    const std::string& value,
+    bool persist) {
+  if (persist) {
+    if (!adapter_) {
+      throw std::runtime_error("NitroAmplitude: Disk adapter unavailable");
+    }
+    adapter_->setDisk(key, value);
+    return;
+  }
+  std::lock_guard<std::mutex> lock(memoryMutex_);
+  memoryStore_[key] = value;
+}
+
+std::optional<std::string> HybridAmplitudeStorage::get(
+    const std::string& key,
+    bool persist) {
+  if (persist) {
+    if (!adapter_) {
+      return std::nullopt;
+    }
+    return adapter_->getDisk(key);
+  }
+  std::lock_guard<std::mutex> lock(memoryMutex_);
+  auto it = memoryStore_.find(key);
+  if (it == memoryStore_.end()) {
+    return std::nullopt;
+  }
+  return it->second;
+}
+
+void HybridAmplitudeStorage::remove(const std::string& key, bool persist) {
+  if (persist) {
+    if (adapter_) {
+      adapter_->deleteDisk(key);
+    }
+    return;
+  }
+  std::lock_guard<std::mutex> lock(memoryMutex_);
+  memoryStore_.erase(key);
+}
+
+void HybridAmplitudeStorage::clear(bool persist) {
+  if (persist) {
+    if (!adapter_) {
+      return;
+    }
+    for (const auto& key : adapter_->getAllDiskKeys()) {
+      adapter_->deleteDisk(key);
+    }
+    return;
+  }
+  std::lock_guard<std::mutex> lock(memoryMutex_);
+  memoryStore_.clear();
+}
+
+bool HybridAmplitudeStorage::has(const std::string& key, bool persist) {
+  if (persist) {
+    return adapter_ ? adapter_->hasDisk(key) : false;
+  }
+  std::lock_guard<std::mutex> lock(memoryMutex_);
+  return memoryStore_.find(key) != memoryStore_.end();
+}
+
+std::vector<std::string> HybridAmplitudeStorage::getAllKeys(bool persist) {
+  if (persist) {
+    return adapter_ ? adapter_->getAllDiskKeys() : std::vector<std::string>{};
+  }
+  std::lock_guard<std::mutex> lock(memoryMutex_);
+  std::vector<std::string> keys;
+  keys.reserve(memoryStore_.size());
+  for (const auto& entry : memoryStore_) {
+    keys.push_back(entry.first);
+  }
+  return keys;
+}
+
+std::vector<std::string> HybridAmplitudeStorage::getKeysByPrefix(
+    const std::string& prefix,
+    bool persist) {
+  const auto keys = getAllKeys(persist);
+  std::vector<std::string> filtered;
+  for (const auto& key : keys) {
+    if (key.rfind(prefix, 0) == 0) {
+      filtered.push_back(key);
+    }
+  }
+  return filtered;
+}
+
+void HybridAmplitudeStorage::setBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values,
+    bool persist) {
+  if (keys.size() != values.size()) {
+    throw std::runtime_error("NitroAmplitude: setBatch key/value length mismatch");
+  }
+  for (size_t i = 0; i < keys.size(); ++i) {
+    set(keys[i], values[i], persist);
+  }
+}
+
+std::vector<std::string> HybridAmplitudeStorage::getBatch(
+    const std::vector<std::string>& keys,
+    bool persist) {
+  std::vector<std::string> values;
+  values.reserve(keys.size());
+  for (const auto& key : keys) {
+    const auto value = get(key, persist);
+    values.push_back(value.value_or(kBatchMissingSentinel));
+  }
+  return values;
+}
+
+void HybridAmplitudeStorage::removeBatch(
+    const std::vector<std::string>& keys,
+    bool persist) {
+  for (const auto& key : keys) {
+    remove(key, persist);
+  }
+}
+
+} // namespace margelo::nitro::NitroAmplitude

package/cpp/bindings/HybridAmplitudeStorage.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "HybridAmplitudeStorageSpec.hpp"
+#include "../core/NativeAmplitudeAdapter.hpp"
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+namespace margelo::nitro::NitroAmplitude {
+
+class HybridAmplitudeStorage : public HybridAmplitudeStorageSpec {
+public:
+  HybridAmplitudeStorage();
+  ~HybridAmplitudeStorage() override = default;
+
+  void set(const std::string& key, const std::string& value, bool persist) override;
+  std::optional<std::string> get(const std::string& key, bool persist) override;
+  void remove(const std::string& key, bool persist) override;
+  void clear(bool persist) override;
+  bool has(const std::string& key, bool persist) override;
+  std::vector<std::string> getAllKeys(bool persist) override;
+  std::vector<std::string> getKeysByPrefix(const std::string& prefix, bool persist) override;
+  void setBatch(
+      const std::vector<std::string>& keys,
+      const std::vector<std::string>& values,
+      bool persist) override;
+  std::vector<std::string> getBatch(
+      const std::vector<std::string>& keys,
+      bool persist) override;
+  void removeBatch(const std::vector<std::string>& keys, bool persist) override;
+
+private:
+  std::shared_ptr<::NitroAmplitude::NativeAmplitudeAdapter> adapter_;
+  std::unordered_map<std::string, std::string> memoryStore_;
+  std::mutex memoryMutex_;
+};
+
+} // namespace margelo::nitro::NitroAmplitude

package/cpp/bindings/HybridAmplitudeWorker.cpp

@@ -0,0 +1,162 @@
+#include "HybridAmplitudeWorker.hpp"
+
+#ifndef NITRO_AMPLITUDE_DISABLE_PLATFORM_ADAPTER
+#if __APPLE__
+#include "../../ios/IOSAmplitudeAdapterCpp.hpp"
+#elif __ANDROID__
+#include "../../android/src/main/cpp/AndroidAmplitudeAdapterCpp.hpp"
+#include <fbjni/fbjni.h>
+#endif
+#endif
+
+#include <algorithm>
+#include <cmath>
+#include <stdexcept>
+
+namespace margelo::nitro::NitroAmplitude {
+
+namespace {
+std::shared_ptr<::NitroAmplitude::NativeAmplitudeAdapter> createPlatformAdapter() {
+#ifndef NITRO_AMPLITUDE_DISABLE_PLATFORM_ADAPTER
+#if __APPLE__
+  return std::make_shared<::NitroAmplitude::IOSAmplitudeAdapterCpp>();
+#elif __ANDROID__
+  auto context = ::NitroAmplitude::AndroidAmplitudeAdapterJava::getContext();
+  return std::make_shared<::NitroAmplitude::AndroidAmplitudeAdapterCpp>(context);
+#else
+  return nullptr;
+#endif
+#else
+  return nullptr;
+#endif
+}
+} // namespace
+
+HybridAmplitudeWorker::HybridAmplitudeWorker()
+    : HybridObject(TAG), HybridAmplitudeWorkerSpec() {
+  adapter_ = createPlatformAdapter();
+  workerThread_ = std::thread([this]() { workerLoop(); });
+}
+
+HybridAmplitudeWorker::~HybridAmplitudeWorker() {
+  {
+    std::lock_guard<std::mutex> lock(queueMutex_);
+    running_ = false;
+  }
+  queueCv_.notify_all();
+  if (workerThread_.joinable()) {
+    workerThread_.join();
+  }
+}
+
+void HybridAmplitudeWorker::enqueue(
+    const std::string& requestId,
+    const std::string& url,
+    const std::string& method,
+    const std::string& headersJson,
+    const std::string& body,
+    double timeoutMillis) {
+  if (requestId.empty() || url.empty()) {
+    throw std::runtime_error("NitroAmplitude: Invalid HTTP request");
+  }
+  if (std::isnan(timeoutMillis) || std::isinf(timeoutMillis) || timeoutMillis <= 0.0) {
+    timeoutMillis = 10000.0;
+  }
+
+  WorkerRequest request{
+      requestId,
+      url,
+      method,
+      headersJson,
+      body,
+      static_cast<int>(timeoutMillis),
+  };
+
+  {
+    std::lock_guard<std::mutex> lock(queueMutex_);
+    cancelledRequests_.erase(requestId);
+    queue_.push(std::move(request));
+    queueSize_ = queue_.size();
+  }
+  queueCv_.notify_one();
+}
+
+void HybridAmplitudeWorker::cancel(const std::string& requestId) {
+  std::lock_guard<std::mutex> lock(queueMutex_);
+  cancelledRequests_.insert(requestId);
+}
+
+std::function<void()> HybridAmplitudeWorker::addOnComplete(
+    const std::function<void(
+        const std::string&,
+        double,
+        const std::string&,
+        const std::string&)>& callback) {
+  std::lock_guard<std::mutex> lock(listenersMutex_);
+  const size_t listenerId = ++nextListenerId_;
+  listeners_.push_back(Listener{listenerId, callback});
+  return [this, listenerId]() {
+    std::lock_guard<std::mutex> innerLock(listenersMutex_);
+    listeners_.erase(
+        std::remove_if(
+            listeners_.begin(),
+            listeners_.end(),
+            [listenerId](const Listener& listener) { return listener.id == listenerId; }),
+        listeners_.end());
+  };
+}
+
+double HybridAmplitudeWorker::queueSize() {
+  return static_cast<double>(queueSize_.load());
+}
+
+void HybridAmplitudeWorker::workerLoop() {
+  while (true) {
+    WorkerRequest request;
+    {
+      std::unique_lock<std::mutex> lock(queueMutex_);
+      queueCv_.wait(lock, [this]() { return !running_ || !queue_.empty(); });
+      if (!running_ && queue_.empty()) {
+        return;
+      }
+      request = std::move(queue_.front());
+      queue_.pop();
+      queueSize_ = queue_.size();
+      if (cancelledRequests_.erase(request.requestId) > 0) {
+        notifyComplete(request.requestId, 0, "", "cancelled");
+        continue;
+      }
+    }
+
+    if (!adapter_) {
+      notifyComplete(request.requestId, 0, "", "Native adapter unavailable");
+      continue;
+    }
+
+    const auto result = adapter_->performHttpRequest(
+        request.url,
+        request.method,
+        request.headersJson,
+        request.body,
+        request.timeoutMillis);
+
+    notifyComplete(
+        request.requestId,
+        static_cast<double>(result.statusCode),
+        result.body,
+        result.error);
+  }
+}
+
+void HybridAmplitudeWorker::notifyComplete(
+    const std::string& requestId,
+    double statusCode,
+    const std::string& body,
+    const std::string& error) {
+  std::lock_guard<std::mutex> lock(listenersMutex_);
+  for (const auto& listener : listeners_) {
+    listener.callback(requestId, statusCode, body, error);
+  }
+}
+
+} // namespace margelo::nitro::NitroAmplitude

package/cpp/bindings/HybridAmplitudeWorker.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "HybridAmplitudeWorkerSpec.hpp"
+#include "../core/NativeAmplitudeAdapter.hpp"
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_set>
+#include <vector>
+
+namespace margelo::nitro::NitroAmplitude {
+
+struct WorkerRequest {
+  std::string requestId;
+  std::string url;
+  std::string method;
+  std::string headersJson;
+  std::string body;
+  int timeoutMillis = 10000;
+};
+
+class HybridAmplitudeWorker : public HybridAmplitudeWorkerSpec {
+public:
+  HybridAmplitudeWorker();
+  ~HybridAmplitudeWorker() override;
+
+  void enqueue(
+      const std::string& requestId,
+      const std::string& url,
+      const std::string& method,
+      const std::string& headersJson,
+      const std::string& body,
+      double timeoutMillis) override;
+  void cancel(const std::string& requestId) override;
+  std::function<void()> addOnComplete(
+      const std::function<void(
+          const std::string&,
+          double,
+          const std::string&,
+          const std::string&)>& callback) override;
+  double queueSize() override;
+
+private:
+  void workerLoop();
+  void notifyComplete(
+      const std::string& requestId,
+      double statusCode,
+      const std::string& body,
+      const std::string& error);
+
+  std::shared_ptr<::NitroAmplitude::NativeAmplitudeAdapter> adapter_;
+  std::thread workerThread_;
+  std::mutex queueMutex_;
+  std::condition_variable queueCv_;
+  std::queue<WorkerRequest> queue_;
+  std::unordered_set<std::string> cancelledRequests_;
+  std::atomic<bool> running_{true};
+  std::atomic<size_t> queueSize_{0};
+
+  std::mutex listenersMutex_;
+  struct Listener {
+    size_t id;
+    std::function<void(const std::string&, double, const std::string&, const std::string&)> callback;
+  };
+  std::vector<Listener> listeners_;
+  size_t nextListenerId_ = 0;
+};
+
+} // namespace margelo::nitro::NitroAmplitude

package/cpp/core/NativeAmplitudeAdapter.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace NitroAmplitude {
+
+struct HttpResult {
+  int statusCode = 0;
+  std::string body;
+  std::string error;
+};
+
+class NativeAmplitudeAdapter {
+public:
+  virtual ~NativeAmplitudeAdapter() = default;
+
+  virtual void prefetchContext() = 0;
+  virtual std::string getApplicationContextJson(const std::string& optionsJson) = 0;
+  virtual std::string getLegacySessionDataJson(const std::string& instanceName) = 0;
+  virtual std::vector<std::string> getLegacyEventsJson(
+      const std::string& instanceName,
+      const std::string& eventKind) = 0;
+  virtual void removeLegacyEvent(
+      const std::string& instanceName,
+      const std::string& eventKind,
+      int64_t eventId) = 0;
+
+  virtual void setDisk(const std::string& key, const std::string& value) = 0;
+  virtual std::optional<std::string> getDisk(const std::string& key) = 0;
+  virtual void deleteDisk(const std::string& key) = 0;
+  virtual bool hasDisk(const std::string& key) = 0;
+  virtual std::vector<std::string> getAllDiskKeys() = 0;
+
+  virtual HttpResult performHttpRequest(
+      const std::string& url,
+      const std::string& method,
+      const std::string& headersJson,
+      const std::string& body,
+      int timeoutMillis) = 0;
+};
+
+} // namespace NitroAmplitude

package/ios/IOSAmplitudeAdapterCpp.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "../../cpp/core/NativeAmplitudeAdapter.hpp"
+
+namespace NitroAmplitude {
+
+class IOSAmplitudeAdapterCpp : public NativeAmplitudeAdapter {
+public:
+  IOSAmplitudeAdapterCpp();
+  ~IOSAmplitudeAdapterCpp() 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