@onekeyfe/react-native-background-thread 1.1.46 → 1.1.48

package/cpp/SharedRPC.cpp

@@ -0,0 +1,223 @@
+#include "SharedRPC.h"
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#define RPC_LOG(...) __android_log_print(ANDROID_LOG_INFO, "SharedRPC", __VA_ARGS__)
+#else
+#define RPC_LOG(...)
+#endif
+
+std::mutex SharedRPC::mutex_;
+std::unordered_map<std::string, RPCValue> SharedRPC::slots_;
+std::vector<RuntimeListener> SharedRPC::listeners_;
+
+void SharedRPC::install(jsi::Runtime &rt) {
+  auto rpc = std::make_shared<SharedRPC>();
+  auto obj = jsi::Object::createFromHostObject(rt, rpc);
+  rt.global().setProperty(rt, "sharedRPC", std::move(obj));
+}
+
+void SharedRPC::install(jsi::Runtime &rt, RPCRuntimeExecutor executor,
+                        const std::string &runtimeId) {
+  auto rpc = std::make_shared<SharedRPC>();
+  auto obj = jsi::Object::createFromHostObject(rt, rpc);
+  rt.global().setProperty(rt, "sharedRPC", std::move(obj));
+
+  std::lock_guard<std::mutex> lock(mutex_);
+  // Remove any existing listener with the same runtimeId (reload scenario).
+  // IMPORTANT: The old listener's callback is a jsi::Function tied to the old
+  // runtime. On reload, that runtime is already destroyed, so calling
+  // ~jsi::Function() would crash (null deref in Pointer::~Pointer).
+  // We intentionally leak the callback to avoid this.
+  for (auto &listener : listeners_) {
+    if (listener.runtimeId == runtimeId && listener.callback) {
+      new std::shared_ptr<jsi::Function>(std::move(listener.callback));
+    }
+  }
+  listeners_.erase(
+      std::remove_if(listeners_.begin(), listeners_.end(),
+                     [&runtimeId](const RuntimeListener &l) {
+                       return l.runtimeId == runtimeId;
+                     }),
+      listeners_.end());
+  listeners_.push_back({runtimeId, &rt, std::move(executor), nullptr});
+}
+
+void SharedRPC::reset() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  slots_.clear();
+  listeners_.clear();
+}
+
+void SharedRPC::notifyOtherRuntime(jsi::Runtime &callerRt, const std::string &callId) {
+  // Collect executors and callbacks under lock, then invoke outside lock
+  // to avoid deadlock (executor may schedule work that also acquires mutex_).
+  std::vector<std::pair<RPCRuntimeExecutor, std::shared_ptr<jsi::Function>>> toNotify;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    RPC_LOG("notifyOtherRuntime: callId=%s, listeners=%zu, callerRt=%p",
+            callId.c_str(), listeners_.size(), &callerRt);
+    for (auto &listener : listeners_) {
+      RPC_LOG("  listener: id=%s, rt=%p, hasCallback=%d",
+              listener.runtimeId.c_str(), listener.runtime, listener.callback != nullptr);
+      if (listener.runtime == &callerRt) continue;
+      if (!listener.callback) continue;
+      toNotify.emplace_back(listener.executor, listener.callback);
+    }
+    RPC_LOG("  toNotify count: %zu", toNotify.size());
+  }
+
+  for (auto &[executor, cb] : toNotify) {
+    auto id = callId;
+    RPC_LOG("  invoking executor for callId=%s", id.c_str());
+    executor([cb, id](jsi::Runtime &rt) {
+      RPC_LOG("  executor work running for callId=%s", id.c_str());
+      try {
+        cb->call(rt, jsi::String::createFromUtf8(rt, id));
+        RPC_LOG("  cb->call succeeded for callId=%s", id.c_str());
+      } catch (const jsi::JSError &e) {
+        RPC_LOG("  JSError in cb->call: %s", e.getMessage().c_str());
+      } catch (...) {
+        RPC_LOG("  Unknown error in cb->call");
+      }
+    });
+  }
+}
+
+RPCValue SharedRPC::extractValue(jsi::Runtime &rt, const jsi::Value &val) {
+  if (val.isBool()) {
+    return val.getBool();
+  }
+  if (val.isNumber()) {
+    return val.getNumber();
+  }
+  if (val.isString()) {
+    return val.getString(rt).utf8(rt);
+  }
+  throw jsi::JSError(rt,
+                     "SharedRPC: unsupported value type. "
+                     "Only bool, number, and string are supported.");
+}
+
+jsi::Value SharedRPC::toJSI(jsi::Runtime &rt, const RPCValue &val) {
+  if (std::holds_alternative<bool>(val)) {
+    return jsi::Value(std::get<bool>(val));
+  }
+  if (std::holds_alternative<double>(val)) {
+    return jsi::Value(std::get<double>(val));
+  }
+  // std::string
+  return jsi::String::createFromUtf8(rt, std::get<std::string>(val));
+}
+
+jsi::Value SharedRPC::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+  auto prop = name.utf8(rt);
+
+  // write(callId: string, value: bool | number | string): void
+  if (prop == "write") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 2,
+        [this](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+               size_t count) -> jsi::Value {
+          if (count < 2 || !args[0].isString()) {
+            throw jsi::JSError(
+                rt, "SharedRPC.write expects (callId: string, value)");
+          }
+          auto callId = args[0].getString(rt).utf8(rt);
+          auto value = extractValue(rt, args[1]);
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            slots_.insert_or_assign(callId, std::move(value));
+          }
+          // Notify OUTSIDE the lock
+          notifyOtherRuntime(rt, callId);
+          return jsi::Value::undefined();
+        });
+  }
+
+  // read(callId: string): bool | number | string | undefined
+  // Deletes the entry after reading (read-and-delete semantics).
+  if (prop == "read") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isString()) {
+            throw jsi::JSError(
+                rt, "SharedRPC.read expects (callId: string)");
+          }
+          auto callId = args[0].getString(rt).utf8(rt);
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            auto it = slots_.find(callId);
+            if (it == slots_.end()) {
+              return jsi::Value::undefined();
+            }
+            auto value = std::move(it->second);
+            slots_.erase(it);
+            return toJSI(rt, value);
+          }
+        });
+  }
+
+  // has(callId: string): boolean
+  if (prop == "has") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isString()) {
+            throw jsi::JSError(
+                rt, "SharedRPC.has expects (callId: string)");
+          }
+          auto callId = args[0].getString(rt).utf8(rt);
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            return jsi::Value(slots_.count(callId) > 0);
+          }
+        });
+  }
+
+  // pendingCount: number (getter, not a function)
+  if (prop == "pendingCount") {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return jsi::Value(static_cast<double>(slots_.size()));
+  }
+
+  // onWrite(callback: (callId: string) => void): void
+  if (prop == "onWrite") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isObject() ||
+              !args[0].asObject(rt).isFunction(rt)) {
+            throw jsi::JSError(rt, "SharedRPC.onWrite expects a function");
+          }
+          auto fn = std::make_shared<jsi::Function>(
+              args[0].asObject(rt).asFunction(rt));
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            for (auto &listener : listeners_) {
+              if (listener.runtime == &rt) {
+                listener.callback = std::move(fn);
+                break;
+              }
+            }
+          }
+          return jsi::Value::undefined();
+        });
+  }
+
+  return jsi::Value::undefined();
+}
+
+std::vector<jsi::PropNameID> SharedRPC::getPropertyNames(jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> props;
+  props.push_back(jsi::PropNameID::forUtf8(rt, "write"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "read"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "has"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "pendingCount"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "onWrite"));
+  return props;
+}

