feat: use node module bindings like the iOS runtime (#1795)

test-app/runtime/CMakeLists.txt

@@ -115,6 +115,7 @@ add_library(
  src/main/cpp/MetadataReader.cpp
  src/main/cpp/MetadataTreeNode.cpp
  src/main/cpp/MethodCache.cpp
+ src/main/cpp/ModuleBinding.cpp
  src/main/cpp/ModuleInternal.cpp
  src/main/cpp/NativeScriptException.cpp
  src/main/cpp/NumericCasts.cpp

test-app/runtime/src/main/cpp/IsolateDisposer.cpp

@@ -9,11 +9,19 @@
 #include <console/Console.h>
 
 
+
 namespace tns {
  void disposeIsolate(v8::Isolate *isolate) {
  tns::ArgConverter::onDisposeIsolate(isolate);
  tns::MetadataNode::onDisposeIsolate(isolate);
  tns::V8GlobalHelpers::onDisposeIsolate(isolate);
  tns::Console::onDisposeIsolate(isolate);
+ // clear all isolate bound objects
+ std::lock_guard<std::mutex> lock(isolateBoundObjectsMutex_);
+ auto it = isolateBoundObjects_.find(isolate);
+ if (it != isolateBoundObjects_.end()) {
+ it->second->clear();
+ isolateBoundObjects_.erase(it);
+ }
  }
 }

test-app/runtime/src/main/cpp/IsolateDisposer.h

@@ -5,9 +5,36 @@
 #ifndef TEST_APP_ISOLATEDISPOSER_H
 #define TEST_APP_ISOLATEDISPOSER_H
 #include "v8.h"
+#include "robin_hood.h"
+#include <vector>
+#include <mutex>
+#include <memory>
 
 namespace tns {
  void disposeIsolate(v8::Isolate* isolate);
+ using unique_void_ptr = std::unique_ptr<void, void(*)(void const*)>;
+ template<typename T>
+ auto unique_void(T * ptr) -> unique_void_ptr
+ {
+ return unique_void_ptr(ptr, [](void const * data) {
+ T const * p = static_cast<T const*>(data);
+ delete p;
+ });
+ }
+ robin_hood::unordered_map<v8::Isolate*, std::shared_ptr<std::vector<unique_void_ptr>>> isolateBoundObjects_;
+ std::mutex isolateBoundObjectsMutex_;
+ template<typename T>
+ void registerIsolateBoundObject(v8::Isolate* isolate, T *ptr) {
+ std::lock_guard<std::mutex> lock(isolateBoundObjectsMutex_);
+ auto it = isolateBoundObjects_.find(isolate);
+ if (it == isolateBoundObjects_.end()) {
+ auto vec = std::make_shared<std::vector<unique_void_ptr>>();
+ vec->push_back(unique_void(ptr));
+ isolateBoundObjects_.emplace(isolate, vec);
+ } else {
+ it->second->push_back(unique_void(ptr));
+ }
+ }
 }
 
 #endif //TEST_APP_ISOLATEDISPOSER_H

test-app/runtime/src/main/cpp/ModuleBinding.cpp

@@ -0,0 +1,101 @@
+//
+// ModuleBinding.cpp
+// NativeScript
+//
+// Created by Eduardo Speroni on 5/11/23.
+// Copyright © 2023 Progress. All rights reserved.
+//
+
+#include "ModuleBinding.h"
+
+// TODO: add here
+//#define NSC_BUILTIN_STANDARD_BINDINGS(V) \
+//V(fs)
+
+#define NSC_BUILTIN_STANDARD_BINDINGS(V)
+
+
+#define NSC_BUILTIN_BINDINGS(V) \
+NSC_BUILTIN_STANDARD_BINDINGS(V)
+
+// This is used to load built-in bindings. Instead of using
+// __attribute__((constructor)), we call the _register_<modname>
+// function for each built-in bindings explicitly in
+// binding::RegisterBuiltinBindings(). This is only forward declaration.
+// The definitions are in each binding's implementation when calling
+// the NODE_BINDING_CONTEXT_AWARE_INTERNAL.
+#define V(modname) void _register_##modname();
+NSC_BUILTIN_BINDINGS(V)
+#undef V
+
+
+
+
+#define V(modname) \
+ void _register_isolate_##modname(v8::Isolate* isolate, \
+ v8::Local<v8::FunctionTemplate> target);
+NODE_BINDINGS_WITH_PER_ISOLATE_INIT(V)
+#undef V
+
+
+
+using v8::Context;
+using v8::EscapableHandleScope;
+using v8::Exception;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::HandleScope;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+namespace tns {
+// Globals per process
+static ns_module* modlist_internal;
+static ns_module* modlist_linked;
+static thread_local ns_module* thread_local_modpending;
+bool node_is_initialized = false;
+
+extern "C" void nativescript_module_register(void* m) {
+ struct ns_module* mp = reinterpret_cast<struct ns_module*>(m);
+
+ if (mp->nm_flags & NM_F_INTERNAL) {
+ mp->nm_link = modlist_internal;
+ modlist_internal = mp;
+ } else if (!node_is_initialized) {
+ // "Linked" modules are included as part of the node project.
+ // Like builtins they are registered *before* node::Init runs.
+ mp->nm_flags = NM_F_LINKED;
+ mp->nm_link = modlist_linked;
+ modlist_linked = mp;
+ } else {
+ thread_local_modpending = mp;
+ }
+}
+
+namespace binding {
+
+void RegisterBuiltinBindings() {
+#define V(modname) _register_##modname();
+ NSC_BUILTIN_BINDINGS(V)
+#undef V
+}
+
+void CreateInternalBindingTemplates(v8::Isolate* isolate, Local<FunctionTemplate> templ) {
+#define V(modname) \
+ do { \
+ /*templ->InstanceTemplate()->SetInternalFieldCount( \
+ BaseObject::kInternalFieldCount);*/ \
+ _register_isolate_##modname(isolate, templ); \
+ /*isolate_data->set_##modname##_binding(templ);*/ \
+ } while (0);
+ NODE_BINDINGS_WITH_PER_ISOLATE_INIT(V)
+#undef V
+}
+
+};
+
+};
+

test-app/runtime/src/main/cpp/ModuleBinding.h

@@ -0,0 +1,98 @@
+//
+// ModuleBinding.hpp
+// NativeScript
+//
+// Created by Eduardo Speroni on 5/11/23.
+// Copyright © 2023 Progress. All rights reserved.
+//
+
+#ifndef ModuleBinding_hpp
+#define ModuleBinding_hpp
+
+#include "v8.h"
+
+
+namespace tns {
+
+#define NODE_BINDING_CONTEXT_AWARE_CPP(modname, regfunc, priv, flags) \
+ static tns::ns_module _module = { \
+ NODE_MODULE_VERSION, \
+ flags, \
+ nullptr, \
+ __FILE__, \
+ nullptr, \
+ (tns::addon_context_register_func)(regfunc), \
+ NODE_STRINGIFY(modname), \
+ priv, \
+ nullptr}; \
+ void _register_##modname() { node_module_register(&_module); }
+
+#define NODE_BINDING_CONTEXT_AWARE_INTERNAL(modname, regfunc) \
+ NODE_BINDING_CONTEXT_AWARE_CPP(modname, regfunc, nullptr, NM_F_INTERNAL)
+
+
+
+
+
+
+
+
+#define NODE_BINDING_PER_ISOLATE_INIT(modname, per_isolate_func) \
+ void _register_isolate_##modname(v8::Isolate* isolate, \
+ v8::Local<v8::FunctionTemplate> target) { \
+ per_isolate_func(isolate, target); \
+ }
+
+
+// This is a helepr that gives the target as an ObjectTemplate (using target.PrototypeTemplate())
+
+#define NODE_BINDING_PER_ISOLATE_INIT_OBJ(modname, per_isolate_func) \
+ void _register_isolate_##modname(v8::Isolate* isolate, \
+ v8::Local<v8::FunctionTemplate> target) { \
+ per_isolate_func(isolate, target->PrototypeTemplate()); \
+ }
+
+
+#define NODE_BINDINGS_WITH_PER_ISOLATE_INIT(V) \
+V(timers)
+
+enum {
+ NM_F_BUILTIN = 1 << 0, // Unused.
+ NM_F_LINKED = 1 << 1,
+ NM_F_INTERNAL = 1 << 2,
+ NM_F_DELETEME = 1 << 3,
+};
+
+typedef void (*addon_register_func)(
+ v8::Local<v8::Object> exports,
+ v8::Local<v8::Value> module,
+ void* priv);
+
+typedef void (*addon_context_register_func)(
+ v8::Local<v8::Object> exports,
+ v8::Local<v8::Value> module,
+ v8::Local<v8::Context> context,
+ void* priv);
+
+struct ns_module {
+ int nm_version;
+ unsigned int nm_flags;
+ void* nm_dso_handle;
+ const char* nm_filename;
+ tns::addon_register_func nm_register_func;
+ tns::addon_context_register_func nm_context_register_func;
+ const char* nm_modname;
+ void* nm_priv;
+ struct ns_module* nm_link;
+};
+
+namespace binding {
+void RegisterBuiltinBindings();
+void CreateInternalBindingTemplates(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> templ);
+};
+
+
+};
+
+
+#endif /* ModuleBinding_hpp */

