NativeScript · edusperoni · Sep 22, 2023 · Aug 30, 2023 · Aug 29, 2023 · Aug 30, 2023
diff --git a/test-app/runtime/CMakeLists.txt b/test-app/runtime/CMakeLists.txt
@@ -146,13 +146,13 @@ if (OPTIMIZED_BUILD OR OPTIMIZED_WITH_INSPECTOR_BUILD)
     set_target_properties(
             NativeScript
             PROPERTIES LINK_FLAGS -Wl,--allow-multiple-definition -Wl,--exclude-libs=ALL -Wl,--gc-sections
-            INTERFACE_INCLUDE_DIRECTORIES NATIVES_BLOB_INCLUDE_DIRECTORIES
+            INTERFACE_INCLUDE_DIRECTORIES ${NATIVES_BLOB_INCLUDE_DIRECTORIES}
     )
 else ()
     set_target_properties(
             NativeScript
             PROPERTIES LINK_FLAGS -Wl,--allow-multiple-definition
-            INTERFACE_INCLUDE_DIRECTORIES NATIVES_BLOB_INCLUDE_DIRECTORIES
+            INTERFACE_INCLUDE_DIRECTORIES ${NATIVES_BLOB_INCLUDE_DIRECTORIES}
     )
 endif ()
 

