@onekeyfe/react-native-background-thread 1.1.7

package/BackgroundThread.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "BackgroundThread"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-background-thread.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.public_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 @onekeyhq
+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,37 @@
+# react-native-background-thread
+
+react-native-background-thread
+
+## Installation
+
+
+```sh
+npm install react-native-background-thread
+```
+
+
+## Usage
+
+
+```js
+import { multiply } from 'react-native-background-thread';
+
+// ...
+
+const result = multiply(3, 7);
+```
+
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,77 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['BackgroundThread_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["BackgroundThread_" + name]).toInteger()
+}
+
+android {
+  namespace "com.backgroundthread"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+BackgroundThread_kotlinVersion=2.0.21
+BackgroundThread_minSdkVersion=24
+BackgroundThread_targetSdkVersion=34
+BackgroundThread_compileSdkVersion=35
+BackgroundThread_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,23 @@
+package com.backgroundthread
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = BackgroundThreadModule.NAME)
+class BackgroundThreadModule(reactContext: ReactApplicationContext) :
+  NativeBackgroundThreadSpec(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  override fun multiply(a: Double, b: Double): Double {
+    return a * b
+  }
+
+  companion object {
+    const val NAME = "BackgroundThread"
+  }
+}

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

@@ -0,0 +1,33 @@
+package com.backgroundthread
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class BackgroundThreadPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == BackgroundThreadModule.NAME) {
+      BackgroundThreadModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[BackgroundThreadModule.NAME] = ReactModuleInfo(
+        BackgroundThreadModule.NAME,
+        BackgroundThreadModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/BackgroundRunnerReactNativeDelegate.h

@@ -0,0 +1,53 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#if __has_include(<React-RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>)
+#import <React-RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>
+#elif __has_include(<React_RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>)
+#import <React_RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>
+#else
+#import "RCTDefaultReactNativeFactoryDelegate.h"
+#endif
+
+#import <React/RCTComponent.h>
+
+#include <string>
+#include <vector>
+
+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;
+
+@property (nonatomic, readwrite) std::string jsBundleSource;
+
+@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

package/ios/BackgroundRunnerReactNativeDelegate.mm

@@ -0,0 +1,342 @@
+#import "BackgroundRunnerReactNativeDelegate.h"
+
+#include <jsi/JSIDynamic.h>
+#include <jsi/decorator.h>
+#include <react/utils/jsi-utils.h>
+#include <map>
+#include <memory>
+#include <mutex>
+
+#import <React/RCTBridge.h>
+#import <React/RCTBundleURLProvider.h>
+
+#if __has_include(<react/utils/FollyConvert.h>)
+  // static libs / header maps (no use_frameworks!)
+  #import <react/utils/FollyConvert.h>
+#elif __has_include("FollyConvert.h")
+  /// `use_frameworks! :linkage => :static` users will need to import FollyConvert this way
+#import "FollyConvert.h"
+#elif __has_include("RCTFollyConvert.h")
+  #import "RCTFollyConvert.h"
+#else
+  #error "FollyConvert.h not found. Ensure React-utils & RCT-Folly pods are installed."
+#endif
+
+#if __has_include(<React-RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>)
+#import <React-RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>
+#elif __has_include(<React_RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>)
+#import React_RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h
+#endif
+
+#import <ReactAppDependencyProvider/RCTAppDependencyProvider.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#import <objc/runtime.h>
+
+#include <fmt/format.h>
+
+namespace jsi = facebook::jsi;
+namespace TurboModuleConvertUtils = facebook::react::TurboModuleConvertUtils;
+using namespace facebook::react;
+
+static void stubJsiFunction(jsi::Runtime &runtime, jsi::Object &object, const char *name)
+{
+  object.setProperty(
+      runtime,
+      name,
+      jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forUtf8(runtime, name), 1, [](auto &, const auto &, const auto *, size_t) {
+            return jsi::Value::undefined();
+          }));
+}
+
+static std::string safeGetStringProperty(jsi::Runtime &rt, const jsi::Object &obj, const char *key)
+{
+  if (!obj.hasProperty(rt, key)) {
+    return "";
+  }
+  jsi::Value value = obj.getProperty(rt, key);
+  return value.isString() ? value.getString(rt).utf8(rt) : "";
+}
+
+@interface BackgroundReactNativeDelegate () {
+  RCTInstance *_rctInstance;
+  std::shared_ptr<jsi::Function> _onMessageSandbox;
+  std::string _origin;
+  std::string _jsBundleSource;
+}
+
+- (void)cleanupResources;
+
+- (jsi::Function)createPostMessageFunction:(jsi::Runtime &)runtime;
+- (jsi::Function)createSetOnMessageFunction:(jsi::Runtime &)runtime;
+- (void)setupErrorHandler:(jsi::Runtime &)runtime;
+
+@end
+
+@implementation BackgroundReactNativeDelegate
+
+#pragma mark - Instance Methods
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _hasOnMessageHandler = NO;
+    _hasOnErrorHandler = NO;
+    self.dependencyProvider = [[RCTAppDependencyProvider alloc] init];
+  }
+  return self;
+}
+
+- (void)cleanupResources
+{
+  _onMessageSandbox.reset();
+  _rctInstance = nil;
+}
+
+#pragma mark - C++ Property Getters
+
+- (std::string)origin
+{
+  return _origin;
+}
+
+- (std::string)jsBundleSource
+{
+  return _jsBundleSource;
+}
+
+- (void)setJsBundleSource:(std::string)jsBundleSource
+{
+  _jsBundleSource = jsBundleSource;
+}
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
+{
+  return [self bundleURL];
+}
+
+- (NSURL *)bundleURL
+{
+  if (!_jsBundleSource.empty()) {
+    NSString *jsBundleSourceNS = [NSString stringWithUTF8String:_jsBundleSource.c_str()];
+    NSURL *url = [NSURL URLWithString:jsBundleSourceNS];
+    if (url && url.scheme) {
+      return url;
+    }
+
+    if ([jsBundleSourceNS hasSuffix:@".jsbundle"]) {
+      return [[NSBundle mainBundle] URLForResource:jsBundleSourceNS withExtension:nil];
+    }
+  }
+
+  return [[NSBundle mainBundle] URLForResource: @"background" withExtension: @"bundle"];
+}
+
+- (void)postMessage:(const std::string &)message
+{
+  if (!_onMessageSandbox || !_rctInstance) {
+    return;
+  }
+
+  [_rctInstance callFunctionOnBufferedRuntimeExecutor:[=](jsi::Runtime &runtime) {
+    try {
+      // Validate runtime before any JSI operations
+      runtime.global(); // Test if runtime is accessible
+
+      // Double-check the JSI function is still valid
+      if (!_onMessageSandbox) {
+        return;
+      }
+
+      jsi::Value parsedValue = runtime.global()
+                                   .getPropertyAsObject(runtime, "JSON")
+                                   .getPropertyAsFunction(runtime, "parse")
+                                   .call(runtime, jsi::String::createFromUtf8(runtime, message));
+
+      _onMessageSandbox->call(runtime, {std::move(parsedValue)});
+    } catch (const jsi::JSError &e) {
+    //   if (self.eventEmitter && self.hasOnErrorHandler) {
+    //     SandboxReactNativeViewEventEmitter::OnError errorEvent = {
+    //         .isFatal = false, .name = "JSError", .message = e.getMessage(), .stack = e.getStack()};
+    //     self.eventEmitter->onError(errorEvent);
+    //   }
+    } catch (const std::exception &e) {
+    //   if (self.eventEmitter && self.hasOnErrorHandler) {
+    //     SandboxReactNativeViewEventEmitter::OnError errorEvent = {
+    //         .isFatal = false, .name = "RuntimeError", .message = e.what(), .stack = ""};
+    //     self.eventEmitter->onError(errorEvent);
+    //   }
+    } catch (...) {
+      NSLog(@"[BackgroundReactNativeDelegate] Runtime invalid during postMessage for sandbox %s", _origin.c_str());
+    }
+  }];
+}
+
+- (bool)routeMessage:(const std::string &)message toSandbox:(const std::string &)targetId
+{
+//   auto &registry = SandboxRegistry::getInstance();
+//   auto target = registry.find(targetId);
+//   if (!target) {
+//     return false;
+//   }
+
+//   // Check if the current sandbox is permitted to send messages to the target
+//   if (!registry.isPermittedFrom(_origin, targetId)) {
+//     // if (self.eventEmitter && self.hasOnErrorHandler) {
+//     //   std::string errorMessage =
+//     //       fmt::format("Access denied: Sandbox '{}' is not permitted to send messages to '{}'", _origin, targetId);
+//     //   SandboxReactNativeViewEventEmitter::OnError errorEvent = {
+//     //       .isFatal = false, .name = "AccessDeniedError", .message = errorMessage, .stack = ""};
+//     //   self.eventEmitter->onError(errorEvent);
+//     // }
+//     return false;
+//   }
+
+//  target->postMessage(message);
+  return true;
+}
+
+- (void)hostDidStart:(RCTHost *)host
+{
+  if (!host) {
+    return;
+  }
+
+  // Safely clear any existing JSI function and instance before new runtime setup
+  // This prevents crash on reload when old function is tied to invalid runtime
+  _onMessageSandbox.reset();
+  _onMessageSandbox = nullptr;
+
+  // Clear old instance reference before setting new one
+  _rctInstance = nil;
+
+  Ivar ivar = class_getInstanceVariable([host class], "_instance");
+  _rctInstance = object_getIvar(host, ivar);
+
+  if (!_rctInstance) {
+    return;
+  }
+
+  [_rctInstance callFunctionOnBufferedRuntimeExecutor:[=](jsi::Runtime &runtime) {
+    facebook::react::defineReadOnlyGlobal(runtime, "postHostMessage", [self createPostMessageFunction:runtime]);
+    facebook::react::defineReadOnlyGlobal(runtime, "onHostMessage", [self createSetOnMessageFunction:runtime]);
+    [self setupErrorHandler:runtime];
+  }];
+}
+
+#pragma mark - RCTTurboModuleManagerDelegate
+
+- (id<RCTModuleProvider>)getModuleProvider:(const char *)name
+{
+  return [super getModuleProvider:name];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+{
+    return [super getTurboModule:name jsInvoker:jsInvoker];
+}
+
+- (jsi::Function)createPostMessageFunction:(jsi::Runtime &)runtime
+{
+  return jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forAscii(runtime, "postMessage"),
+      2, // Updated to accept up to 2 arguments
+      [=](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
+        // Validate runtime before any JSI operations
+        try {
+          rt.global(); // Test if runtime is accessible
+        } catch (...) {
+          return jsi::Value::undefined();
+        }
+
+        if (count < 1 || count > 2) {
+          throw jsi::JSError(rt, "Expected 1 or 2 arguments: postMessage(message, targetOrigin?)");
+        }
+
+        const jsi::Value &messageArg = args[0];
+        if (!messageArg.isString()) {
+          throw jsi::JSError(rt, "Expected an string as the first argument");
+        }
+//        jsi::Object jsonObject = rt.global().getPropertyAsObject(rt, "JSON");
+//        jsi::Function jsonStringify = jsonObject.getPropertyAsFunction(rt, "stringify");
+//        jsi::Value jsonResult = jsonStringify.call(rt, messageArg);
+        std::string messageJson = messageArg.getString(rt).utf8(rt);
+        NSString *messageNS = [NSString stringWithUTF8String:messageJson.c_str()];
+            dispatch_async(dispatch_get_main_queue(), ^{
+              if (self.onMessageCallback) {
+                self.onMessageCallback(messageNS);
+              }
+            });
+        return jsi::Value::undefined();
+      });
+}
+
+- (jsi::Function)createSetOnMessageFunction:(jsi::Runtime &)runtime
+{
+  return jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forAscii(runtime, "setOnMessage"),
+      1,
+      [=](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
+        if (count != 1) {
+          throw jsi::JSError(rt, "Expected exactly one argument");
+        }
+
+        const jsi::Value &arg = args[0];
+        if (!arg.isObject() || !arg.asObject(rt).isFunction(rt)) {
+          throw jsi::JSError(rt, "Expected a function as the first argument");
+        }
+
+        jsi::Function fn = arg.asObject(rt).asFunction(rt);
+
+        _onMessageSandbox.reset();
+        _onMessageSandbox = std::make_shared<jsi::Function>(std::move(fn));
+
+        return jsi::Value::undefined();
+      });
+}
+
+- (void)setupErrorHandler:(jsi::Runtime &)runtime
+{
+  // Get ErrorUtils
+  jsi::Object global = runtime.global();
+  jsi::Value errorUtilsVal = global.getProperty(runtime, "ErrorUtils");
+  if (!errorUtilsVal.isObject()) {
+    throw std::runtime_error("ErrorUtils is not available on global object");
+  }
+
+  jsi::Object errorUtils = errorUtilsVal.asObject(runtime);
+
+  std::shared_ptr<jsi::Value> originalHandler = std::make_shared<jsi::Value>(
+      errorUtils.getProperty(runtime, "getGlobalHandler").asObject(runtime).asFunction(runtime).call(runtime));
+
+  auto handlerFunc = jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forAscii(runtime, "customGlobalErrorHandler"),
+      2,
+      [=, originalHandler = std::move(originalHandler)](
+          jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+        if (count < 2) {
+          return jsi::Value::undefined();
+        }
+
+        if (originalHandler->isObject() && originalHandler->asObject(rt).isFunction(rt)) {
+          jsi::Function original = originalHandler->asObject(rt).asFunction(rt);
+          original.call(rt, args, count);
+        }
+
+        return jsi::Value::undefined();
+      });
+
+  // Set the new global error handler
+  jsi::Function setHandler = errorUtils.getProperty(runtime, "setGlobalHandler").asObject(runtime).asFunction(runtime);
+  setHandler.call(runtime, {std::move(handlerFunc)});
+
+  // Disable further setGlobalHandler from sandbox
+  stubJsiFunction(runtime, errorUtils, "setGlobalHandler");
+}
+
+@end

