Add more functions

app/src/main/assets/nodeJava.js

@@ -0,0 +1,26 @@
+(function() {
+    const $java = process._linkedBinding("java");
+    $java.constructors = {};
+    $java.prototypes = {};
+
+    $java.findClassOrNull = function (className) {
+        const cachedClass = $java.constructors[className];
+        if (typeof cachedClass !== "undefined") {
+            return cachedClass;
+        }
+
+        const classInfo = $java.getClassInfo(className);
+        if (!classInfo) {
+            return null;
+        }
+
+        return classInfo;
+    }
+
+    globalThis["$java"] = $java;
+})();
+
+$java.setUnsafeReflectionEnabled(true);
+
+const clazz = $java.findClassOrNull("com.mucheng.nodejava.core.Context");
+console.log(clazz);

app/src/main/cpp/CMakeLists.txt

@@ -28,8 +28,12 @@ add_library(${CMAKE_PROJECT_NAME} SHARED
         # List C/C++ source files with relative paths to this CMakeLists.txt.
         main.cpp
         Util.cpp
+        embedding.cpp
         Isolate.cpp
         Context.cpp
+        Locker.cpp
+        Unlocker.cpp
+        javabridge/ClassInfo.cpp
 )
 
 target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC

app/src/main/cpp/Context.cpp

@@ -3,6 +3,7 @@
 #include "Util.h"
 #include "main.h"
 #include "log.h"
+#include "embedding.h"
 #include <jni.h>
 
 Context::Context(Isolate *isolate) {
@@ -25,14 +26,14 @@ void Context::To(jobject instance, Context *self) {
 }
 
 Context *Context::From(jobject instance) {
-    return Util::GetPtrCast<Context *>(instance, "contextPtr");
+    return Util::GetPtrAs<Context *>(instance, "contextPtr");
 }
 
 extern "C"
 JNIEXPORT void JNICALL
 Java_com_mucheng_nodejava_core_Context_nativeCreateContext(JNIEnv *env, jobject thiz,
                                                            jlong isolatePtr) {
-    Isolate *isolate = Util::Cast<Isolate *>(isolatePtr);
+    Isolate *isolate = Util::As<Isolate *>(isolatePtr);
     Context *context = new Context(isolate);
     Context::To(thiz, context);
 }
@@ -154,4 +155,16 @@ Java_com_mucheng_nodejava_core_Context_nativeEvaluateScript(JNIEnv *env, jobject
         }
         return;
     }
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_mucheng_nodejava_core_Context_nativeInjectJavaBridge(JNIEnv *env, jobject thiz) {
+    Context *context = Context::From(thiz);
+    AddLinkedBinding(
+            context->environment,
+            "java",
+            JAVA_ACCESSOR_BINDING,
+            nullptr
+    );
 }

app/src/main/cpp/Isolate.cpp

@@ -25,7 +25,7 @@ void Isolate::To(jobject instance, Isolate *self) {
 }
 
 Isolate *Isolate::From(jobject instance) {
-    return Util::GetPtrCast<Isolate *>(instance, "isolatePtr");
+    return Util::GetPtrAs<Isolate *>(instance, "isolatePtr");
 }
 
 extern "C"

app/src/main/cpp/Locker.cpp