package/cpp/SharedRPC.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace jsi = facebook::jsi;
+
+using RPCValue = std::variant<bool, double, std::string>;
+
+// Executes a callback on a specific runtime's JS thread.
+// The implementation is platform-specific (iOS vs Android).
+using RPCRuntimeExecutor = std::function<void(std::function<void(jsi::Runtime &)>)>;
+
+struct RuntimeListener {
+  std::string runtimeId;                   // "main" or "background"
+  jsi::Runtime *runtime;
+  RPCRuntimeExecutor executor;
+  std::shared_ptr<jsi::Function> callback; // JS onWrite callback
+};
+
+class SharedRPC : public jsi::HostObject {
+public:
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  /// Legacy install without executor (no cross-runtime notification)
+  static void install(jsi::Runtime &rt);
+
+  /// Install with executor — enables cross-runtime write notifications
+  /// runtimeId should be "main" or "background" — used for dedup on reload.
+  static void install(jsi::Runtime &rt, RPCRuntimeExecutor executor,
+                      const std::string &runtimeId);
+
+  static void reset();
+
+private:
+  static RPCValue extractValue(jsi::Runtime &rt, const jsi::Value &val);
+  static jsi::Value toJSI(jsi::Runtime &rt, const RPCValue &val);
+  void notifyOtherRuntime(jsi::Runtime &callerRt, const std::string &callId);
+
+  static std::mutex mutex_;
+  static std::unordered_map<std::string, RPCValue> slots_;
+  static std::vector<RuntimeListener> listeners_;
+};

