@onekeyfe/react-native-background-thread 3.0.60 → 3.0.62

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

@@ -70,6 +70,166 @@ static std::mutex gWorkMutex;
 static std::unordered_map<int64_t, std::function<void(jsi::Runtime &)>> gPendingWork;
 static int64_t gNextWorkId = 0;
 
+using JavaObjectRef = std::shared_ptr<_jobject>;
+
+static constexpr size_t kRuntimeDrainBatchSize = 64;
+static constexpr size_t kRuntimeQueueWarnThreshold = 128;
+static constexpr size_t kRuntimeQueueWarnInterval = 128;
+
+struct RuntimeWorkQueue {
+    std::deque<std::function<void(jsi::Runtime &)>> items;
+    bool drainScheduled = false;
+};
+
+static RuntimeWorkQueue gMainRuntimeWorkQueue;
+static RuntimeWorkQueue gBgRuntimeWorkQueue;
+
+static RuntimeWorkQueue &getRuntimeWorkQueue(bool isMain) {
+    return isMain ? gMainRuntimeWorkQueue : gBgRuntimeWorkQueue;
+}
+
+static bool callScheduleOnJSThread(const JavaObjectRef &ref, bool isMain, int64_t workId) {
+    JNIEnv *env = getJNIEnv();
+    if (!env || !ref) {
+        LOGE("executor: env=%p, ref=%p — aborting", env, ref.get());
+        return false;
+    }
+
+    jclass cls = env->GetObjectClass(ref.get());
+    if (!cls) {
+        LOGE("executor: GetObjectClass failed");
+        if (env->ExceptionCheck()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+        }
+        return false;
+    }
+
+    jmethodID mid = env->GetMethodID(cls, "scheduleOnJSThread", "(ZJ)Z");
+    if (!mid) {
+        LOGE("executor: scheduleOnJSThread method not found!");
+        if (env->ExceptionCheck()) {
+            env->ExceptionDescribe();
+            env->ExceptionClear();
+        }
+        env->DeleteLocalRef(cls);
+        return false;
+    }
+
+    LOGI("executor: calling scheduleOnJSThread(isMain=%d, workId=%ld)", isMain, (long)workId);
+    jboolean scheduled = env->CallBooleanMethod(
+        ref.get(),
+        mid,
+        static_cast<jboolean>(isMain),
+        static_cast<jlong>(workId));
+    if (env->ExceptionCheck()) {
+        LOGE("executor: JNI exception after scheduleOnJSThread");
+        env->ExceptionDescribe();
+        env->ExceptionClear();
+        env->DeleteLocalRef(cls);
+        return false;
+    }
+    env->DeleteLocalRef(cls);
+    return scheduled == JNI_TRUE;
+}
+
+static void scheduleRuntimeDrain(const JavaObjectRef &ref, bool isMain);
+
+static void drainRuntimeWorkQueue(jsi::Runtime &rt, JavaObjectRef ref, bool isMain) {
+    size_t drained = 0;
+
+    while (drained < kRuntimeDrainBatchSize) {
+        std::function<void(jsi::Runtime &)> work;
+        {
+            std::lock_guard<std::mutex> lock(gWorkMutex);
+            auto &queue = getRuntimeWorkQueue(isMain);
+            if (queue.items.empty()) {
+                break;
+            }
+            work = std::move(queue.items.front());
+            queue.items.pop_front();
+        }
+
+        try {
+            work(rt);
+        } catch (const jsi::JSError &e) {
+            LOGE("JSError in runtime drain work: %s", e.getMessage().c_str());
+        } catch (const std::exception &e) {
+            LOGE("Error in runtime drain work: %s", e.what());
+        } catch (...) {
+            LOGE("Unknown error in runtime drain work");
+        }
+        drained += 1;
+    }
+
+    bool shouldReschedule = false;
+    size_t remaining = 0;
+    {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        auto &queue = getRuntimeWorkQueue(isMain);
+        remaining = queue.items.size();
+        if (remaining == 0) {
+            queue.drainScheduled = false;
+        } else {
+            shouldReschedule = true;
+        }
+    }
+
+    if (drained > 1 || remaining > 0) {
+        LOGI("executor: drained runtime queue isMain=%d, drained=%zu, remaining=%zu",
+             isMain, drained, remaining);
+    }
+
+    if (shouldReschedule) {
+        scheduleRuntimeDrain(ref, isMain);
+    }
+}
+
+static void scheduleRuntimeDrain(const JavaObjectRef &ref, bool isMain) {
+    int64_t workId;
+    size_t queued = 0;
+    {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        workId = gNextWorkId++;
+        queued = getRuntimeWorkQueue(isMain).items.size();
+        gPendingWork[workId] = [ref, isMain](jsi::Runtime &rt) {
+            drainRuntimeWorkQueue(rt, ref, isMain);
+        };
+    }
+
+    bool scheduled = callScheduleOnJSThread(ref, isMain, workId);
+    if (!scheduled) {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        gPendingWork.erase(workId);
+        getRuntimeWorkQueue(isMain).drainScheduled = false;
+        LOGE("executor: failed to schedule runtime drain isMain=%d, workId=%ld, queued=%zu",
+             isMain, (long)workId, queued);
+    }
+}
+
+static void enqueueRuntimeWork(JavaObjectRef ref, bool isMain, std::function<void(jsi::Runtime &)> work) {
+    bool shouldSchedule = false;
+    size_t queued = 0;
+    {
+        std::lock_guard<std::mutex> lock(gWorkMutex);
+        auto &queue = getRuntimeWorkQueue(isMain);
+        queue.items.push_back(std::move(work));
+        queued = queue.items.size();
+        if (!queue.drainScheduled) {
+            queue.drainScheduled = true;
+            shouldSchedule = true;
+        }
+    }
+
+    if (queued >= kRuntimeQueueWarnThreshold && queued % kRuntimeQueueWarnInterval == 0) {
+        LOGE("executor: runtime queue backlog isMain=%d, queued=%zu", isMain, queued);
+    }
+
+    if (shouldSchedule) {
+        scheduleRuntimeDrain(ref, isMain);
+    }
+}
+
 // Called from Kotlin after runOnJSQueueThread dispatches to the correct thread.
 extern "C" JNIEXPORT void JNICALL
 Java_com_backgroundthread_BackgroundThreadManager_nativeExecuteWork(
@@ -470,37 +630,7 @@ Java_com_backgroundthread_BackgroundThreadManager_nativeInstallSharedBridge(
     bool capturedIsMain = static_cast<bool>(isMain);
 
     RPCRuntimeExecutor executor = [ref, capturedIsMain](std::function<void(jsi::Runtime &)> work) {
-        JNIEnv *env = getJNIEnv();
-        if (!env || !ref) {
-            LOGE("executor: env=%p, ref=%p — aborting", env, ref.get());
-            return;
-        }
-
-        int64_t workId;
-        {
-            std::lock_guard<std::mutex> lock(gWorkMutex);
-            workId = gNextWorkId++;
-            gPendingWork[workId] = std::move(work);
-        }
-
-        jclass cls = env->GetObjectClass(ref.get());
-        jmethodID mid = env->GetMethodID(cls, "scheduleOnJSThread", "(ZJ)V");
-        if (mid) {
-            LOGI("executor: calling scheduleOnJSThread(isMain=%d, workId=%ld)", capturedIsMain, (long)workId);
-            env->CallVoidMethod(ref.get(), mid, static_cast<jboolean>(capturedIsMain), static_cast<jlong>(workId));
-            if (env->ExceptionCheck()) {
-                LOGE("executor: JNI exception after scheduleOnJSThread");
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-        } else {
-            LOGE("executor: scheduleOnJSThread method not found!");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-        }
-        env->DeleteLocalRef(cls);
+        enqueueRuntimeWork(ref, capturedIsMain, std::move(work));
     };
 
     std::string runtimeId = isMain ? "main" : "background";
@@ -652,6 +782,13 @@ Java_com_backgroundthread_BackgroundThreadManager_nativeDestroy(
             new std::function<void(jsi::Runtime &)>(std::move(entry.second));
         }
         gPendingWork.clear();
+        for (auto *queue : {&gMainRuntimeWorkQueue, &gBgRuntimeWorkQueue}) {
+            for (auto &work : queue->items) {
+                new std::function<void(jsi::Runtime &)>(std::move(work));
+            }
+            queue->items.clear();
+            queue->drainScheduled = false;
+        }
     }
 
     LOGI("Native resources cleaned up");

package/android/src/main/java/com/backgroundthread/BackgroundThreadManager.kt

@@ -407,26 +407,36 @@ class BackgroundThreadManager private constructor() {
      * Routes to main or background runtime's JS queue thread, then calls nativeExecuteWork.
      */
     @DoNotStrip
-    fun scheduleOnJSThread(isMain: Boolean, workId: Long) {
+    fun scheduleOnJSThread(isMain: Boolean, workId: Long): Boolean {
         val context = if (isMain) mainReactContext else bgReactHost?.currentReactContext
         BTLogger.info("scheduleOnJSThread: isMain=$isMain, workId=$workId, context=${context != null}")
         if (context == null) {
             BTLogger.error("scheduleOnJSThread: context is null! isMain=$isMain, mainCtx=${mainReactContext != null}, bgHost=${bgReactHost != null}, bgCtx=${bgReactHost?.currentReactContext != null}")
+            return false
         }
-        context?.runOnJSQueueThread {
-            // Re-read ptr inside the block — if a reload happened between
-            // scheduling and execution, the old ptr may be stale.
-            val ptr = if (isMain) mainRuntimePtr else bgRuntimePtr
-            BTLogger.info("scheduleOnJSThread runOnJSQueueThread: isMain=$isMain, workId=$workId, ptr=$ptr")
-            if (ptr != 0L) {
-                try {
-                    nativeExecuteWork(ptr, workId)
-                } catch (e: Exception) {
-                    BTLogger.error("Error executing work on JS thread: ${e.message}")
+        return try {
+            val posted = context.runOnJSQueueThread {
+                // Re-read ptr inside the block — if a reload happened between
+                // scheduling and execution, the old ptr may be stale.
+                val ptr = if (isMain) mainRuntimePtr else bgRuntimePtr
+                BTLogger.info("scheduleOnJSThread runOnJSQueueThread: isMain=$isMain, workId=$workId, ptr=$ptr")
+                if (ptr != 0L) {
+                    try {
+                        nativeExecuteWork(ptr, workId)
+                    } catch (e: Exception) {
+                        BTLogger.error("Error executing work on JS thread: ${e.message}")
+                    }
+                } else {
+                    BTLogger.error("scheduleOnJSThread: ptr is 0! isMain=$isMain")
                 }
-            } else {
-                BTLogger.error("scheduleOnJSThread: ptr is 0! isMain=$isMain")
             }
+            if (!posted) {
+                BTLogger.error("scheduleOnJSThread: runOnJSQueueThread rejected workId=$workId isMain=$isMain")
+            }
+            posted
+        } catch (e: Exception) {
+            BTLogger.error("scheduleOnJSThread: failed to post workId=$workId isMain=$isMain error=${e.message}")
+            false
         }
     }
 

package/package.json

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

package/src/SharedRPC.ts

@@ -4,7 +4,7 @@ export interface ISharedRPC {
   // 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,
+    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