feat: expand generic NativeScript runtime parity

Author: DjDeveloperr

NativeScript/ffi/jsc/NativeApiJSCSelectorGroups.mm

@@ -173,11 +173,11 @@ NativeApiReturnStorage returnStorage(
 #if defined(__x86_64__)
       bool isStret = signature.returnType.ffiType->size > 16 &&
                      signature.returnType.ffiType->type == FFI_TYPE_STRUCT;
-      void* target = dispatchSuperClass != Nil
-                         ? (isStret ? FFI_FN(objc_msgSendSuper_stret)
-                                    : FFI_FN(objc_msgSendSuper))
-                         : (isStret ? FFI_FN(objc_msgSend_stret)
-                                    : FFI_FN(objc_msgSend));
+      void (*target)(void) =
+          dispatchSuperClass != Nil
+              ? (isStret ? FFI_FN(objc_msgSendSuper_stret)
+                         : FFI_FN(objc_msgSendSuper))
+              : (isStret ? FFI_FN(objc_msgSend_stret) : FFI_FN(objc_msgSend));
       ffi_call(const_cast<ffi_cif*>(&signature.cif), target,
                returnStorage.data(), values.data());
 #else
@@ -456,4 +456,3 @@ Function CreateNativeApiBoundSelectorGroupFunction(
       receiverHostObject != nullptr ? receiverHostObject->lifetimeState()
                                     : nullptr);
 }
-

NativeScript/ffi/napi/ObjCBridge.mm

@@ -26,6 +26,7 @@
 #include <mach-o/getsect.h>
 #include <objc/runtime.h>
 #include <atomic>
+#include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <mutex>
@@ -46,6 +47,18 @@ const unsigned char __attribute__((section("__objc_metadata,__objc_metadata")))
 std::atomic<uint64_t> gNextBridgeStateToken{1};
 constexpr const char* kNativePointerProperty = "__ns_native_ptr";
 