package/ios/BackgroundThread.h

@@ -0,0 +1,8 @@
+#import <BackgroundThreadSpec/BackgroundThreadSpec.h>
+
+@interface BackgroundThread : NativeBackgroundThreadSpecBase <NativeBackgroundThreadSpec>
+
+- (void)startBackgroundRunner;
+- (void)startBackgroundRunnerWithEntryURL:(NSString *)entryURL;
+
+@end

package/ios/BackgroundThread.mm

@@ -0,0 +1,39 @@
+#import "BackgroundThread.h"
+#import "BackgroundThreadManager.h"
+
+
+@implementation BackgroundThread
+
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeBackgroundThreadSpecJSI>(params);
+}
+
+- (void)startBackgroundRunner {
+    [[BackgroundThreadManager sharedInstance] startBackgroundRunner];
+}
+
+- (void)startBackgroundRunnerWithEntryURL:(NSString *)entryURL {
+    BackgroundThreadManager *manager = [BackgroundThreadManager sharedInstance];
+    
+    // Set up message callback to bridge it back through this instance
+    __weak __typeof__(self) weakSelf = self;
+    [manager setOnMessageCallback:^(NSString *message) {
+        [weakSelf emitOnBackgroundMessage:message];
+    }];
+    
+    [manager startBackgroundRunnerWithEntryURL:entryURL];
+}
+
+- (void)postBackgroundMessage:(nonnull NSString *)message {
+    [[BackgroundThreadManager sharedInstance] postBackgroundMessage:message];
+}
+
++ (NSString *)moduleName
+{
+  return @"BackgroundThread";
+}
+
+@end