@@ -0,0 +1,60 @@
+#include "Locker.h"
+#include "Util.h"
+#include "Isolate.h"
+#include <jni.h>
+
+Locker::Locker(Isolate *isolate) {
+    this->isolate = isolate;
+
+    self = new v8::Locker(isolate->self);
+}
+
+void Locker::To(jobject instance, Locker *self) {
+    Util::SetPtr(instance, "lockerPtr", self);
+}
+
+Locker *Locker::From(jobject instance) {
+    return Util::GetPtrAs<Locker *>(instance, "lockerPtr");
+}
+
+bool Locker::isLocked(Isolate *isolate) {
+    return v8::Locker::IsLocked(isolate->self);
+}
+
+void Locker::release() {
+    delete this->self;
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_mucheng_nodejava_core_Locker_nativeCreateLocker(JNIEnv *env, jobject thiz,
+                                                         jlong isolatePtr) {
+    Isolate *isolate = Util::As<Isolate *>(isolatePtr);
+    Locker *locker = new Locker(isolate);
+    Locker::To(thiz, locker);
+}
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+Java_com_mucheng_nodejava_core_Locker_nativeIsLocked(JNIEnv *env, jclass clazz, jlong isolatePtr) {
+    Isolate *isolate = Util::As<Isolate *>(isolatePtr);
+    return Locker::isLocked(isolate);
+}
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+Java_com_mucheng_nodejava_core_Locker_nativeIsActive(JNIEnv *env, jobject thiz) {
+    return Locker::From(thiz)->self->IsActive();
+}
+
+extern "C"
+JNIEXPORT jboolean JNICALL
+Java_com_mucheng_nodejava_core_Locker_nativeWasEverUsed(JNIEnv *env, jobject thiz) {
+    return Locker::From(thiz)->self->WasEverUsed();
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_mucheng_nodejava_core_Locker_nativeRelease(JNIEnv *env, jobject thiz) {
+    Locker::From(thiz)->release();
+}

app/src/main/cpp/Locker.h

@@ -0,0 +1,29 @@
+//
+// Created by 35785 on 2024/1/25.
+//
+
+#ifndef NODEJAVA_LOCKER_H
+#define NODEJAVA_LOCKER_H
+
+#include <jni.h>
+#include <v8.h>
+#include "Isolate.h"
+
+class Locker {
+public:
+    Isolate *isolate;
+    v8::Locker *self;
+
+    Locker(Isolate *isolate);
+
+    static void To(jobject instance, Locker *self);
+
+    static Locker *From(jobject instance);
+
+    void release();
+
+    static bool isLocked(Isolate *isolate);
+};
+
+
+#endif //NODEJAVA_LOCKER_H

app/src/main/cpp/Unlocker.cpp

@@ -0,0 +1,26 @@
+#include "Unlocker.h"
+#include "Util.h"
+#include <v8.h>
+
+Unlocker::Unlocker(Isolate *isolate) {
+    this->isolate = isolate;
+
+    self = new v8::Unlocker(isolate->self);
+}
+
+void Unlocker::To(jobject instance, Unlocker *unlocker) {
+    Util::SetPtr(instance, "unlockerPtr", unlocker);
+}
+
+Unlocker *Unlocker::From(jobject instance) {
+    return Util::GetPtrAs<Unlocker *>(instance, "unlockerPtr");
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_mucheng_nodejava_core_Unlocker_nativeCreateUnlocker(JNIEnv *env, jobject thiz,
+                                                             jlong isolatePtr) {
+    Isolate *isolate = Util::As<Isolate *>(isolatePtr);
+    Unlocker *unlocker = new Unlocker(isolate);
+    Unlocker::To(thiz, unlocker);
+}

app/src/main/cpp/Unlocker.h

@@ -0,0 +1,26 @@
+//
+// Created by 35785 on 2024/1/25.
+//
+
+#ifndef NODEJAVA_UNLOCKER_H
+#define NODEJAVA_UNLOCKER_H
+#include <jni.h>
+#include <v8.h>
+#include "Isolate.h"
+
+class Unlocker {
+public:
+    Isolate *isolate;
+    v8::Unlocker *self;
+
+    Unlocker(Isolate *isolate);
+
+    static void To(jobject instance, Unlocker *unlocker);
+
+    static Unlocker *From(jobject instance);
+
+
+};
+
+
+#endif //NODEJAVA_UNLOCKER_H

app/src/main/cpp/Util.h

@@ -23,17 +23,17 @@ namespace Util {
     void ThrowNodeException(const char *message);
 
     template<typename Class>
-    inline Class Cast(long ptr) {
+    inline Class As(long ptr) {
         return reinterpret_cast<Class>(ptr);
     }
 
     template<typename Class>
-    inline Class GetPtrCast(jclass javaClass, const char *fieldName) {
+    inline Class GetPtrAs(jclass javaClass, const char *fieldName) {
         return static_cast<Class>(GetPtr(javaClass, fieldName));
     }
 
     template<typename Class>
-    inline Class GetPtrCast(jobject instance, const char *fieldName) {
+    inline Class GetPtrAs(jobject instance, const char *fieldName) {
         return static_cast<Class>(GetPtr(instance, fieldName));
     }
 

app/src/main/cpp/embedding.cpp

@@ -0,0 +1,74 @@
+#include "embedding.h"
+#include "main.h"
+#include "log.h"
+#include "javabridge/ClassInfo.h"
+
+v8::Local<v8::Object> getClassInfo(
+        v8::Isolate *isolate,
+        v8::Local<v8::Context> context,
+        v8::Local<v8::String> className
+) {
+    JNIEnv *env = Main::env();
+    jclass javaBridgeUtilClass = env->FindClass("com/mucheng/nodejava/javabridge/JavaBridgeUtil");
+    jmethodID findClassOrNull = env->GetStaticMethodID(javaBridgeUtilClass, "findClassOrNull",
+                                                       "(Ljava/lang/String;)Lcom/mucheng/nodejava/javabridge/ClassInfo;");
+    jobject classInfoInstance = env->NewGlobalRef(
+            env->CallStaticObjectMethod(javaBridgeUtilClass, findClassOrNull,
+                                        env->NewStringUTF(
+                                                *v8::String::Utf8Value(isolate,
+                                                                       className))));
+
+
+    return ClassInfo::BuildObject(isolate, context, classInfoInstance);
+}
+
+void JAVA_ACCESSOR_BINDING(
+        v8::Local<v8::Object> exports,
+        v8::Local<v8::Value>,
+        v8::Local<v8::Context> context,
+        void *priv
+) {
+    v8::Isolate *isolate = context->GetIsolate();
+
+    exports->Set(
+            context,
+            v8::String::NewFromUtf8Literal(isolate, "getClassInfo"),
+            v8::Function::New(context, [](const v8::FunctionCallbackInfo<v8::Value> &info) {
+                SETUP_CALLBACK_INFO();
+                info.GetReturnValue().Set(getClassInfo(isolate, context, info[0].As<v8::String>()));
+            }).ToLocalChecked()
+    ).Check();
+
+    exports->Set(
+            context,
+            v8::String::NewFromUtf8Literal(isolate, "setUnsafeReflectionEnabled"),
+            v8::Function::New(context, [](const v8::FunctionCallbackInfo<v8::Value> &info) {
+                SETUP_CALLBACK_INFO();
+                JNIEnv *env = Main::env();
+                jclass javaBridgeUtilClass = env->FindClass(
+                        "com/mucheng/nodejava/javabridge/JavaBridgeUtil");
+                jfieldID unsafeReflectionEnabledField = env->GetStaticFieldID(javaBridgeUtilClass,
+                                                                              "unsafeReflectionEnabled",
+                                                                              "Z");
+                env->SetStaticBooleanField(javaBridgeUtilClass, unsafeReflectionEnabledField,
+                                           info[0].As<v8::Boolean>()->Value());
+            }).ToLocalChecked()
+    ).Check();
+
+    exports->Set(
+            context,
+            v8::String::NewFromUtf8Literal(isolate, "isUnsafeReflectionEnabled"),
+            v8::Function::New(context, [](const v8::FunctionCallbackInfo<v8::Value> &info) {
+                SETUP_CALLBACK_INFO();
+                JNIEnv *env = Main::env();
+                jclass javaBridgeUtilClass = env->FindClass(
+                        "com/mucheng/nodejava/javabridge/JavaBridgeUtil");
+                jfieldID unsafeReflectionEnabledField = env->GetStaticFieldID(javaBridgeUtilClass,
+                                                                              "unsafeReflectionEnabled",
+                                                                              "Z");
+                info.GetReturnValue().Set(env->GetStaticBooleanField(javaBridgeUtilClass,
+                                                                     unsafeReflectionEnabledField));
+            }).ToLocalChecked()
+    ).Check();
+
+}

app/src/main/cpp/embedding.h

@@ -0,0 +1,17 @@
+#ifndef NODEJAVA_EMBEDDING_H
+#define NODEJAVA_EMBEDDING_H
+
+#include <node.h>
+#include <v8.h>
+
+#define SETUP_CALLBACK_INFO() v8::Isolate *isolate = info.GetIsolate(); \
+v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+void JAVA_ACCESSOR_BINDING(
+        v8::Local<v8::Object> exports,
+        v8::Local<v8::Value> module,
+        v8::Local<v8::Context> context,
+        void *priv
+);
+
+#endif //NODEJAVA_EMBEDDING_H

app/src/main/cpp/include/node/nan_object_wrap.h

@@ -30,7 +30,7 @@ class ObjectWrap {
   static inline T* Unwrap(v8::Local<v8::Object> object) {
     assert(!object.IsEmpty());
     assert(object->InternalFieldCount() > 0);
-    // Cast to ObjectWrap before casting to T.  A direct cast from void
+    // As to ObjectWrap before casting to T.  A direct cast from void
     // to T won't work right when T has more than one base class.
     void* ptr = GetInternalFieldPointer(object, 0);
     ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);

app/src/main/cpp/include/node/nan_persistent_pre_12_inl.h

@@ -225,7 +225,7 @@ class Global : public PersistentBase<T> {
     return *this;
   }
   /**
-   * Cast operator for moves.
+   * As operator for moves.
    */
   inline operator RValue() { return RValue(this); }
   /**

app/src/main/cpp/include/node/node_object_wrap.h

@@ -47,7 +47,7 @@ class ObjectWrap {
   static inline T* Unwrap(v8::Local<v8::Object> handle) {
     assert(!handle.IsEmpty());
     assert(handle->InternalFieldCount() > 0);
-    // Cast to ObjectWrap before casting to T.  A direct cast from void
+    // As to ObjectWrap before casting to T.  A direct cast from void
     // to T won't work right when T has more than one base class.
     void* ptr = handle->GetAlignedPointerFromInternalField(0);
     ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);

app/src/main/cpp/include/node/v8-fast-api-calls.h

@@ -83,7 +83,7 @@
  *      static void SlowMethod(
  *          const v8::FunctionCallbackInfo<v8::Value>& info) {
  *        v8::Local<v8::Object> instance =
- *          v8::Local<v8::Object>::Cast(info.Holder());
+ *          v8::Local<v8::Object>::As(info.Holder());
  *        CustomEmbedderType* receiver = Unwrap(instance);
  *        // TODO: Do type checks and extract {param}.
  *        receiver->Method(param);

app/src/main/cpp/include/node/v8-internal.h

@@ -623,7 +623,7 @@ class Internals {
 };
 
 // Only perform cast check for types derived from v8::Data since
-// other types do not implement the Cast method.
+// other types do not implement the As method.
 template <bool PerformCheck>
 struct CastCheck {
   template <class T>