+bool envFlagEnabled(const char* name) {
+  const char* value = std::getenv(name);
+  if (value == nullptr || value[0] == '\0') {
+    return false;
+  }
+
+  return std::strcmp(value, "0") != 0 && std::strcmp(value, "false") != 0 &&
+         std::strcmp(value, "FALSE") != 0 && std::strcmp(value, "False") != 0 &&
+         std::strcmp(value, "off") != 0 && std::strcmp(value, "OFF") != 0 &&
+         std::strcmp(value, "no") != 0 && std::strcmp(value, "NO") != 0;
+}
+
 inline void deleteReferenceNow(napi_env env, napi_ref ref, bool unrefFirst) {
   if (env == nullptr || ref == nullptr) {
     return;
@@ -958,7 +971,7 @@ void registerLegacyCompatGlobals(napi_env env, napi_value global, ObjCBridgeStat
 
   napi_value result = object;
   const bool nativeIsArray = [nativeObject isKindOfClass:NSArray.class];
-  bool shouldProxyArray = nativeIsArray;
+  bool shouldProxyArray = nativeIsArray && !envFlagEnabled("NS_DISABLE_NAPI_ARRAY_PROXY");
   if (shouldProxyArray) {
     napi_value factory = get_ref_value(env, createNativeProxy);
     napi_value transferOwnershipFunc = get_ref_value(env, this->transferOwnershipToNative);

NativeScript/ffi/quickjs/NativeApiQuickJSSelectorGroups.mm

@@ -173,11 +173,11 @@ NativeApiReturnStorage returnStorage(
 #if defined(__x86_64__)
       bool isStret = signature.returnType.ffiType->size > 16 &&
                      signature.returnType.ffiType->type == FFI_TYPE_STRUCT;
-      void* target = dispatchSuperClass != Nil
-                         ? (isStret ? FFI_FN(objc_msgSendSuper_stret)
-                                    : FFI_FN(objc_msgSendSuper))
-                         : (isStret ? FFI_FN(objc_msgSend_stret)
-                                    : FFI_FN(objc_msgSend));
+      void (*target)(void) =
+          dispatchSuperClass != Nil
+              ? (isStret ? FFI_FN(objc_msgSendSuper_stret)
+                         : FFI_FN(objc_msgSendSuper))
+              : (isStret ? FFI_FN(objc_msgSend_stret) : FFI_FN(objc_msgSend));
       ffi_call(const_cast<ffi_cif*>(&signature.cif), target,
                returnStorage.data(), values.data());
 #else
@@ -462,4 +462,3 @@ Function CreateNativeApiBoundSelectorGroupFunction(
       receiverHostObject != nullptr ? receiverHostObject->lifetimeState()
                                     : nullptr);
 }
-

NativeScript/ffi/shared/NativeApiBackendConfig.h

@@ -20,6 +20,7 @@ struct NativeApiBackendConfig {
   std::shared_ptr<NativeApiBackendScheduler> scheduler = nullptr;
   std::function<void(std::function<void()>)> nativeInvocationInvoker = nullptr;
   std::function<void(std::function<void()>)> nativeCallbackInvoker = nullptr;
+  std::function<void(std::function<void()>)> runtimeCallbackInvoker = nullptr;
   std::function<void(std::function<void()>)> jsThreadCallbackInvoker = nullptr;
   std::function<void(std::function<void()>)> jsThreadAsyncCallbackInvoker = nullptr;
   bool invokeCallbacksOnNativeCallerThread = false;

NativeScript/ffi/shared/bridge/Callbacks.mm

@@ -41,6 +41,7 @@ explicit NativeApiRuntimeScope(Runtime&) {}
 enum class NativeApiCallbackThreadPolicy {
   Default,
   JS,
+  Runtime,
 };
 
 NativeApiCallbackThreadPolicy readEngineCallbackThreadPolicy(
@@ -58,6 +59,9 @@ NativeApiCallbackThreadPolicy readEngineCallbackThreadPolicy(
     if (policy == "js") {
       return NativeApiCallbackThreadPolicy::JS;
     }
+    if (policy == "runtime" || policy == "worklet") {
+      return NativeApiCallbackThreadPolicy::Runtime;
+    }
   } catch (const std::exception&) {
   }
   return NativeApiCallbackThreadPolicy::Default;
@@ -579,6 +583,7 @@ void invoke(void* ret, void* args[]) {
     std::string error;
     auto call = [&]() { invokeOnCurrentThread(ret, args, &error); };
     const auto& nativeCallbackInvoker = bridge_->nativeCallbackInvoker();
+    const auto& runtimeCallbackInvoker = bridge_->runtimeCallbackInvoker();
     const auto& jsThreadCallbackInvoker = bridge_->jsThreadCallbackInvoker();
     bool currentThreadIsJs =
         std::this_thread::get_id() == bridge_->jsThreadId();
@@ -611,6 +616,17 @@ void invoke(void* ret, void* args[]) {
       }
       error = "Native callback was invoked off the JS thread without a JS scheduler.";
     };
+    auto callOnRuntimeThread = [&]() {
+      if (currentThreadIsJs) {
+        call();
+        return;
+      }
+      if (runtimeCallbackInvoker) {
+        runtimeCallbackInvoker(call);
+        return;
+      }
+      error = "Native callback was invoked off its owning runtime thread without a runtime scheduler.";
+    };
 
     if (threadPolicy_ == NativeApiCallbackThreadPolicy::JS) {
       callOnJSThread();
@@ -621,20 +637,21 @@ void invoke(void* ret, void* args[]) {
       }
       return;
     }
+    if (threadPolicy_ == NativeApiCallbackThreadPolicy::Runtime) {
+      callOnRuntimeThread();
+      if (!error.empty()) {
+        if (!recordNativeCallbackException(error)) {
+          throwNativeApiCallbackException(error);
+        }
+      }
+      return;
+    }
 
     bool returnsVoid = signature_->returnType.kind == metagen::mdTypeVoid;
-    bool activeSynchronousNativeInvocation =
-        gActiveSynchronousNativeInvocationDepth.load(
-            std::memory_order_acquire) > 0;
     bool nativeCallerThreadCallbacks =
         bridge_->invokeCallbacksOnNativeCallerThread();
-    bool nativeCallerThreadCallback =
-        nativeCallerThreadCallbacks && !currentThreadIsJs &&
-        activeSynchronousNativeInvocation &&
-        (block_ || bindThis_ || !returnsVoid);
     bool direct = currentThreadIsJs ||
-                  gSynchronousNativeInvocationDepth > 0 ||
-                  nativeCallerThreadCallback;
+                  gSynchronousNativeInvocationDepth > 0;
     bool waitForNativeThreadCallback =
         currentThreadIsJs && nativeCallbackInvoker &&
         gActiveNativeThreadEngineCallbacks.load(std::memory_order_acquire) > 0;
@@ -671,21 +688,14 @@ void invoke(void* ret, void* args[]) {
       return false;
     };
 
-    if (dispatchZeroArgVoidBlockAsync()) {
+    if (nativeCallerThreadCallbacks && !currentThreadIsJs) {
+      callOnNativeCallerThread();
+    } else if (dispatchZeroArgVoidBlockAsync()) {
       return;
-    }
-
-    if (direct && !waitForNativeThreadCallback) {
-      if (nativeCallerThreadCallback) {
-        callOnNativeCallerThread();
-      } else {
-        call();
-      }
-    } else if (!currentThreadIsJs && !nativeCallerThreadCallbacks) {
+    } else if (direct && !waitForNativeThreadCallback) {
+      call();
+    } else if (!currentThreadIsJs) {
       callOnJSThread();
-    } else if (!currentThreadIsJs && returnsVoid && block_ &&
-               jsThreadCallbackInvoker) {
-      jsThreadCallbackInvoker(call);
     } else if (nativeCallbackInvoker) {
       bool nativeThreadCallback = !currentThreadIsJs;
       if (nativeThreadCallback) {
@@ -1472,6 +1482,31 @@ NativeApiType parseMetadataEngineType(MDMetadataReader* metadata,
   return signature;
 }
 
+bool prepareEngineCallbackSignature(NativeApiSignature* signature) {
+  if (signature == nullptr) {
+    return false;
+  }
+
+  signature->ffiTypes.clear();
+  signature->ffiTypes.reserve(signature->argumentTypes.size() +
+                              signature->implicitArgumentCount);
+  for (unsigned int i = 0; i < signature->implicitArgumentCount; i++) {
+    signature->ffiTypes.push_back(&ffi_type_pointer);
+  }
+  for (const auto& argType : signature->argumentTypes) {
+    signature->ffiTypes.push_back(ffiTypeForEngineArgument(argType));
+  }
+
+  ffi_status status = ffi_prep_cif(
+      &signature->cif, FFI_DEFAULT_ABI,
+      static_cast<unsigned int>(signature->ffiTypes.size()),
+      signature->returnType.ffiType != nullptr ? signature->returnType.ffiType
+                                               : &ffi_type_void,
+      signature->ffiTypes.empty() ? nullptr : signature->ffiTypes.data());
+  signature->prepared = status == FFI_OK;
+  return signature->prepared;
+}
+
 const char* skipObjCTypeQualifiers(const char* encoding) {
   while (encoding != nullptr && *encoding != '\0' &&
          std::strchr("rnNoORV", *encoding) != nullptr) {
@@ -1480,6 +1515,13 @@ NativeApiType parseMetadataEngineType(MDMetadataReader* metadata,
   return encoding;
 }
 
+const char* skipObjCTypeFrameOffset(const char* encoding) {
+  while (encoding != nullptr && *encoding >= '0' && *encoding <= '9') {
+    encoding++;
+  }
+  return encoding;
+}
+
 const char* skipObjCTypeFieldName(const char* encoding, std::string* name) {
   if (encoding == nullptr || *encoding != '"') {
     return encoding;
@@ -1930,6 +1972,48 @@ NativeApiType parseObjCEncodedEngineType(
   return finishPrimitive(encoding + 1);
 }
 
+std::optional<NativeApiSignature> parseObjCCallbackEngineSignature(
+    const std::string& encodingString, bool block, NativeApiBridge* bridge) {
+  const char* cursor = skipObjCTypeQualifiers(encodingString.c_str());
+  if (cursor == nullptr || *cursor == '\0') {
+    return std::nullopt;
+  }
+
+  NativeApiSignature signature;
+  signature.implicitArgumentCount = block ? 1 : 0;
+
+  const char* returnEnd = cursor;
+  signature.returnType = parseObjCEncodedEngineType(cursor, bridge, &returnEnd);
+  if (returnEnd == cursor) {
+    return std::nullopt;
+  }
+  cursor = skipObjCTypeFrameOffset(returnEnd);
+
+  if (block) {
+    const char* blockSelf = skipObjCTypeQualifiers(cursor);
+    if (blockSelf != nullptr && blockSelf[0] == '@' && blockSelf[1] == '?') {
+      cursor = skipObjCTypeFrameOffset(blockSelf + 2);
+    }
+  }
+
+  while (cursor != nullptr && *cursor != '\0') {
+    const char* argStart = skipObjCTypeQualifiers(cursor);
+    if (argStart == nullptr || *argStart == '\0') {
+      break;
+    }
+    const char* argEnd = argStart;
+    NativeApiType argType = parseObjCEncodedEngineType(argStart, bridge, &argEnd);
+    if (argEnd == argStart) {
+      return std::nullopt;
+    }
+    signature.argumentTypes.push_back(std::move(argType));
+    cursor = skipObjCTypeFrameOffset(argEnd);
+  }
+
+  prepareEngineCallbackSignature(&signature);
+  return signature;
+}
+
 std::optional<NativeApiSignature> parseObjCMethodEngineSignature(
     Method method, NativeApiBridge* bridge = nullptr) {
   if (method == nullptr) {
@@ -2110,6 +2194,36 @@ throw JSError(
   return callback;
 }
 
+std::shared_ptr<NativeApiCallback> createEngineCallback(
+    Runtime& runtime, const std::shared_ptr<NativeApiBridge>& bridge,
+    const std::string& objcSignatureEncoding, Function function, bool block,
+    NativeApiCallbackThreadPolicy threadPolicy =
+        NativeApiCallbackThreadPolicy::Default,
+    uintptr_t roundTripValidationKey = 0) {
+  if (bridge == nullptr || objcSignatureEncoding.empty()) {
+    throw JSError(runtime, "Native callback encoding is unavailable.");
+  }
+
+  auto parsed = parseObjCCallbackEngineSignature(
+      objcSignatureEncoding, block, bridge.get());
+  if (!parsed || !signatureSupportedForEngineCallback(*parsed)) {
+    throw JSError(
+        runtime, "Native callback signature is not supported by backend.");
+  }
+
+  auto signature =
+      std::make_shared<NativeApiSignature>(std::move(*parsed));
+  auto callback = std::make_shared<NativeApiCallback>(
+      runtime, bridge, std::move(signature), std::move(function), block,
+      threadPolicy, false, roundTripValidationKey);
+  if (block) {
+    callback->retainInitialBlockLifetime(callback);
+  } else {
+    bridge->retainEngineLifetime(callback);
+  }
+  return callback;
+}
+
 std::shared_ptr<NativeApiCallback> createEngineMethodCallback(
     Runtime& runtime, const std::shared_ptr<NativeApiBridge>& bridge,
     const std::string& selectorName, MDSectionOffset signatureOffset,