package/cpp/SharedStore.cpp

@@ -0,0 +1,184 @@
+#include "SharedStore.h"
+
+// Static member definitions
+std::mutex SharedStore::mutex_;
+std::unordered_map<std::string, StoreValue> SharedStore::data_;
+
+void SharedStore::install(jsi::Runtime &rt) {
+  auto store = std::make_shared<SharedStore>();
+  auto obj = jsi::Object::createFromHostObject(rt, store);
+  rt.global().setProperty(rt, "sharedStore", std::move(obj));
+}
+
+void SharedStore::reset() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  data_.clear();
+}
+
+StoreValue SharedStore::extractValue(jsi::Runtime &rt,
+                                     const jsi::Value &val) {
+  if (val.isBool()) {
+    return val.getBool();
+  }
+  if (val.isNumber()) {
+    return val.getNumber();
+  }
+  if (val.isString()) {
+    return val.getString(rt).utf8(rt);
+  }
+  throw jsi::JSError(rt,
+                     "SharedStore: unsupported value type. "
+                     "Only bool, number, and string are supported.");
+}
+
+jsi::Value SharedStore::toJSI(jsi::Runtime &rt, const StoreValue &val) {
+  if (std::holds_alternative<bool>(val)) {
+    return jsi::Value(std::get<bool>(val));
+  }
+  if (std::holds_alternative<double>(val)) {
+    return jsi::Value(std::get<double>(val));
+  }
+  if (std::holds_alternative<std::string>(val)) {
+    return jsi::String::createFromUtf8(rt, std::get<std::string>(val));
+  }
+  return jsi::Value::undefined();
+}
+
+jsi::Value SharedStore::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
+  auto prop = name.utf8(rt);
+
+  // set(key: string, value: bool | number | string): void
+  if (prop == "set") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 2,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 2 || !args[0].isString()) {
+            throw jsi::JSError(
+                rt, "SharedStore.set expects (string key, value)");
+          }
+          auto key = args[0].getString(rt).utf8(rt);
+          auto val = extractValue(rt, args[1]);
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            data_[std::move(key)] = std::move(val);
+          }
+          return jsi::Value::undefined();
+        });
+  }
+
+  // get(key: string): bool | number | string | undefined
+  if (prop == "get") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isString()) {
+            throw jsi::JSError(
+                rt, "SharedStore.get expects a string key");
+          }
+          auto key = args[0].getString(rt).utf8(rt);
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            auto it = data_.find(key);
+            if (it == data_.end()) {
+              return jsi::Value::undefined();
+            }
+            return toJSI(rt, it->second);
+          }
+        });
+  }
+
+  // has(key: string): boolean
+  if (prop == "has") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isString()) {
+            throw jsi::JSError(
+                rt, "SharedStore.has expects a string key");
+          }
+          auto key = args[0].getString(rt).utf8(rt);
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            return jsi::Value(data_.count(key) > 0);
+          }
+        });
+  }
+
+  // delete(key: string): boolean
+  if (prop == "delete") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isString()) {
+            throw jsi::JSError(
+                rt, "SharedStore.delete expects a string key");
+          }
+          auto key = args[0].getString(rt).utf8(rt);
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            return jsi::Value(data_.erase(key) > 0);
+          }
+        });
+  }
+
+  // keys(): string[]
+  if (prop == "keys") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 0,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *,
+           size_t) -> jsi::Value {
+          std::vector<std::string> allKeys;
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            allKeys.reserve(data_.size());
+            for (const auto &pair : data_) {
+              allKeys.push_back(pair.first);
+            }
+          }
+          auto arr = jsi::Array(rt, allKeys.size());
+          for (size_t i = 0; i < allKeys.size(); i++) {
+            arr.setValueAtIndex(
+                rt, i, jsi::String::createFromUtf8(rt, allKeys[i]));
+          }
+          return arr;
+        });
+  }
+
+  // clear(): void
+  if (prop == "clear") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 0,
+        [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *,
+           size_t) -> jsi::Value {
+          {
+            std::lock_guard<std::mutex> lock(mutex_);
+            data_.clear();
+          }
+          return jsi::Value::undefined();
+        });
+  }
+
+  // size: number (getter, not a function)
+  if (prop == "size") {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return jsi::Value(static_cast<double>(data_.size()));
+  }
+
+  return jsi::Value::undefined();
+}
+
+std::vector<jsi::PropNameID> SharedStore::getPropertyNames(jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> props;
+  props.push_back(jsi::PropNameID::forUtf8(rt, "set"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "get"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "has"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "delete"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "keys"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "clear"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "size"));
+  return props;
+}