package/ios/BackgroundThreadManager.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class BackgroundReactNativeDelegate;
+@class RCTReactNativeFactory;
+
+@interface BackgroundThreadManager : NSObject
+
+/// Shared instance for singleton pattern
++ (instancetype)sharedInstance;
+
+/// Start background runner with default entry URL
+- (void)startBackgroundRunner;
+
+/// Start background runner with custom entry URL
+/// @param entryURL The custom entry URL for the background runner
+- (void)startBackgroundRunnerWithEntryURL:(NSString *)entryURL;
+
+/// Post message to background runner
+/// @param message The message to post
+- (void)postBackgroundMessage:(NSString *)message;
+
+/// Set callback for handling background messages
+/// @param callback The callback block to handle messages
+- (void)setOnMessageCallback:(void (^)(NSString *message))callback;
+
+/// Check if background runner is started
+@property (nonatomic, readonly) BOOL isStarted;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/BackgroundThreadManager.mm

@@ -0,0 +1,95 @@
+#import "BackgroundThreadManager.h"
+#import <React/RCTBridge.h>
+#import <React/RCTBundleURLProvider.h>
+#if __has_include(<ReactAppDependencyProvider/RCTAppDependencyProvider.h>)
+#import <ReactAppDependencyProvider/RCTAppDependencyProvider.h>
+#endif
+#if __has_include(<ReactAppDependencyProvider/RCTReactNativeFactory.h>)
+#import <ReactAppDependencyProvider/RCTReactNativeFactory.h>
+#endif
+#if __has_include(<ReactAppDependencyProvider/RCTAppDependencyProvider.h>)
+#import <ReactAppDependencyProvider/RCTAppDependencyProvider.h>
+#elif __has_include("RCTAppDependencyProvider.h")
+#import "RCTAppDependencyProvider.h"
+#endif
+#import "BackgroundRunnerReactNativeDelegate.h"
+
+@interface BackgroundThreadManager ()
+@property (nonatomic, strong) BackgroundReactNativeDelegate *reactNativeFactoryDelegate;
+@property (nonatomic, strong) RCTReactNativeFactory *reactNativeFactory;
+@property (nonatomic, assign) BOOL hasListeners;
+@property (nonatomic, assign, readwrite) BOOL isStarted;
+@property (nonatomic, copy) void (^onMessageCallback)(NSString *message);
+@end
+
+@implementation BackgroundThreadManager
+
+static BackgroundThreadManager *_sharedInstance = nil;
+static dispatch_once_t onceToken;
+static NSString *const MODULE_NAME = @"background";
+static NSString *const MODULE_DEBUG_URL = @"http://localhost:8082/apps/mobile/background.bundle?platform=ios&dev=true&lazy=false&minify=false&inlineSourceMap=false&modulesOnly=false&runModule=true&excludeSource=true&sourcePaths=url-server&app=so.onekey.wallet&transform.routerRoot=app&transform.engine=hermes&transform.bytecode=1&unstable_transformProfile=hermes-stable";
+
+#pragma mark - Singleton
+
++ (instancetype)sharedInstance {
+    dispatch_once(&onceToken, ^{
+        _sharedInstance = [[self alloc] init];
+    });
+    return _sharedInstance;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _isStarted = NO;
+        _hasListeners = NO;
+    }
+    return self;
+}
+
+#pragma mark - Public Methods
+
+- (void)startBackgroundRunner {
+    [self startBackgroundRunnerWithEntryURL:MODULE_DEBUG_URL];
+}
+
+- (void)startBackgroundRunnerWithEntryURL:(NSString *)entryURL {
+    if (self.isStarted) {
+        return;
+    }
+    self.isStarted = YES;
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        NSDictionary *initialProperties = @{};
+        NSDictionary *launchOptions = @{};
+        self.reactNativeFactoryDelegate = [[BackgroundReactNativeDelegate alloc] init];
+        self.reactNativeFactory = [[RCTReactNativeFactory alloc] initWithDelegate:self.reactNativeFactoryDelegate];
+        
+        #if DEBUG
+            [self.reactNativeFactoryDelegate setJsBundleSource:std::string([entryURL UTF8String])];
+        #endif
+        
+        [self.reactNativeFactory.rootViewFactory viewWithModuleName:MODULE_NAME
+                                                     initialProperties:initialProperties
+                                                         launchOptions:launchOptions];
+        
+        __weak __typeof__(self) weakSelf = self;
+        [self.reactNativeFactoryDelegate setOnMessageCallback:^(NSString *message) {
+            if (weakSelf.onMessageCallback) {
+                weakSelf.onMessageCallback(message);
+            }
+        }];
+    });
+}
+
+- (void)postBackgroundMessage:(NSString *)message {
+    if (self.reactNativeFactoryDelegate) {
+        [self.reactNativeFactoryDelegate postMessage:std::string([message UTF8String])];
+    }
+}
+
+- (void)setOnMessageCallback:(void (^)(NSString *message))callback {
+    self.onMessageCallback = callback;
+}
+
+@end

