@onekeyfe/react-native-background-thread 3.0.40 → 3.0.42

package/cpp/SharedRPC.cpp

@@ -1,5 +1,7 @@
 #include "SharedRPC.h"
 
+#include "SharedStore.h"
+
 #include <algorithm>
 
 #ifdef __ANDROID__
@@ -10,8 +12,8 @@
 #endif
 
 std::mutex SharedRPC::mutex_;
-std::unordered_map<std::string, RPCValue> SharedRPC::slots_;
 std::vector<RuntimeListener> SharedRPC::listeners_;
+std::unordered_map<std::string, std::string> SharedRPC::readinessKeys_;
 
 void SharedRPC::install(jsi::Runtime &rt) {
   auto rpc = std::make_shared<SharedRPC>();
@@ -86,12 +88,21 @@ bool SharedRPC::invalidate(const std::string &runtimeId) {
                        return l.runtimeId == runtimeId;
                      }),
       listeners_.end());
+
+  // Restart freshness: drop this runtime's latched readiness key from
+  // SharedStore so a respawned reader can never observe a prior-life
+  // "peer ready". Robust to crash-restart because it runs in the native
+  // invalidate path, not a JS teardown hook. SharedStore::eraseKey takes its
+  // own mutex (distinct from mutex_, only ever locked SharedRPC→SharedStore).
+  auto keyIt = readinessKeys_.find(runtimeId);
+  if (keyIt != readinessKeys_.end()) {
+    SharedStore::eraseKey(keyIt->second);
+  }
   return found;
 }
 
 void SharedRPC::reset() {
   std::lock_guard<std::mutex> lock(mutex_);
-  slots_.clear();
   // Intentionally leak jsi::Function callbacks to avoid destroying them on the
   // wrong thread (same rationale as the leak in install() for reload scenarios).
   // Also flip alive=false so any executor lambda still in flight short-circuits
@@ -107,7 +118,8 @@ void SharedRPC::reset() {
   listeners_.clear();
 }
 
-void SharedRPC::notifyOtherRuntime(jsi::Runtime &callerRt, const std::string &callId) {
+void SharedRPC::notifyOtherRuntime(jsi::Runtime &callerRt,
+                                   const std::string &callId, RPCValue value) {
   // Collect executors and callbacks under lock, then invoke outside lock
   // to avoid deadlock (executor may schedule work that also acquires mutex_).
   //
@@ -140,12 +152,22 @@ void SharedRPC::notifyOtherRuntime(jsi::Runtime &callerRt, const std::string &ca
     RPC_LOG("  toNotify count: %zu", toNotify.size());
   }
 
-  for (auto &snap : toNotify) {
+  for (size_t i = 0; i < toNotify.size(); ++i) {
+    auto &snap = toNotify[i];
     auto id = callId;
     RPC_LOG("  invoking executor for callId=%s", id.c_str());
     auto cb = snap.callback;
     auto alive = snap.alive;
-    snap.executor([cb, alive, id](jsi::Runtime &rt) {
+    // The payload rides the dispatched lambda's capture. In practice there is
+    // exactly one non-caller listener, so the last (only) iteration moves the
+    // value; any earlier listener takes a copy. A captured RPCValue is a pure
+    // C++ value type — its destructor is thread-agnostic, so dropping this
+    // lambda during teardown is safe (unlike the per-runtime jsi::Function,
+    // which is why `cb` is leaked on invalidate/reset). The jsi::String/value
+    // is materialized via toJSI ONLY inside cb->call, i.e. on the target
+    // runtime's JS thread where it is legal.
+    RPCValue v = (i + 1 == toNotify.size()) ? std::move(value) : value;
+    snap.executor([cb, alive, id, v = std::move(v)](jsi::Runtime &rt) {
       // Listener was invalidated between snapshot and dispatch — bail
       // before calling into a runtime that may already be torn down.
       if (!alive || !alive->load()) {
@@ -155,7 +177,7 @@ void SharedRPC::notifyOtherRuntime(jsi::Runtime &callerRt, const std::string &ca
       }
       RPC_LOG("  executor work running for callId=%s", id.c_str());
       try {
-        cb->call(rt, jsi::String::createFromUtf8(rt, id));
+        cb->call(rt, jsi::String::createFromUtf8(rt, id), toJSI(rt, v));
         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());
@@ -206,83 +228,61 @@ jsi::Value SharedRPC::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
                 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);
+          RPCValue value = extractValue(rt, args[1]);
+          // Value-inline: no slot map. The payload is handed straight to
+          // notifyOtherRuntime, which moves it into the dispatched lambda's
+          // capture and delivers it as the callback's 2nd argument on the
+          // target runtime. No lock here — notify takes the lock internally.
+          notifyOtherRuntime(rt, callId, std::move(value));
           return jsi::Value::undefined();
         });
   }
 
-  // read(callId: string): bool | number | string | undefined
-  // Deletes the entry after reading (read-and-delete semantics).
-  if (prop == "read") {
+  // onWrite(callback: (callId: string, value: string|number|boolean) => 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].isString()) {
-            throw jsi::JSError(
-                rt, "SharedRPC.read expects (callId: string)");
+          if (count < 1 || !args[0].isObject() ||
+              !args[0].asObject(rt).isFunction(rt)) {
+            throw jsi::JSError(rt, "SharedRPC.onWrite expects a function");
           }
-          auto callId = args[0].getString(rt).utf8(rt);
+          auto fn = std::make_shared<jsi::Function>(
+              args[0].asObject(rt).asFunction(rt));
           {
             std::lock_guard<std::mutex> lock(mutex_);
-            auto it = slots_.find(callId);
-            if (it == slots_.end()) {
-              return jsi::Value::undefined();
+            for (auto &listener : listeners_) {
+              if (listener.runtime == &rt) {
+                listener.callback = std::move(fn);
+                break;
+              }
             }
-            auto value = std::move(it->second);
-            slots_.erase(it);
-            return toJSI(rt, value);
           }
+          return jsi::Value::undefined();
         });
   }
 
-  // has(callId: string): boolean
-  if (prop == "has") {
+  // registerReadinessKey(key: string): void
+  // The calling runtime declares which SharedStore key holds its readiness
+  // payload, so invalidate() can clear exactly that key on teardown (restart
+  // freshness). Identified by the calling runtime pointer → its listener's
+  // runtimeId, mirroring how onWrite finds the listener.
+  if (prop == "registerReadinessKey") {
     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)");
+                rt, "SharedRPC.registerReadinessKey expects (key: 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));
+          auto key = args[0].getString(rt).utf8(rt);
           {
             std::lock_guard<std::mutex> lock(mutex_);
             for (auto &listener : listeners_) {
               if (listener.runtime == &rt) {
-                listener.callback = std::move(fn);
+                readinessKeys_[listener.runtimeId] = std::move(key);
                 break;
               }
             }
@@ -297,9 +297,7 @@ jsi::Value SharedRPC::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
 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"));
+  props.push_back(jsi::PropNameID::forUtf8(rt, "registerReadinessKey"));
   return props;
 }

package/cpp/SharedRPC.h

@@ -56,9 +56,17 @@ public:
 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);
+  // Value-inline messaging: the payload rides the dispatched lambda's capture
+  // (delivered as the 2nd callback arg on the target runtime) instead of being
+  // parked in a shared slot map and read back. No `slots_` involved.
+  void notifyOtherRuntime(jsi::Runtime &callerRt, const std::string &callId,
+                          RPCValue value);
 
   static std::mutex mutex_;
-  static std::unordered_map<std::string, RPCValue> slots_;
   static std::vector<RuntimeListener> listeners_;
+  // runtimeId ("main"/"background") → the SharedStore readiness key that
+  // runtime owns. Registered by the JS via `registerReadinessKey`; consumed by
+  // invalidate() to clear that key from SharedStore on teardown so a respawned
+  // reader never sees a prior-life "peer ready" value (restart freshness).
+  static std::unordered_map<std::string, std::string> readinessKeys_;
 };

package/cpp/SharedStore.cpp

@@ -15,6 +15,11 @@ void SharedStore::reset() {
   data_.clear();
 }
 
+void SharedStore::eraseKey(const std::string &key) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  data_.erase(key);
+}
+
 StoreValue SharedStore::extractValue(jsi::Runtime &rt,
                                      const jsi::Value &val) {
   if (val.isBool()) {

package/cpp/SharedStore.h

@@ -19,6 +19,12 @@ public:
   static void install(jsi::Runtime &rt);
   static void reset();
 
+  /// Native-side erase of a single key. Used by SharedRPC::invalidate to drop
+  /// the readiness key owned by a runtime being torn down, so a respawned
+  /// reader can never observe a prior-life "peer ready" (restart freshness).
+  /// Safe to call from any thread; takes the SharedStore mutex internally.
+  static void eraseKey(const std::string &key);
+
 private:
   static StoreValue extractValue(jsi::Runtime &rt, const jsi::Value &val);
   static jsi::Value toJSI(jsi::Runtime &rt, const StoreValue &val);

package/lib/typescript/src/SharedRPC.d.ts

@@ -1,9 +1,7 @@
 export interface ISharedRPC {
     write(callId: string, value: string | number | boolean): void;
-    read(callId: string): string | number | boolean | undefined;
-    has(callId: string): boolean;
-    readonly pendingCount: number;
-    onWrite(callback: (callId: string) => void): void;
+    onWrite(callback: (callId: string, value: string | number | boolean) => void): void;
+    registerReadinessKey(key: string): void;
 }
 declare global {
     var sharedRPC: ISharedRPC | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-background-thread",
-  "version": "3.0.40",
+  "version": "3.0.42",
   "description": "react-native-background-thread",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/SharedRPC.ts

@@ -1,9 +1,15 @@
 export interface ISharedRPC {
   write(callId: string, value: string | number | boolean): void;
-  read(callId: string): string | number | boolean | undefined;
-  has(callId: string): boolean;
-  readonly pendingCount: number;
-  onWrite(callback: (callId: string) => void): void;
+  // Value-inline messaging: the notify callback delivers BOTH the callId and
+  // the payload value, so there is no read-back. `read`/`has`/`pendingCount`
+  // (the old slot-map introspection) are gone.
+  onWrite(
+    callback: (callId: string, value: string | number | boolean) => void,
+  ): void;
+  // The calling runtime declares which SharedStore key holds its readiness
+  // payload, so the native invalidate path clears exactly that key on teardown
+  // (restart freshness — prevents a respawned reader seeing prior-life state).
+  registerReadinessKey(key: string): void;
 }
 
 declare global {