package/cpp/SharedStore.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace jsi = facebook::jsi;
+
+using StoreValue = std::variant<bool, double, std::string>;
+
+class SharedStore : public jsi::HostObject {
+public:
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  static void install(jsi::Runtime &rt);
+  static void reset();
+
+private:
+  static StoreValue extractValue(jsi::Runtime &rt, const jsi::Value &val);
+  static jsi::Value toJSI(jsi::Runtime &rt, const StoreValue &val);
+
+  static std::mutex mutex_;
+  static std::unordered_map<std::string, StoreValue> data_;
+};

package/ios/BackgroundRunnerReactNativeDelegate.h

@@ -18,7 +18,6 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface BackgroundReactNativeDelegate : RCTDefaultReactNativeFactoryDelegate
 
-//@property (nonatomic) std::shared_ptr<const facebook::react::SandboxReactNativeViewEventEmitter> eventEmitter;
 @property (nonatomic, assign) BOOL hasOnMessageHandler;
 @property (nonatomic, assign) BOOL hasOnErrorHandler;
 
@@ -26,28 +25,12 @@ NS_ASSUME_NONNULL_BEGIN
 
 @property (nonatomic, readwrite) std::string origin;
 
-@property (nonatomic, copy) void (^onMessageCallback)(NSString *message);
-
 /**
  * Initializes the delegate.
  * @return Initialized delegate instance with filtered module access
  */
 - (instancetype)init;
 
-/**
- * Posts a message to the JavaScript runtime.
- * @param message C++ string containing the JSON.stringified message
- */
-- (void)postMessage:(const std::string &)message;
-
-/**
- * Routes a message to a specific sandbox delegate.
- * @param message The message to route
- * @param targetId The ID of the target sandbox
- * @return true if the message was successfully routed, false otherwise
- */
-- (bool)routeMessage:(const std::string &)message toSandbox:(const std::string &)targetId;
-
 @end
 
 NS_ASSUME_NONNULL_END