diff --git a/test-app/runtime/src/main/cpp/ArrayElementAccessor.cpp b/test-app/runtime/src/main/cpp/ArrayElementAccessor.cpp
@@ -190,7 +190,7 @@ Local<Value> ArrayElementAccessor::ConvertToJsValue(Isolate* isolate, ObjectMana
                     if (elementSignature[0] == '[') {
                         className = Util::JniClassPathToCanonicalName(elementSignature);
                     } else {
-                        className = objectManager->GetClassName(*(jobject*) value);
+                        className = env.GetClassName(*(jobject*) value);
                     }
 
                     jsValue = objectManager->CreateJSWrapper(javaObjectID, className);

diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp
@@ -162,14 +162,6 @@ jclass CallbackHandlers::ResolveClass(Isolate *isolate, const string &baseClassN
     return globalRefToGeneratedClass;
 }
 
-// Called by ExtendMethodCallback when extending a class
-string CallbackHandlers::ResolveClassName(Isolate *isolate, jclass &clazz) {
-    auto runtime = Runtime::GetRuntime(isolate);
-    auto objectManager = runtime->GetObjectManager();
-    auto className = objectManager->GetClassName(clazz);
-    return className;
-}
-
 Local<Value> CallbackHandlers::GetArrayElement(Local<Context> context, const Local<Object> &array,
                                                uint32_t index, const string &arraySignature) {
     return arrayElementAccessor.GetArrayElement(context, array, index, arraySignature);

diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.h b/test-app/runtime/src/main/cpp/CallbackHandlers.h
@@ -48,8 +48,6 @@ namespace tns {
                                    const v8::Local<v8::Object> &implementationObject,
                                    bool isInterface);
 
-        static std::string ResolveClassName(v8::Isolate *isolate, jclass &clazz);
-
         static v8::Local<v8::Value>
         GetArrayElement(v8::Local<v8::Context> context, const v8::Local<v8::Object> &array, uint32_t index,
                         const std::string &arraySignature);

diff --git a/test-app/runtime/src/main/cpp/JEnv.cpp b/test-app/runtime/src/main/cpp/JEnv.cpp
@@ -828,6 +828,10 @@ void JEnv::Init(JavaVM *jvm) {
     GET_CACHED_CLASS_METHOD_ID = env.GetStaticMethodID(RUNTIME_CLASS, "getCachedClass",
                                                        "(Ljava/lang/String;)Ljava/lang/Class;");
     assert(GET_CACHED_CLASS_METHOD_ID != nullptr);
+    jclass javaLangClass = env.FindClass("java/lang/Class");
+    assert(javaLangClass != nullptr);
+    GET_NAME_METHOD_ID = env.GetMethodID(javaLangClass, "getName", "()Ljava/lang/String;");
+    assert(GET_NAME_METHOD_ID != nullptr);
 }
 
 jclass JEnv::GetObjectClass(jobject obj) {
@@ -836,6 +840,19 @@ jclass JEnv::GetObjectClass(jobject obj) {
     return jcl;
 }
 
+std::string JEnv::GetClassName(jclass cls) {
+    JniLocalRef javaCanonicalName{CallObjectMethod(cls, GET_NAME_METHOD_ID)};
+
+    jboolean unused = JNI_FALSE;
+    const char* chars = GetStringUTFChars(jstring{javaCanonicalName}, &unused);
+    std::string className{chars};
+    ReleaseStringUTFChars(jstring{javaCanonicalName}, chars);
+
+    std::replace(className.begin(), className.end(), '.', '/');
+
+    return className;
+}
+
 jsize JEnv::GetArrayLength(jarray array) {
     jsize jsz = m_env->GetArrayLength(array);
     CheckForJavaException();
@@ -859,6 +876,7 @@ map<string, jclass> JEnv::s_classCache;
 map<string, jthrowable> JEnv::s_missingClasses;
 jclass JEnv::RUNTIME_CLASS = nullptr;
 jmethodID JEnv::GET_CACHED_CLASS_METHOD_ID = nullptr;
+jmethodID JEnv::GET_NAME_METHOD_ID = nullptr;
 
 std::pair<jmethodID, jclass>
 JEnv::GetInterfaceStaticMethodIDAndJClass(const std::string &interfaceName,

diff --git a/test-app/runtime/src/main/cpp/JEnv.h b/test-app/runtime/src/main/cpp/JEnv.h
@@ -17,6 +17,8 @@ class JEnv {
         operator JNIEnv* () const;
 
         jclass GetObjectClass(jobject obj);
+        std::string GetClassName(jclass cls);
+        std::string GetClassName(jobject obj) { return GetClassName(GetObjectClass(obj)); }
 
         jsize GetArrayLength(jarray array);
 
@@ -341,6 +343,7 @@ class JEnv {
         static jclass RUNTIME_CLASS;
 
         static jmethodID GET_CACHED_CLASS_METHOD_ID;
+        static jmethodID GET_NAME_METHOD_ID;
 
         static std::map<std::string, jclass> s_classCache;
         static std::map<std::string, jthrowable> s_missingClasses;

diff --git a/test-app/runtime/src/main/cpp/MetadataNode.cpp b/test-app/runtime/src/main/cpp/MetadataNode.cpp
@@ -1690,7 +1690,8 @@ void MetadataNode::ExtendMethodCallback(const v8::FunctionCallbackInfo<v8::Value
         uint8_t nodeType = s_metadataReader.GetNodeType(node->m_treeNode);
         bool isInterface = s_metadataReader.IsNodeTypeInterface(nodeType);
         auto clazz = CallbackHandlers::ResolveClass(isolate, baseClassName, fullClassName, implementationObject, isInterface);
-        auto fullExtendedName = CallbackHandlers::ResolveClassName(isolate, clazz);
+        JEnv env;
+        std::string fullExtendedName{env.GetClassName(clazz)};
         DEBUG_WRITE("ExtendsCallMethodHandler: extend full name %s", fullClassName.c_str());
 
         auto cachedData = GetCachedExtendedClassData(isolate, fullExtendedName);
@@ -2039,17 +2040,12 @@ void MetadataNode::EnableProfiler(bool enableProfiler) {
 }
 
 bool MetadataNode::IsJavascriptKeyword(std::string word) {
-    static set<string> keywords;
-
-    if (keywords.empty()) {
-        string kw[] { "abstract", "arguments", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "debugger", "default", "delete", "do",
-                      "double", "else", "enum", "eval", "export", "extends", "false", "final", "finally", "float", "for", "function", "goto", "if", "implements",
-                      "import", "in", "instanceof", "int", "interface", "let", "long", "native", "new", "null", "package", "private", "protected", "public", "return",
-                      "short", "static", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "typeof", "var", "void", "volatile", "while", "with", "yield"
-                    };
-
-        keywords = set<string>(kw, kw + sizeof(kw)/sizeof(kw[0]));
-    }
+    static set<string> keywords{
+        "abstract", "arguments", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "debugger", "default", "delete", "do",
+        "double", "else", "enum", "eval", "export", "extends", "false", "final", "finally", "float", "for", "function", "goto", "if", "implements",
+        "import", "in", "instanceof", "int", "interface", "let", "long", "native", "new", "null", "package", "private", "protected", "public", "return",
+        "short", "static", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "typeof", "var", "void", "volatile", "while", "with", "yield"
+    };
 
     return keywords.find(word) != keywords.end();
 }

diff --git a/test-app/runtime/src/main/cpp/NativeScriptException.cpp b/test-app/runtime/src/main/cpp/NativeScriptException.cpp
@@ -75,8 +75,7 @@ void NativeScriptException::ReThrowToJava() {
 
 
     if (!m_javaException.IsNull()) {
-        auto objectManager = Runtime::GetObjectManager(isolate);
-        auto excClassName = objectManager->GetClassName((jobject) m_javaException);
+        std::string excClassName{env.GetClassName((jobject) m_javaException)};
         if (excClassName == "com/tns/NativeScriptException") {
             ex = m_javaException;
         } else {
@@ -103,10 +102,9 @@ void NativeScriptException::ReThrowToJava() {
         if (ex == nullptr) {
             ex = static_cast<jthrowable>(env.NewObject(NATIVESCRIPTEXCEPTION_CLASS, NATIVESCRIPTEXCEPTION_JSVALUE_CTOR_ID, (jstring) msg, (jstring)stackTrace, reinterpret_cast<jlong>(m_javascriptException)));
         } else {
-            auto objectManager = Runtime::GetObjectManager(isolate);
-            auto excClassName = objectManager->GetClassName(ex);
+            std::string excClassName{env.GetClassName(ex)};
             if (excClassName != "com/tns/NativeScriptException") {
-                ex = static_cast<jthrowable>(env.NewObject(NATIVESCRIPTEXCEPTION_CLASS, NATIVESCRIPTEXCEPTION_THROWABLE_CTOR_ID, (jstring) msg, (jstring)stackTrace, ex));
+                ex = static_cast<jthrowable>(env.NewObject(NATIVESCRIPTEXCEPTION_CLASS, NATIVESCRIPTEXCEPTION_THROWABLE_WITH_STACK_CTOR_ID, (jstring) msg, (jstring)stackTrace, ex));
             }
         }
     } else if (!m_message.empty()) {
@@ -135,9 +133,12 @@ void NativeScriptException::Init() {
     NATIVESCRIPTEXCEPTION_JSVALUE_CTOR_ID = env.GetMethodID(NATIVESCRIPTEXCEPTION_CLASS, "<init>", "(Ljava/lang/String;Ljava/lang/String;J)V");
     assert(NATIVESCRIPTEXCEPTION_JSVALUE_CTOR_ID != nullptr);
 
-    NATIVESCRIPTEXCEPTION_THROWABLE_CTOR_ID = env.GetMethodID(NATIVESCRIPTEXCEPTION_CLASS, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V");
+    NATIVESCRIPTEXCEPTION_THROWABLE_CTOR_ID = env.GetMethodID(NATIVESCRIPTEXCEPTION_CLASS, "<init>", "(Ljava/lang/String;Ljava/lang/Throwable;)V");
     assert(NATIVESCRIPTEXCEPTION_THROWABLE_CTOR_ID != nullptr);
 
+    NATIVESCRIPTEXCEPTION_THROWABLE_WITH_STACK_CTOR_ID = env.GetMethodID(NATIVESCRIPTEXCEPTION_CLASS, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V");
+    assert(NATIVESCRIPTEXCEPTION_THROWABLE_WITH_STACK_CTOR_ID != nullptr);
+
     NATIVESCRIPTEXCEPTION_GET_STACK_TRACE_AS_STRING_METHOD_ID = env.GetStaticMethodID(NATIVESCRIPTEXCEPTION_CLASS, "getStackTraceAsString", "(Ljava/lang/Throwable;)Ljava/lang/String;");
     assert(NATIVESCRIPTEXCEPTION_GET_STACK_TRACE_AS_STRING_METHOD_ID != nullptr);
 
@@ -184,9 +185,8 @@ Local<Value> NativeScriptException::WrapJavaToJsException() {
     JEnv env;
 
     auto isolate = Isolate::GetCurrent();
-    auto objectManager = Runtime::GetObjectManager(isolate);
 
-    string excClassName = objectManager->GetClassName((jobject) m_javaException);
+    string excClassName{env.GetClassName((jobject) m_javaException)};
     if (excClassName == "com/tns/NativeScriptException") {
         jfieldID fieldID = env.GetFieldID(env.GetObjectClass(m_javaException), "jsValueAddress", "J");
         jlong addr = env.GetLongField(m_javaException, fieldID);
@@ -220,7 +220,7 @@ Local<Value> NativeScriptException::GetJavaExceptionFromEnv(const JniLocalRef& e
     auto nativeExceptionObject = objectManager->GetJsObjectByJavaObject(javaObjectID);
 
     if (nativeExceptionObject.IsEmpty()) {
-        string className = objectManager->GetClassName((jobject) exc);
+        string className{env.GetClassName((jobject) exc)};
         nativeExceptionObject = objectManager->CreateJSWrapper(javaObjectID, className);
     }
 
@@ -409,5 +409,6 @@ jclass NativeScriptException::THROWABLE_CLASS = nullptr;
 jclass NativeScriptException::NATIVESCRIPTEXCEPTION_CLASS = nullptr;
 jmethodID NativeScriptException::NATIVESCRIPTEXCEPTION_JSVALUE_CTOR_ID = nullptr;
 jmethodID NativeScriptException::NATIVESCRIPTEXCEPTION_THROWABLE_CTOR_ID = nullptr;
+jmethodID NativeScriptException::NATIVESCRIPTEXCEPTION_THROWABLE_WITH_STACK_CTOR_ID = nullptr;
 jmethodID NativeScriptException::NATIVESCRIPTEXCEPTION_GET_MESSAGE_METHOD_ID = nullptr;
 jmethodID NativeScriptException::NATIVESCRIPTEXCEPTION_GET_STACK_TRACE_AS_STRING_METHOD_ID = nullptr;
diff --git a/test-app/runtime/src/main/cpp/NativeScriptException.h b/test-app/runtime/src/main/cpp/NativeScriptException.h
@@ -97,6 +97,7 @@ class NativeScriptException {
         static jclass NATIVESCRIPTEXCEPTION_CLASS;
         static jmethodID NATIVESCRIPTEXCEPTION_JSVALUE_CTOR_ID;
         static jmethodID NATIVESCRIPTEXCEPTION_THROWABLE_CTOR_ID;
+        static jmethodID NATIVESCRIPTEXCEPTION_THROWABLE_WITH_STACK_CTOR_ID;
         static jmethodID NATIVESCRIPTEXCEPTION_GET_MESSAGE_METHOD_ID;
         static jmethodID NATIVESCRIPTEXCEPTION_GET_STACK_TRACE_AS_STRING_METHOD_ID;
 

diff --git a/test-app/runtime/src/main/cpp/ObjectManager.cpp b/test-app/runtime/src/main/cpp/ObjectManager.cpp
@@ -47,9 +47,6 @@ ObjectManager::ObjectManager(v8::Isolate* isolate, jobject javaRuntimeObject) :
     jclass javaLangClass = env.FindClass("java/lang/Class");
     assert(javaLangClass != nullptr);
 
-    GET_NAME_METHOD_ID = env.GetMethodID(javaLangClass, "getName", "()Ljava/lang/String;");
-    assert(GET_NAME_METHOD_ID != nullptr);
-
     Local<ObjectTemplate> tmpl = ObjectTemplate::New(m_isolate);
     tmpl->SetInternalFieldCount(static_cast<int>(MetadataNodeKeys::END));
     m_wrapperObjectTemplate.Reset(m_isolate, tmpl);
@@ -160,7 +157,7 @@ Local<Object>
 ObjectManager::CreateJSWrapperHelper(jint javaObjectID, const string &typeName, jclass clazz) {
     auto isolate = m_isolate;
 
-    auto className = (clazz != nullptr) ? GetClassName(clazz) : typeName;
+    std::string className{clazz != nullptr ? JEnv{}.GetClassName(clazz) : typeName};
 
     auto node = MetadataNode::GetOrCreate(className);
 
@@ -220,24 +217,6 @@ bool ObjectManager::CloneLink(const Local<Object> &src, const Local<Object> &des
     return success;
 }
 
-string ObjectManager::GetClassName(jobject javaObject) {
-    JEnv env;
-    JniLocalRef objectClass(env.GetObjectClass(javaObject));
-
-    return GetClassName((jclass) objectClass);
-}
-
-string ObjectManager::GetClassName(jclass clazz) {
-    JEnv env;
-    JniLocalRef javaCanonicalName(env.CallObjectMethod(clazz, GET_NAME_METHOD_ID));
-
-    string className = ArgConverter::jstringToString(javaCanonicalName);
-
-    std::replace(className.begin(), className.end(), '.', '/');
-
-    return className;
-}
-
 void ObjectManager::JSObjectFinalizerStatic(const WeakCallbackInfo<ObjectWeakCallbackState> &data) {
     ObjectWeakCallbackState *callbackState = data.GetParameter();
 

diff --git a/test-app/runtime/src/main/cpp/ObjectManager.h b/test-app/runtime/src/main/cpp/ObjectManager.h
@@ -33,10 +33,6 @@ class ObjectManager {
 
         bool CloneLink(const v8::Local<v8::Object>& src, const v8::Local<v8::Object>& dest);
 
-        std::string GetClassName(jobject javaObject);
-
-        std::string GetClassName(jclass clazz);
-
         jint GenerateNewObjectID();
 
         v8::Local<v8::Object> GetEmptyObject(v8::Isolate* isolate);
@@ -98,8 +94,6 @@ class ObjectManager {
 
         volatile jint m_currentObjectId;
 
-        jmethodID GET_NAME_METHOD_ID;
-
         jmethodID GET_JAVAOBJECT_BY_ID_METHOD_ID;
 
         jmethodID GET_OR_CREATE_JAVA_OBJECT_ID_METHOD_ID;

diff --git a/test-app/runtime/src/main/cpp/Runtime.cpp b/test-app/runtime/src/main/cpp/Runtime.cpp
@@ -177,6 +177,7 @@ void Runtime::Init(JNIEnv* _env, jobject obj, int runtimeId, jstring filesPath,
 
 void Runtime::Init(JNIEnv* env, jstring filesPath, jstring nativeLibDir, bool verboseLoggingEnabled, bool isDebuggable, jstring packageName, jobjectArray args, jstring callingDir, int maxLogcatObjectSize, bool forceLog) {
     LogEnabled = verboseLoggingEnabled;
+    NativeScriptException::Init();
 
     auto filesRoot = ArgConverter::jstringToString(filesPath);
     auto nativeLibDirStr = ArgConverter::jstringToString(nativeLibDir);
@@ -196,7 +197,6 @@ void Runtime::Init(JNIEnv* env, jstring filesPath, jstring nativeLibDir, bool ve
 
     auto profilerOutputDirStr = ArgConverter::jstringToString(profilerOutputDir);
 
-    NativeScriptException::Init();
     m_isolate = PrepareV8Runtime(filesRoot, nativeLibDirStr, packageNameStr, isDebuggable, callingDirStr, profilerOutputDirStr, maxLogcatObjectSize, forceLog);
 }
 
@@ -335,7 +335,8 @@ void Runtime::CreateJSInstanceNative(jobject obj, jobject javaObject, jint javaO
     Local<Object> jsInstance;
     Local<Object> implementationObject;
 
-    auto proxyClassName = m_objectManager->GetClassName(javaObject);
+    JEnv env;
+    std::string proxyClassName{env.GetClassName(javaObject)};
     DEBUG_WRITE("createJSInstanceNative class %s", proxyClassName.c_str());
     jsInstance = MetadataNode::CreateExtendedJSWrapper(isolate, m_objectManager.get(), proxyClassName);
 
@@ -404,7 +405,8 @@ void Runtime::PassExceptionToJsNative(JNIEnv* env, jobject obj, jthrowable excep
     auto nativeExceptionObject = m_objectManager->GetJsObjectByJavaObject(javaObjectID);
 
     if (nativeExceptionObject.IsEmpty()) {
-        string className = m_objectManager->GetClassName((jobject) exception);
+        JEnv java{env};
+        string className{java.GetClassName((jobject) exception)};
         //create proxy object that wraps the java err
         nativeExceptionObject = m_objectManager->CreateJSWrapper(javaObjectID, className);
         if (nativeExceptionObject.IsEmpty()) {

diff --git a/test-app/runtime/src/main/java/com/tns/DexFactory.java b/test-app/runtime/src/main/java/com/tns/DexFactory.java
@@ -338,6 +338,11 @@ private void purgeDexesByThumb(String cachedDexThumb, File pathToPurge) {
                     continue;
                 }
 
+                if (!filename.endsWith(".dex") && !filename.endsWith(".jar") && !filename.endsWith(".jar.cur.prof") && !filename.endsWith(".odex")) {
+                    logger.write("Not purging unexpected file type " + purgeCandidate.getAbsolutePath());
+                    continue;
+                }
+
                 if (!purgeCandidate.delete()) {
                     logger.write("Error purging cached proxy file: " + purgeCandidate.getAbsolutePath());
                 }