feat: Enhance ObjC bridge state management with mutex and token handling

DjDeveloperr · DjDeveloperr · commit 9388c48ddd52 · 2026-02-25T21:29:05.000-05:00
diff --git a/NativeScript/ffi/ClassBuilder.mm b/NativeScript/ffi/ClassBuilder.mm
@@ -9,11 +9,53 @@
 #include "Util.h"
 #include "js_native_api.h"
 #include "node_api_util.h"
+#include <mutex>
 
 namespace nativescript {
 namespace {
 std::unordered_map<std::string, MethodDescriptor> gKnownExposedMethods;
-napi_env gClassBuilderEnv = nullptr;
+std::mutex gClassBuilderEnvMutex;
+std::unordered_map<Class, napi_env> gClassBuilderEnvs;
+
+void registerClassBuilderEnv(Class nativeClass, napi_env env) {
+  if (nativeClass == Nil || env == nullptr) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(gClassBuilderEnvMutex);
+  gClassBuilderEnvs[nativeClass] = env;
+}
+
+void unregisterClassBuilderEnv(Class nativeClass) {
+  if (nativeClass == Nil) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(gClassBuilderEnvMutex);
+  gClassBuilderEnvs.erase(nativeClass);
+}
+
+napi_env resolveClassBuilderEnv(id self) {
+  if (self == nil) {
+    return nullptr;
+  }
+
+  Class currentClass = object_getClass(self);
+  if (currentClass == Nil) {
+    return nullptr;
+  }
+
+  std::lock_guard<std::mutex> lock(gClassBuilderEnvMutex);
+  while (currentClass != Nil) {
+    auto find = gClassBuilderEnvs.find(currentClass);
+    if (find != gClassBuilderEnvs.end()) {
+      return find->second;
+    }
+    currentClass = class_getSuperclass(currentClass);
+  }
+
+  return nullptr;
+}
 
 const char* kInstallSuperAccessorSource = R"(
   (function (prototype, basePrototype) {
@@ -201,11 +243,15 @@ napi_value JS_classConformsToProtocolSafe(napi_env env, napi_callback_info info)
 
 NSUInteger JS_SymbolIteratorCountByEnumerating(id self, SEL _cmd, NSFastEnumerationState* state,
                                                id __unsafe_unretained stackbuf[], NSUInteger len) {
-  if (len == 0 || gClassBuilderEnv == nullptr) {
+  if (len == 0) {
+    return 0;
+  }
+
+  napi_env env = resolveClassBuilderEnv(self);
+  if (env == nullptr) {
     return 0;
   }
 
-  napi_env env = gClassBuilderEnv;
   ObjCBridgeState* bridgeState = ObjCBridgeState::InstanceData(env);
   if (bridgeState == nullptr) {
     return 0;
@@ -343,7 +389,6 @@ NSUInteger JS_SymbolIteratorCountByEnumerating(id self, SEL _cmd, NSFastEnumerat
 
 ClassBuilder::ClassBuilder(napi_env env, napi_value constructor) {
   this->env = env;
-  gClassBuilderEnv = env;
   bridgeState = ObjCBridgeState::InstanceData(env);
 
   metadataOffset = MD_SECTION_OFFSET_NULL;
@@ -399,6 +444,7 @@ NSUInteger JS_SymbolIteratorCountByEnumerating(id self, SEL _cmd, NSFastEnumerat
   class_addProtocol(nativeClass, @protocol(ObjCBridgeClassBuilderProtocol));
 
   objc_registerClassPair(nativeClass);
+  registerClassBuilderEnv(nativeClass, env);
 
   napi_remove_wrap(env, constructor, nullptr);
 
@@ -412,6 +458,8 @@ NSUInteger JS_SymbolIteratorCountByEnumerating(id self, SEL _cmd, NSFastEnumerat
 }
 
 ClassBuilder::~ClassBuilder() {
+  unregisterClassBuilderEnv(nativeClass);
+
   if (nativeClass != nullptr) {
     objc_disposeClassPair(nativeClass);
     napi_delete_reference(env, constructor);
diff --git a/NativeScript/ffi/ObjCBridge.h b/NativeScript/ffi/ObjCBridge.h
@@ -29,7 +29,11 @@ using namespace metagen;
 
 namespace nativescript {
 
+class ObjCBridgeState;
+
 void finalize_objc_object(napi_env /*env*/, void* data, void* hint);
+bool IsBridgeStateLive(const ObjCBridgeState* bridgeState,
+                       uint64_t token) noexcept;
 
 // Determines how retain/release should be called when an Objective-C
 // object is exposed to JavaScript land.
@@ -193,6 +197,7 @@ class ObjCBridgeState {
   }
 
  public:
+  uint64_t lifetimeToken = 0;
   std::unordered_map<id, napi_ref> objectRefs;
 
   napi_ref pointerClass = nullptr;
diff --git a/NativeScript/ffi/ObjCBridge.mm b/NativeScript/ffi/ObjCBridge.mm
@@ -24,8 +24,10 @@
 #include <mach-o/dyld.h>
 #include <mach-o/getsect.h>
 #include <objc/runtime.h>
+#include <atomic>
 #include <cstring>
 #include <initializer_list>
+#include <mutex>
 
 #ifdef EMBED_METADATA_SIZE
 const unsigned char __attribute__((section("__objc_metadata,__objc_metadata")))
@@ -37,6 +39,42 @@ const unsigned char __attribute__((section("__objc_metadata,__objc_metadata")))
 #endif
 
 namespace nativescript {
+namespace {
+std::mutex gLiveBridgeStatesMutex;
+std::unordered_map<const ObjCBridgeState*, uint64_t> gLiveBridgeStates;
+std::atomic<uint64_t> gNextBridgeStateToken{1};
+
+uint64_t RegisterBridgeState(const ObjCBridgeState* bridgeState) {
+  if (bridgeState == nullptr) {
+    return 0;
+  }
+
+  uint64_t token = gNextBridgeStateToken.fetch_add(1, std::memory_order_relaxed);
+  std::lock_guard<std::mutex> lock(gLiveBridgeStatesMutex);
+  gLiveBridgeStates[bridgeState] = token;
+  return token;
+}
+
+void UnregisterBridgeState(const ObjCBridgeState* bridgeState) {
+  if (bridgeState == nullptr) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(gLiveBridgeStatesMutex);
+  gLiveBridgeStates.erase(bridgeState);
+}
+}  // namespace
+
+bool IsBridgeStateLive(const ObjCBridgeState* bridgeState,
+                       uint64_t token) noexcept {
+  if (bridgeState == nullptr || token == 0) {
+    return false;
+  }
+
+  std::lock_guard<std::mutex> lock(gLiveBridgeStatesMutex);
+  auto find = gLiveBridgeStates.find(bridgeState);
+  return find != gLiveBridgeStates.end() && find->second == token;
+}
 
 void finalize_bridge_data(napi_env env, void* data, void* hint) {
   auto bridgeState = (ObjCBridgeState*)data;
@@ -459,6 +497,7 @@ void registerLegacyCompatGlobals(napi_env env, napi_value global, ObjCBridgeStat
 ObjCBridgeState::ObjCBridgeState(napi_env env, const char* metadata_path,
                                  const void* metadata_ptr) {
   napi_set_instance_data(env, this, finalize_bridge_data, nil);
+  lifetimeToken = RegisterBridgeState(this);
 
   self_dl = dlopen(nullptr, RTLD_NOW);
 
@@ -495,6 +534,8 @@ void registerLegacyCompatGlobals(napi_env env, napi_value global, ObjCBridgeStat
 }
 
 ObjCBridgeState::~ObjCBridgeState() {
+  UnregisterBridgeState(this);
+
   // Clean up cached Cif objects
   for (auto& pair : cifs) {
     delete pair.second;
diff --git a/NativeScript/ffi/Object.mm b/NativeScript/ffi/Object.mm
@@ -26,11 +26,13 @@ - (instancetype)initWithEnv:(napi_env)env ref:(napi_ref)ref;
 @end
 
 @interface ObjCLifecycleAssociation : NSObject {
-  napi_env _env;
+  nativescript::ObjCBridgeState* _bridgeState;
+  uint64_t _bridgeStateToken;
   uintptr_t _objectAddress;
 }
 
-- (instancetype)initWithEnv:(napi_env)env object:(id)object;
+- (instancetype)initWithBridgeState:(nativescript::ObjCBridgeState*)bridgeState
+                             object:(id)object;
 
 @end
 
@@ -66,22 +68,24 @@ - (void)dealloc {
 
 @implementation ObjCLifecycleAssociation
 
-- (instancetype)initWithEnv:(napi_env)env object:(id)object {
+- (instancetype)initWithBridgeState:(nativescript::ObjCBridgeState*)bridgeState
+                             object:(id)object {
   self = [super init];
   if (self) {
-    _env = env;
+    _bridgeState = bridgeState;
+    _bridgeStateToken = bridgeState != nullptr ? bridgeState->lifetimeToken : 0;
     _objectAddress = (uintptr_t)object;
   }
 
   return self;
 }
 
 - (void)dealloc {
-  napi_env env = _env;
+  nativescript::ObjCBridgeState* bridgeState = _bridgeState;
+  uint64_t bridgeStateToken = _bridgeStateToken;
   uintptr_t objectAddress = _objectAddress;
   dispatch_async(dispatch_get_main_queue(), ^{
-    nativescript::ObjCBridgeState* bridgeState = nativescript::ObjCBridgeState::InstanceData(env);
-    if (bridgeState != nullptr) {
+    if (nativescript::IsBridgeStateLive(bridgeState, bridgeStateToken)) {
       bridgeState->objectRefs.erase((id)objectAddress);
     }
   });
@@ -163,12 +167,17 @@ void attachObjectLifecycleAssociation(napi_env env, id object) {
     return;
   }
 
+  auto bridgeState = ObjCBridgeState::InstanceData(env);
+  if (bridgeState == nullptr) {
+    return;
+  }
+
   if (objc_getAssociatedObject(object, ObjCLifecycleAssociationKey) != nil) {
     return;
   }
 
-  ObjCLifecycleAssociation* association = [[ObjCLifecycleAssociation alloc] initWithEnv:env
-                                                                                  object:object];
+  ObjCLifecycleAssociation* association =
+      [[ObjCLifecycleAssociation alloc] initWithBridgeState:bridgeState object:object];
   objc_setAssociatedObject(object, ObjCLifecycleAssociationKey, association,
                            OBJC_ASSOCIATION_RETAIN_NONATOMIC);
   [association release];