test-app/runtime/src/main/cpp/Runtime.cpp

@@ -30,6 +30,7 @@
 #include <unistd.h>
 #include <thread>
 #include "File.h"
+#include "ModuleBinding.h"
 
 #ifdef APPLICATION_IN_DEBUG
 // #include "NetworkDomainCallbackHandlers.h"
@@ -500,6 +501,7 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
 
  auto globalFunctionTemplate = FunctionTemplate::New(isolate);
  globalFunctionTemplate->SetClassName(ArgConverter::ConvertToV8String(isolate, "NativeScriptGlobalObject"));
+ tns::binding::CreateInternalBindingTemplates(isolate, globalFunctionTemplate);
  auto globalTemplate = ObjectTemplate::New(isolate, globalFunctionTemplate);
 
  const auto readOnlyFlags = static_cast<PropertyAttribute>(PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
@@ -582,8 +584,6 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
 
  CallbackHandlers::CreateGlobalCastFunctions(isolate, globalTemplate);
 
- m_timers.Init(isolate, globalTemplate);
-
  Local<Context> context = Context::New(isolate, nullptr, globalTemplate);
 
  auto global = context->Global();

test-app/runtime/src/main/cpp/Runtime.h

@@ -94,8 +94,6 @@ class Runtime {
 
  WeakRef m_weakRef;
 
- Timers m_timers;
-
  Profiler m_profiler;
 
  MessageLoopTimer* m_loopTimer;

test-app/runtime/src/main/cpp/Timers.cpp

@@ -5,6 +5,9 @@
 #include <android/looper.h>
 #include <unistd.h>
 #include <thread>
+#include "ModuleBinding.h"
+#include "IsolateDisposer.h"
+#include "Util.h"
 
 
 /**
@@ -15,7 +18,6 @@
  * ALL changes and scheduling of a TimerTask MUST be done when locked in an isolate to ensure consistency
  */
 
-using namespace tns;
 using namespace v8;
 
 // Takes a value and transform into a positive number
@@ -43,22 +45,18 @@ static double now_ms() {
  return 1000.0 * res.tv_sec + (double) res.tv_nsec / 1e6;
 }
 
+namespace tns {
+
+
+
 
 void Timers::Init(v8::Isolate *isolate, v8::Local<v8::ObjectTemplate> &globalObjectTemplate) {
  isolate_ = isolate;
  // TODO: remove the __ns__ prefix once this is validated
- globalObjectTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__ns__setTimeout"),
- FunctionTemplate::New(isolate, SetTimeoutCallback,
- External::New(isolate, this)));
- globalObjectTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__ns__setInterval"),
- FunctionTemplate::New(isolate, SetIntervalCallback,
- External::New(isolate, this)));
- globalObjectTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__ns__clearTimeout"),
- FunctionTemplate::New(isolate, ClearTimer,
- External::New(isolate, this)));
- globalObjectTemplate->Set(ArgConverter::ConvertToV8String(isolate, "__ns__clearInterval"),
- FunctionTemplate::New(isolate, ClearTimer,
- External::New(isolate, this)));
+ SetMethod(isolate, globalObjectTemplate, "__ns__setTimeout", SetTimeoutCallback, External::New(isolate, this));
+ SetMethod(isolate, globalObjectTemplate, "__ns__setInterval", SetIntervalCallback, External::New(isolate, this));
+ SetMethod(isolate, globalObjectTemplate, "__ns__clearTimeout", ClearTimer, External::New(isolate, this));
+ SetMethod(isolate, globalObjectTemplate, "__ns__clearInterval", ClearTimer, External::New(isolate, this));
  auto res = pipe(fd_);
  assert(res != -1);
  res = fcntl(fd_[1], F_SETFL, O_NONBLOCK);
@@ -324,4 +322,14 @@ int Timers::PumpTimerLoopCallback(int fd, int events, void *data) {
  }
  thiz->bufferFull.notify_one();
  return 1;
-}
+}
+
+void Timers::InitStatic(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalObjectTemplate) {
+ auto timers = new Timers();
+ timers->Init(isolate, globalObjectTemplate);
+ registerIsolateBoundObject(isolate, timers);
+}
+
+};
+
+NODE_BINDING_PER_ISOLATE_INIT_OBJ(timers, tns::Timers::InitStatic);

test-app/runtime/src/main/cpp/Timers.h

@@ -76,6 +76,8 @@ namespace tns {
  */
  void Init(v8::Isolate *isolate, v8::Local<v8::ObjectTemplate> &globalObjectTemplate);
 
+ static void InitStatic(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalObjectTemplate);
+
  /**
  * Disposes the timers. This will clear all references and stop all thread.
  * MUST be called in the same thread Init was called