package/lib/module/NativeBackgroundThread.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('BackgroundThread');
+//# sourceMappingURL=NativeBackgroundThread.js.map

package/lib/module/NativeBackgroundThread.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeBackgroundThread.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAAQ,cAAc;AASlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,kBAAkB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import NativeBackgroundThread from "./NativeBackgroundThread.js";
+export const BackgroundThread = NativeBackgroundThread;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeBackgroundThread","BackgroundThread"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,sBAAsB,MAAM,6BAA0B;AAE7D,OAAO,MAAMC,gBAAgB,GAAGD,sBAAsB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,9 @@
+import type { CodegenTypes, TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    readonly onBackgroundMessage: CodegenTypes.EventEmitter<string>;
+    postBackgroundMessage(message: string): void;
+    startBackgroundRunnerWithEntryURL(entryURL: string): void;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeBackgroundThread.d.ts.map

package/lib/typescript/src/NativeBackgroundThread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeBackgroundThread.d.ts","sourceRoot":"","sources":["../../../src/NativeBackgroundThread.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC9D,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,QAAQ,CAAC,mBAAmB,EAAE,YAAY,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAChE,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,iCAAiC,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3D;;AAED,wBAA0E"}

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

@@ -0,0 +1,2 @@
+export declare const BackgroundThread: import("./NativeBackgroundThread").Spec;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,yCAAyB,CAAC"}

package/package.json

@@ -0,0 +1,169 @@
+{
+  "name": "@onekeyfe/react-native-background-thread",
+  "version": "1.1.7",
+  "description": "react-native-background-thread",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-background-thread-example",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest",
+    "release": "yarn prepare && npm whoami && npm publish --access public"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/app-modules/react-native-background-thread.git"
+  },
+  "author": "@onekeyhq <huanming@onekey.so> (https://github.com/OneKeyHQ/app-modules)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/OneKeyHQ/app-modules/react-native-background-thread/issues"
+  },
+  "homepage": "https://github.com/OneKeyHQ/app-modules/react-native-background-thread#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@react-native/babel-preset": "0.83.0",
+    "@react-native/eslint-config": "0.83.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.0",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "lefthook": "^2.0.3",
+    "prettier": "^2.8.8",
+    "react": "19.2.0",
+    "react-native": "0.83.0",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "BackgroundThreadSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.backgroundthread"
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [
+      "eslint",
+      "jest",
+      "lefthook",
+      "release-it"
+    ],
+    "version": "0.56.0"
+  }
+}

package/src/NativeBackgroundThread.ts

@@ -0,0 +1,10 @@
+import { TurboModuleRegistry } from 'react-native';
+
+import type { CodegenTypes, TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+  readonly onBackgroundMessage: CodegenTypes.EventEmitter<string>;
+  postBackgroundMessage(message: string): void;
+  startBackgroundRunnerWithEntryURL(entryURL: string): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('BackgroundThread');

package/src/index.tsx

@@ -0,0 +1,3 @@
+import NativeBackgroundThread from './NativeBackgroundThread';
+
+export const BackgroundThread = NativeBackgroundThread;