objc-js 0.0.11 → 0.0.13

package/src/native/protocol-impl.mm

@@ -1,17 +1,17 @@
 #include "protocol-impl.h"
+#include "method-forwarding.h"
 #include "ObjcObject.h"
-#include "bridge.h"
+#include "protocol-storage.h"
+#include "type-conversion.h"
 #include <Foundation/Foundation.h>
 #include <atomic>
 #include <chrono>
-#include <mutex>
 #include <napi.h>
-#include <objc/message.h>
 #include <objc/runtime.h>
-#include <pthread.h>
 #include <sstream>
 
-// Global storage for protocol implementations
+// MARK: - Global Storage Definition
+
 std::unordered_map<void *, ProtocolImplementation> g_implementations;
 std::mutex g_implementations_mutex;
 
@@ -75,594 +75,6 @@ std::vector<std::string> ParseMethodSignature(const char *typeEncoding) {
   return types;
 }
 
-// Convert Objective-C value to JavaScript value
-Napi::Value ConvertObjCValueToJS(Napi::Env env, void *valuePtr,
-                                 const char *typeEncoding) {
-  SimplifiedTypeEncoding simplifiedType(typeEncoding);
-
-  switch (simplifiedType[0]) {
-  case 'c': {
-    char value = *(char *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'i': {
-    int value = *(int *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 's': {
-    short value = *(short *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'l': {
-    long value = *(long *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'q': {
-    long long value = *(long long *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'C': {
-    unsigned char value = *(unsigned char *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'I': {
-    unsigned int value = *(unsigned int *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'S': {
-    unsigned short value = *(unsigned short *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'L': {
-    unsigned long value = *(unsigned long *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'Q': {
-    unsigned long long value = *(unsigned long long *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'f': {
-    float value = *(float *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'd': {
-    double value = *(double *)valuePtr;
-    return Napi::Number::New(env, value);
-  }
-  case 'B': {
-    bool value = *(bool *)valuePtr;
-    return Napi::Boolean::New(env, value);
-  }
-  case '*': {
-    char *value = *(char **)valuePtr;
-    if (value == nullptr) {
-      return env.Null();
-    }
-    return Napi::String::New(env, value);
-  }
-  case '@': {
-    id value = *(__strong id *)valuePtr;
-    if (value == nil) {
-      return env.Null();
-    }
-    return ObjcObject::NewInstance(env, value);
-  }
-  case '#': {
-    Class value = *(Class *)valuePtr;
-    if (value == nil) {
-      return env.Null();
-    }
-    return ObjcObject::NewInstance(env, value);
-  }
-  case ':': {
-    SEL value = *(SEL *)valuePtr;
-    if (value == nullptr) {
-      return env.Null();
-    }
-    NSString *selectorString = NSStringFromSelector(value);
-    if (selectorString == nil) {
-      return env.Null();
-    }
-    return Napi::String::New(env, [selectorString UTF8String]);
-  }
-  case 'v':
-    return env.Undefined();
-  default:
-    return env.Undefined();
-  }
-}
-
-// MARK: - ThreadSafeFunction Callback Handler
-
-// This function runs on the JavaScript thread
-void CallJSCallback(Napi::Env env, Napi::Function jsCallback, InvocationData* data) {
-  if (!data) {
-    NSLog(@"Error: InvocationData is null in CallJSCallback");
-    return;
-  }
-  
-  NSInvocation *invocation = data->invocation;
-  if (!invocation) {
-    NSLog(@"Error: NSInvocation is null in CallJSCallback");
-    return;
-  }
-  
-  // Extract arguments using NSInvocation
-  NSMethodSignature *sig = [invocation methodSignature];
-  if (!sig) {
-    NSLog(@"Error: Failed to get method signature for selector %s", 
-          data->selectorName.c_str());
-    return;
-  }
-  
-  std::vector<napi_value> jsArgs;
-  
-  // Skip first two arguments (self and _cmd)
-  for (NSUInteger i = 2; i < [sig numberOfArguments]; i++) {
-    const char *type = [sig getArgumentTypeAtIndex:i];
-    SimplifiedTypeEncoding argType(type);
-    
-    switch (argType[0]) {
-    case 'c': {
-      char value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'i': {
-      int value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 's': {
-      short value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'l': {
-      long value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'q': {
-      long long value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'C': {
-      unsigned char value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'I': {
-      unsigned int value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'S': {
-      unsigned short value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'L': {
-      unsigned long value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'Q': {
-      unsigned long long value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'f': {
-      float value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'd': {
-      double value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Number::New(env, value));
-      break;
-    }
-    case 'B': {
-      bool value;
-      [invocation getArgument:&value atIndex:i];
-      jsArgs.push_back(Napi::Boolean::New(env, value));
-      break;
-    }
-    case '*': {
-      char *value;
-      [invocation getArgument:&value atIndex:i];
-      if (value == nullptr) {
-        jsArgs.push_back(env.Null());
-      } else {
-        jsArgs.push_back(Napi::String::New(env, value));
-      }
-      break;
-    }
-    case '@': {
-      __unsafe_unretained id value;
-      [invocation getArgument:&value atIndex:i];
-      if (value == nil) {
-        jsArgs.push_back(env.Null());
-      } else {
-        jsArgs.push_back(ObjcObject::NewInstance(env, value));
-      }
-      break;
-    }
-    case '#': {
-      Class value;
-      [invocation getArgument:&value atIndex:i];
-      if (value == nil) {
-        jsArgs.push_back(env.Null());
-      } else {
-        jsArgs.push_back(ObjcObject::NewInstance(env, value));
-      }
-      break;
-    }
-    case ':': {
-      SEL value;
-      [invocation getArgument:&value atIndex:i];
-      if (value == nullptr) {
-        jsArgs.push_back(env.Null());
-      } else {
-        NSString *selString = NSStringFromSelector(value);
-        if (selString == nil) {
-          jsArgs.push_back(env.Null());
-        } else {
-          jsArgs.push_back(Napi::String::New(env, [selString UTF8String]));
-        }
-      }
-      break;
-    }
-    case '^': {
-      void *value;
-      [invocation getArgument:&value atIndex:i];
-      if (value == nullptr) {
-        jsArgs.push_back(env.Null());
-      } else {
-        jsArgs.push_back(env.Undefined());
-      }
-      break;
-    }
-    default:
-      jsArgs.push_back(env.Undefined());
-      break;
-    }
-  }
-  
-  // Call the JavaScript callback
-  try {
-    Napi::Value result = jsCallback.Call(jsArgs);
-    
-    // Handle return value if the method expects one
-    const char *returnType = [sig methodReturnType];
-    SimplifiedTypeEncoding retType(returnType);
-    
-    if (retType[0] != 'v') { // Not void
-      // Convert JS return value to Objective-C and set it
-      if (!result.IsUndefined() && !result.IsNull()) {
-        switch (retType[0]) {
-        case 'c': {
-          char value = result.As<Napi::Number>().Int32Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'i': {
-          int value = result.As<Napi::Number>().Int32Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 's': {
-          short value = result.As<Napi::Number>().Int32Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'l': {
-          long value = result.As<Napi::Number>().Int64Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'q': {
-          long long value = result.As<Napi::Number>().Int64Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'C': {
-          unsigned char value = result.As<Napi::Number>().Uint32Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'I': {
-          unsigned int value = result.As<Napi::Number>().Uint32Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'S': {
-          unsigned short value = result.As<Napi::Number>().Uint32Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'L': {
-          unsigned long value = result.As<Napi::Number>().Int64Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'Q': {
-          unsigned long long value = result.As<Napi::Number>().Int64Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'f': {
-          float value = result.As<Napi::Number>().FloatValue();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'd': {
-          double value = result.As<Napi::Number>().DoubleValue();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case 'B': {
-          bool value = result.As<Napi::Boolean>().Value();
-          [invocation setReturnValue:&value];
-          break;
-        }
-        case '@': {
-          // Return an Objective-C object
-          if (result.IsObject()) {
-            Napi::Object resultObj = result.As<Napi::Object>();
-            // Check if it's an ObjcObject instance
-            if (resultObj.InstanceOf(ObjcObject::constructor.Value())) {
-              ObjcObject *objcObj = Napi::ObjectWrap<ObjcObject>::Unwrap(resultObj);
-              id objcValue = objcObj->objcObject;
-              [invocation setReturnValue:&objcValue];
-            } else {
-              NSLog(@"Warning: result object is not an ObjcObject instance");
-            }
-          } else if (result.IsNull()) {
-            id objcValue = nil;
-            [invocation setReturnValue:&objcValue];
-          } else {
-            NSLog(@"Warning: result is not an object (type: %d)", result.Type());
-          }
-          break;
-        }
-        default:
-          NSLog(@"Warning: Unsupported return type '%c' for selector %s", 
-                retType[0], data->selectorName.c_str());
-          break;
-        }
-      }
-    }
-  } catch (const Napi::Error &e) {
-    NSLog(@"Error calling JavaScript callback for %s: %s",
-          data->selectorName.c_str(), e.what());
-  } catch (const std::exception &e) {
-    NSLog(@"Exception calling JavaScript callback for %s: %s",
-          data->selectorName.c_str(), e.what());
-  } catch (...) {
-    NSLog(@"Unknown error calling JavaScript callback for %s",
-          data->selectorName.c_str());
-  }
-  
-  // Clean up the invocation data
-  delete data;
-}
-
-// MARK: - Message Forwarding Implementation
-
-// Override respondsToSelector to return YES for methods we implement
-BOOL RespondsToSelector(id self, SEL _cmd, SEL selector) {
-  void *ptr = (__bridge void *)self;
-  
-  // Check if this is one of our implemented methods
-  {
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    auto it = g_implementations.find(ptr);
-    if (it != g_implementations.end()) {
-      NSString *selectorString = NSStringFromSelector(selector);
-      if (selectorString != nil) {
-        std::string selName = [selectorString UTF8String];
-        auto callbackIt = it->second.callbacks.find(selName);
-        if (callbackIt != it->second.callbacks.end()) {
-          return YES;
-        }
-      }
-    }
-  }
-  
-  // For methods we don't implement, check if NSObject responds to them
-  // This handles standard NSObject methods like description, isEqual:, etc.
-  return [NSObject instancesRespondToSelector:selector];
-}
-
-// Provide method signature for message forwarding
-NSMethodSignature* MethodSignatureForSelector(id self, SEL _cmd, SEL selector) {
-  void *ptr = (__bridge void *)self;
-  
-  std::lock_guard<std::mutex> lock(g_implementations_mutex);
-  auto it = g_implementations.find(ptr);
-  if (it != g_implementations.end()) {
-    NSString *selectorString = NSStringFromSelector(selector);
-    std::string selName = [selectorString UTF8String];
-    auto encIt = it->second.typeEncodings.find(selName);
-    if (encIt != it->second.typeEncodings.end()) {
-      return [NSMethodSignature signatureWithObjCTypes:encIt->second.c_str()];
-    }
-  }
-  // Fall back to superclass for methods we don't implement
-  return [NSObject instanceMethodSignatureForSelector:selector];
-}
-
-// Handle forwarded invocations
-void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
-  if (!invocation) {
-    NSLog(@"Error: ForwardInvocation called with nil invocation");
-    return;
-  }
-  
-  // Retain the invocation to keep it alive during async call
-  [invocation retainArguments];
-  
-  SEL selector = [invocation selector];
-  NSString *selectorString = NSStringFromSelector(selector);
-  if (!selectorString) {
-    NSLog(@"Error: Failed to convert selector to string");
-    return;
-  }
-  
-  std::string selectorName = [selectorString UTF8String];
-  
-  // Store self pointer for later lookups
-  void *ptr = (__bridge void *)self;
-  
-  // First pass: get ONLY thread-safe data (pthread_t, TSFN, typeEncoding)
-  // DO NOT access any N-API values here - we may not be on the JS thread!
-  pthread_t js_thread;
-  Napi::ThreadSafeFunction tsfn;
-  std::string typeEncoding;
-  {
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    auto it = g_implementations.find(ptr);
-    if (it == g_implementations.end()) {
-      NSLog(@"Warning: Protocol implementation not found for instance %p", self);
-      return;
-    }
-    
-    auto callbackIt = it->second.callbacks.find(selectorName);
-    if (callbackIt == it->second.callbacks.end()) {
-      NSLog(@"Warning: Callback not found for selector %s", selectorName.c_str());
-      return;
-    }
-    
-    // Get thread ID first - this is a plain C type, safe from any thread
-    js_thread = it->second.js_thread;
-    
-    // Get the ThreadSafeFunction - this is thread-safe by design
-    // IMPORTANT: We must Acquire() to increment the ref count, because copying
-    // a ThreadSafeFunction does NOT increment it. If DeallocImplementation runs
-    // and calls Release() on the original, our copy would become invalid.
-    tsfn = callbackIt->second;
-    napi_status acq_status = tsfn.Acquire();
-    if (acq_status != napi_ok) {
-      NSLog(@"Warning: Failed to acquire ThreadSafeFunction for selector %s", selectorName.c_str());
-      return;
-    }
-    
-    // Get the type encoding for return value handling
-    auto encIt = it->second.typeEncodings.find(selectorName);
-    if (encIt != it->second.typeEncodings.end()) {
-      typeEncoding = encIt->second;
-    }
-  }
-  
-  // Check if we're on the JS thread BEFORE any N-API value access
-  bool is_js_thread = pthread_equal(pthread_self(), js_thread);
-  
-  // Create invocation data
-  auto data = new InvocationData();
-  data->invocation = invocation;
-  data->selectorName = selectorName;
-  data->typeEncoding = typeEncoding;
-  
-  if (is_js_thread) {
-    // We're on the JS thread, so it's safe to access N-API values directly
-    // Release the TSFN we acquired - we don't need it on this path
-    tsfn.Release();
-    
-    // Do a second lookup to get the JS callback
-    // IMPORTANT: We must call .Value() while holding the lock to prevent
-    // DeallocImplementation from erasing the entry while we're using it
-    napi_env stored_env;
-    Napi::Function jsFn;
-    {
-      std::lock_guard<std::mutex> lock(g_implementations_mutex);
-      auto it = g_implementations.find(ptr);
-      if (it == g_implementations.end()) {
-        NSLog(@"Warning: Protocol implementation not found for instance %p (JS thread path)", self);
-        delete data;
-        return;
-      }
-      
-      auto jsCallbackIt = it->second.jsCallbacks.find(selectorName);
-      if (jsCallbackIt == it->second.jsCallbacks.end()) {
-        NSLog(@"Warning: JS callback not found for selector %s (JS thread path)", selectorName.c_str());
-        delete data;
-        return;
-      }
-      
-      stored_env = it->second.env;
-      // Get the function value WHILE HOLDING THE LOCK
-      // This prevents a race with DeallocImplementation clearing the jsCallbacks map
-      jsFn = jsCallbackIt->second.Value();
-    }
-    
-    // Now jsFn is a local Napi::Function (napi_value), safe to use after lock release
-    Napi::Env env(stored_env);
-    CallJSCallback(env, jsFn, data);
-    // Data is deleted in CallJSCallback
-  } else {
-    // We're on a different thread - NEVER access FunctionReference here!
-    // Use ThreadSafeFunction to marshal to JS thread
-    napi_status status = tsfn.BlockingCall(data, CallJSCallback);
-    
-    // Release our acquired reference to the TSFN
-    // This balances the Acquire() call above
-    tsfn.Release();
-    
-    if (status != napi_ok) {
-      NSLog(@"Error: Failed to call ThreadSafeFunction for selector %s (status: %d)",
-            selectorName.c_str(), status);
-      delete data;
-      return;
-    }
-    // Data will be deleted in the callback
-  }
-}
-
-// Deallocation implementation
-void DeallocImplementation(id self, SEL _cmd) {
-  @autoreleasepool {
-    // Remove the implementation from the global map
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    void *ptr = (__bridge void *)self;
-    auto it = g_implementations.find(ptr);
-    if (it != g_implementations.end()) {
-      // Release all ThreadSafeFunctions and JS callbacks
-      // Do this carefully to avoid issues during shutdown
-      try {
-        for (auto& pair : it->second.callbacks) {
-          // Release the ThreadSafeFunction
-          pair.second.Release();
-        }
-        it->second.callbacks.clear();
-        it->second.jsCallbacks.clear();
-        it->second.typeEncodings.clear();
-      } catch (...) {
-        // Ignore errors during cleanup
-        NSLog(@"Warning: Exception during callback cleanup for instance %p", self);
-      }
-      g_implementations.erase(it);
-    }
-  }
-
-  // Call the superclass dealloc
-  // Note: Under ARC, we don't need to manually call [super dealloc]
-  // The runtime handles this automatically
-}
-
 // MARK: - Main Implementation
 
 Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
@@ -718,13 +130,33 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
   // Get the method implementations object's property names
   Napi::Array propertyNames = methodImplementations.GetPropertyNames();
 
+  // Detect if we're running in Electron by checking process.versions.electron
+  bool isElectron = false;
+  try {
+    Napi::Object global = env.Global();
+    if (global.Has("process")) {
+      Napi::Object process = global.Get("process").As<Napi::Object>();
+      if (process.Has("versions")) {
+        Napi::Object versions = process.Get("versions").As<Napi::Object>();
+        isElectron = versions.Has("electron");
+      }
+    }
+  } catch (...) {
+    // If detection fails, assume not Electron
+  }
+  
+  if (isElectron) {
+    NSLog(@"[DEBUG] Detected Electron runtime, will always use TSFN path");
+  }
+
   // Store callbacks for this instance (we'll set the instance pointer later)
   ProtocolImplementation impl{
       .callbacks = {},
       .typeEncodings = {},
       .className = className,
       .env = env,
-      .js_thread = pthread_self() // Store the current (JS) thread ID
+      .js_thread = pthread_self(), // Store the current (JS) thread ID
+      .isElectron = isElectron
   };
 
   // Store default type encodings to keep them alive
@@ -781,7 +213,7 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
       for (size_t j = 0; j < colonCount; j++) {
         defaultEncoding += "@";
       }
-      
+
       // Store the string to keep it alive, then use its c_str()
       defaultTypeEncodings.push_back(std::move(defaultEncoding));
       typeEncoding = defaultTypeEncodings.back().c_str();
@@ -793,27 +225,28 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
 
     // Create a ThreadSafeFunction for this callback
     Napi::ThreadSafeFunction tsfn = Napi::ThreadSafeFunction::New(
-      env,
-      jsCallback,                    // The JS function to call
-      "ProtocolCallback",            // Resource name
-      0,                             // Max queue size (0 = unlimited)
-      1,                             // Initial thread count
-      [](Napi::Env) {} // Finalizer (no context to clean up)
+        env,
+        jsCallback,         // The JS function to call
+        "ProtocolCallback", // Resource name
+        0,                  // Max queue size (0 = unlimited)
+        1,                  // Initial thread count
+        [](Napi::Env) {}    // Finalizer (no context to clean up)
     );
-    
+
     // Store both the TSFN and the original JS function
     impl.callbacks[selectorName] = tsfn;
     impl.jsCallbacks[selectorName] = Napi::Persistent(jsCallback);
     impl.typeEncodings[selectorName] = std::string(typeEncoding);
   }
-  
+
   // Override respondsToSelector
-  // Use class_addMethod since the class is being created and doesn't have methods yet
+  // Use class_addMethod since the class is being created and doesn't have
+  // methods yet
   if (!class_addMethod(newClass, @selector(respondsToSelector:),
                        (IMP)RespondsToSelector, "B@::")) {
     NSLog(@"Warning: Failed to add respondsToSelector: method");
   }
-  
+
   // Add message forwarding methods to the class
   class_addMethod(newClass, @selector(methodSignatureForSelector:),
                   (IMP)MethodSignatureForSelector, "@@::");
@@ -848,4 +281,3 @@ Napi::Value CreateProtocolImplementation(const Napi::CallbackInfo &info) {
   // Return wrapped object
   return ObjcObject::NewInstance(env, instance);
 }
-