From 875479891a9cb62d0659404f2cc23d433f5eacf3 Mon Sep 17 00:00:00 2001 From: Joseph <7348910+dig@users.noreply.github.com> Date: Sat, 28 Dec 2019 22:27:35 +0000 Subject: [PATCH 01/85] Update README.md --- README.md | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 0643b75..6105d83 100644 --- a/README.md +++ b/README.md @@ -8,15 +8,10 @@ Authors: JanHolger, Digital ### Download Check out Releases for a download to Windows & Linux builds. -### Issues -If you have the following error in console while loading our Java plugin, -``` -[2019-12-27 20:01:37] [info] Loading plugin "OnsetJavaPlugin" -[2019-12-27 20:01:37] [error] Failed loading "OnsetJavaPlugin": The specified module could not be found. -``` -This is typically an issue with Windows users. To fix this, add your Java 8 bin/server folder to your PATH configuration. Example of JDK (or JRE) path: -```C:\Program Files\Java\jdk1.8.0_221\jre\bin\server``` -Make sure your Java installation is 64 bit otherwise it won't have the required JNI libraries we use. +### Installation +1. Download OnsetJavaPlugin.dll (Windows) & OnsetJavaPlugin.so (Linux) from Releases ([HERE](https://github.com/OnfireNetwork/OnsetJavaPlugin/releases)) and place inside plugins folder. +1. Ensure Java 8 JDK/JRE 64bit is installed. +1. Enable "OnsetJavaPlugin" as a plugin inside server_config.json. ### Data Types we support #### Method Parameters From d996e0a498e383a59f8b22598de8753a0b6276b5 Mon Sep 17 00:00:00 2001 From: Joseph Date: Sat, 28 Dec 2019 23:02:53 +0000 Subject: [PATCH 02/85] Support JRE and JDK --- src/Plugin.cpp | 37 ++++++++++++++++++++++++------------- 1 file changed, 24 insertions(+), 13 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index b65e134..8eee60f 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -21,29 +21,37 @@ int Plugin::CreateJava(std::string classPath) { int id = 0; - while (this->jvms[id] != nullptr){ + while (this->jvms[id] != nullptr) id++; - } #ifdef _WIN32 - char inputPathDll[] = "%JAVA_HOME%\\jre\\bin\\server\\jvm.dll"; - TCHAR outputPathDll[32000]; - DWORD result = ExpandEnvironmentStrings((LPCTSTR)inputPathDll, outputPathDll, sizeof(outputPathDll) / sizeof(*outputPathDll)); - if (!result) { - Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed. Exiting..."); - return 1; + char inputJdkDll[] = "%JAVA_HOME%\\jre\\bin\\server\\jvm.dll"; + TCHAR outputJdkDll[32000]; + DWORD jdkResult = ExpandEnvironmentStrings((LPCTSTR)inputJdkDll, outputJdkDll, sizeof(outputJdkDll) / sizeof(*outputJdkDll)); + + char inputJreDll[] = "%JAVA_HOME%\\bin\\server\\jvm.dll"; + TCHAR outputJreDll[32000]; + DWORD jreResult = ExpandEnvironmentStrings((LPCTSTR)inputJreDll, outputJreDll, sizeof(outputJreDll) / sizeof(*outputJreDll)); + + if (!jdkResult && !jreResult) { + Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); + return -1; } - HINSTANCE jvmDLL = LoadLibrary(outputPathDll); + HINSTANCE jvmDLL = LoadLibrary(outputJdkDll); if (!jvmDLL) { - Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed. Exiting..."); - return 1; + jvmDLL = LoadLibrary(outputJreDll); + + if (!jvmDLL) { + Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); + return -1; + } } JVMDLLFunction createJavaVMFunction = (JVMDLLFunction)GetProcAddress(jvmDLL, "JNI_CreateJavaVM"); if (!createJavaVMFunction) { - Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed. Exiting..."); - return 1; + Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); + return -1; } #endif @@ -231,6 +239,8 @@ Plugin::Plugin() std::string classPath; Lua::ParseArguments(L, classPath); int id = Plugin::Get()->CreateJava(classPath); + + if (id < 0) return 0; return Lua::ReturnValues(L, id); }); @@ -239,6 +249,7 @@ Plugin::Plugin() int id; Lua::ParseArguments(L, id); Plugin::Get()->DestroyJava(id); + return 1; }); From 8fbc0c6b4da0fc46e80e06c0f84aad7f2ba84eec Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 29 Dec 2019 14:35:05 +0100 Subject: [PATCH 03/85] Splitted the code up to make it more readable --- src/JavaEnv.cpp | 269 +++++++++++++++++++++++++++++++++++++++++++ src/JavaEnv.hpp | 27 +++++ src/Plugin.cpp | 300 ++++-------------------------------------------- src/Plugin.hpp | 11 +- 4 files changed, 325 insertions(+), 282 deletions(-) create mode 100644 src/JavaEnv.cpp create mode 100644 src/JavaEnv.hpp diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp new file mode 100644 index 0000000..b10f48e --- /dev/null +++ b/src/JavaEnv.cpp @@ -0,0 +1,269 @@ +#include "JavaEnv.hpp" + +#ifdef _WIN32 +#include +typedef UINT(CALLBACK* JVMDLLFunction)(JavaVM**, void**, JavaVMInitArgs*); +#endif + +#include +#include +#include +#include + +JavaEnv::JavaEnv(std::string classPath) { + this->env = nullptr; + this->vm = nullptr; + #ifdef _WIN32 + char inputJdkDll[] = "%JAVA_HOME%\\jre\\bin\\server\\jvm.dll"; + TCHAR outputJdkDll[32000]; + DWORD jdkResult = ExpandEnvironmentStrings((LPCTSTR)inputJdkDll, outputJdkDll, sizeof(outputJdkDll) / sizeof(*outputJdkDll)); + char inputJreDll[] = "%JAVA_HOME%\\bin\\server\\jvm.dll"; + TCHAR outputJreDll[32000]; + DWORD jreResult = ExpandEnvironmentStrings((LPCTSTR)inputJreDll, outputJreDll, sizeof(outputJreDll) / sizeof(*outputJreDll)); + if (!jdkResult && !jreResult) { + Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); + return; + } + HINSTANCE jvmDLL = LoadLibrary(outputJdkDll); + if (!jvmDLL) { + jvmDLL = LoadLibrary(outputJreDll); + + if (!jvmDLL) { + Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); + return; + } + } + JVMDLLFunction createJavaVMFunction = (JVMDLLFunction)GetProcAddress(jvmDLL, "JNI_CreateJavaVM"); + if (!createJavaVMFunction) { + Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); + return; + } + #endif + + static std::stringstream optionString; + optionString << "-Djava.class.path=" << classPath; + + JavaVMInitArgs vm_args; + auto* options = new JavaVMOption[1]; + char cpoptionString[200] = ""; + std::strcpy(cpoptionString, optionString.str().c_str()); + + options[0].optionString = cpoptionString; + vm_args.version = JNI_VERSION_1_8; + vm_args.nOptions = 1; + vm_args.options = options; + vm_args.ignoreUnrecognized = false; + + #ifdef __linux__ + JNI_CreateJavaVM(&this->vm, (void**)&this->env, &vm_args); + #elif _WIN32 + createJavaVMFunction(&this->vm, (void**)&this->env, &vm_args); + #endif +} + +jobject JavaEnv::ToJavaObject(Lua::LuaValue value) +{ + JNIEnv* jenv = this->GetEnv(); + switch (value.GetType()) + { + case Lua::LuaValue::Type::STRING: + { + return (jobject)jenv->NewStringUTF(value.GetValue().c_str()); + } break; + case Lua::LuaValue::Type::INTEGER: + { + jclass jcls = jenv->FindClass("java/lang/Integer"); + return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); + } break; + case Lua::LuaValue::Type::BOOLEAN: + { + jclass jcls = jenv->FindClass("java/lang/Boolean"); + return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); + } break; + case Lua::LuaValue::Type::TABLE: + { + jclass jcls = jenv->FindClass("java/util/HashMap"); + jobject jmap = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "()V")); + jmethodID putMethod = jenv->GetMethodID(jcls, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); + + Lua::LuaTable_t table = value.GetValue(); + table->ForEach([jenv, this, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { + jenv->CallObjectMethod(jmap, putMethod, this->ToJavaObject(k), this->ToJavaObject(v)); + }); + + return jmap; + } break; + case Lua::LuaValue::Type::NIL: + case Lua::LuaValue::Type::INVALID: + break; + default: + break; + } + + return NULL; +} + +Lua::LuaValue JavaEnv::ToLuaValue(jobject object) +{ + JNIEnv* jenv = this->GetEnv(); + jclass jcls = jenv->GetObjectClass(object); + + if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/String"))) { + jstring element = (jstring)object; + const char* pchars = jenv->GetStringUTFChars(element, nullptr); + + Lua::LuaValue value(pchars); + + jenv->ReleaseStringUTFChars(element, pchars); + jenv->DeleteLocalRef(element); + + return value; + } + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Integer"))) { + jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); + jint result = jenv->CallIntMethod(object, intValueMethod); + + Lua::LuaValue value(result); + return value; + } + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { + jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); + jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); + + Lua::LuaValue value(result); + return value; + } + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/List"))) { + jmethodID sizeMethod = jenv->GetMethodID(jcls, "size", "()I"); + jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(I)Ljava/lang/Object;"); + jint len = jenv->CallIntMethod(object, sizeMethod); + + Lua::LuaTable_t table(new Lua::LuaTable); + for (jint i = 0; i < len; i++) { + jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); + table->Add(i + 1, this->ToLuaValue(arrayElement)); + } + + Lua::LuaValue value(table); + return value; + } + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/Map"))) { + jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(Ljava/lang/Object;)Ljava/lang/Object;"); + + jmethodID keySetMethod = jenv->GetMethodID(jcls, "keySet", "()Ljava/util/Set;"); + jobject keySet = jenv->CallObjectMethod(object, keySetMethod); + + jmethodID keySetToArrayMethod = jenv->GetMethodID(jenv->GetObjectClass(keySet), "toArray", "()[Ljava/lang/Object;"); + jobjectArray keyArray = (jobjectArray)jenv->CallObjectMethod(keySet, keySetToArrayMethod); + int arraySize = jenv->GetArrayLength(keyArray); + + Lua::LuaTable_t table(new Lua::LuaTable); + for (int i = 0; i < arraySize; i++) + { + jobject key = jenv->GetObjectArrayElement(keyArray, i); + jobject value = jenv->CallObjectMethod(object, getMethod, key); + + table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); + } + + Lua::LuaValue value(table); + return value; + } + + return NULL; +} + +jobject JavaEnv::CallStatic(std::string className, std::string methodName, std::string signature, jobject* params) { + size_t paramsLength = sizeof(params); + if (paramsLength > 0) { + paramsLength = paramsLength / sizeof(params[0]); + } + size_t spos = signature.find(")"); + std::string returnSignature = signature.substr(spos + 1, signature.length() - spos); + jclass clazz = this->env->FindClass(className.c_str()); + if (clazz == nullptr) return 0; + jmethodID methodID = this->env->GetStaticMethodID(clazz, methodName.c_str(), signature.c_str()); + if (methodID == nullptr) return 0; + jobject returnValue = NULL; + if (!returnSignature.compare("V")) { + switch (paramsLength) { + case 0: + this->env->CallStaticVoidMethod(clazz, methodID); + break; + case 1: + this->env->CallStaticVoidMethod(clazz, methodID, params[0]); + break; + case 2: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1]); + break; + case 3: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2]); + break; + case 4: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3]); + break; + case 5: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4]); + break; + case 6: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5]); + break; + case 7: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6]); + break; + case 8: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7]); + break; + case 9: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8]); + break; + case 10: + this->env->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9]); + break; + default: + Onset::Plugin::Get()->Log("Too many parameters for CallJavaStaticMethod, 10 max."); + break; + } + } + else { + switch (paramsLength) { + case 0: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID); + break; + case 1: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0]); + break; + case 2: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1]); + break; + case 3: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2]); + break; + case 4: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3]); + break; + case 5: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4]); + break; + case 6: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5]); + break; + case 7: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6]); + break; + case 8: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7]); + break; + case 9: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8]); + break; + case 10: + returnValue = this->env->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9]); + break; + default: + Onset::Plugin::Get()->Log("Too many parameters for CallJavaStaticMethod, 10 max."); + break; + } + } + return returnValue; +} \ No newline at end of file diff --git a/src/JavaEnv.hpp b/src/JavaEnv.hpp new file mode 100644 index 0000000..7142c12 --- /dev/null +++ b/src/JavaEnv.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include +#include +#include + +class JavaEnv +{ +private: + JavaVM* vm; + JNIEnv* env; +public: + JavaEnv(std::string classPath); + void Destroy() { + this->vm->DestroyJavaVM(); + } + JavaVM* GetVM() { + return this->vm; + } + JNIEnv* GetEnv() { + return this->env; + } + Lua::LuaValue ToLuaValue(jobject object); + jobject ToJavaObject(Lua::LuaValue value); + jobject CallStatic(std::string className, std::string methodName, std::string signature, jobject* params); +}; + diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 8eee60f..7d49e98 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -21,191 +21,41 @@ int Plugin::CreateJava(std::string classPath) { int id = 0; - while (this->jvms[id] != nullptr) + while (this->jenvs[id] != nullptr) id++; - - #ifdef _WIN32 - char inputJdkDll[] = "%JAVA_HOME%\\jre\\bin\\server\\jvm.dll"; - TCHAR outputJdkDll[32000]; - DWORD jdkResult = ExpandEnvironmentStrings((LPCTSTR)inputJdkDll, outputJdkDll, sizeof(outputJdkDll) / sizeof(*outputJdkDll)); - - char inputJreDll[] = "%JAVA_HOME%\\bin\\server\\jvm.dll"; - TCHAR outputJreDll[32000]; - DWORD jreResult = ExpandEnvironmentStrings((LPCTSTR)inputJreDll, outputJreDll, sizeof(outputJreDll) / sizeof(*outputJreDll)); - - if (!jdkResult && !jreResult) { - Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); - return -1; - } - - HINSTANCE jvmDLL = LoadLibrary(outputJdkDll); - if (!jvmDLL) { - jvmDLL = LoadLibrary(outputJreDll); - - if (!jvmDLL) { - Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); - return -1; - } - } - - JVMDLLFunction createJavaVMFunction = (JVMDLLFunction)GetProcAddress(jvmDLL, "JNI_CreateJavaVM"); - if (!createJavaVMFunction) { - Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); - return -1; - } - #endif - - static std::stringstream optionString; - optionString << "-Djava.class.path=" << classPath; - - JavaVMInitArgs vm_args; - auto* options = new JavaVMOption[1]; - char cpoptionString[200] = ""; - std::strcpy(cpoptionString, optionString.str().c_str()); - - options[0].optionString = cpoptionString; - vm_args.version = JNI_VERSION_1_8; - vm_args.nOptions = 1; - vm_args.options = options; - vm_args.ignoreUnrecognized = false; - - #ifdef __linux__ - JNI_CreateJavaVM(&this->jvms[id], (void**)&this->jenvs[id], &vm_args); - #elif _WIN32 - createJavaVMFunction(&this->jvms[id], (void**)&this->jenvs[id], &vm_args); - #endif - + this->jenvs[id] = new JavaEnv(classPath); return id + 1; } void Plugin::DestroyJava(int id) { - this->jvms[id - 1]->DestroyJavaVM(); - this->jvms[id - 1] = nullptr; + this->jenvs[id - 1]->Destroy(); this->jenvs[id - 1] = nullptr; } -JavaVM* Plugin::GetJavaVM(int id) -{ - return this->jvms[id - 1]; -} - -JNIEnv* Plugin::GetJavaEnv(int id) +JavaEnv* Plugin::GetJavaEnv(int id) { return this->jenvs[id - 1]; } -jobject Plugin::ToJavaObject(JNIEnv* jenv, Lua::LuaValue value) -{ - switch (value.GetType()) - { - case Lua::LuaValue::Type::STRING: - { - return (jobject)jenv->NewStringUTF(value.GetValue().c_str()); - } break; - case Lua::LuaValue::Type::INTEGER: - { - jclass jcls = jenv->FindClass("java/lang/Integer"); - return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); - } break; - case Lua::LuaValue::Type::BOOLEAN: - { - jclass jcls = jenv->FindClass("java/lang/Boolean"); - return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); - } break; - case Lua::LuaValue::Type::TABLE: - { - jclass jcls = jenv->FindClass("java/util/HashMap"); - jobject jmap = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "()V")); - jmethodID putMethod = jenv->GetMethodID(jcls, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); - - Lua::LuaTable_t table = value.GetValue(); - table->ForEach([jenv, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { - jenv->CallObjectMethod(jmap, putMethod, Plugin::Get()->ToJavaObject(jenv, k), Plugin::Get()->ToJavaObject(jenv, v)); - }); - - return jmap; - } break; - case Lua::LuaValue::Type::NIL: - case Lua::LuaValue::Type::INVALID: - break; - default: - break; - } - - return NULL; -} - -Lua::LuaValue Plugin::ToLuaValue(JNIEnv* jenv, jobject object) -{ - jclass jcls = jenv->GetObjectClass(object); - - if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/String"))) { - jstring element = (jstring)object; - const char* pchars = jenv->GetStringUTFChars(element, nullptr); - - Lua::LuaValue value(pchars); - - jenv->ReleaseStringUTFChars(element, pchars); - jenv->DeleteLocalRef(element); - - return value; - } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Integer"))) { - jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); - jint result = jenv->CallIntMethod(object, intValueMethod); - - Lua::LuaValue value(result); - return value; - } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { - jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); - jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - - Lua::LuaValue value(result); - return value; - } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/List"))) { - jmethodID sizeMethod = jenv->GetMethodID(jcls, "size", "()I"); - jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(I)Ljava/lang/Object;"); - jint len = jenv->CallIntMethod(object, sizeMethod); - - Lua::LuaTable_t table(new Lua::LuaTable); - for (jint i = 0; i < len; i++) { - jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); - table->Add(i + 1, Plugin::Get()->ToLuaValue(jenv, arrayElement)); - } - - Lua::LuaValue value(table); - return value; - } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/Map"))) { - jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(Ljava/lang/Object;)Ljava/lang/Object;"); - - jmethodID keySetMethod = jenv->GetMethodID(jcls, "keySet", "()Ljava/util/Set;"); - jobject keySet = jenv->CallObjectMethod(object, keySetMethod); - - jmethodID keySetToArrayMethod = jenv->GetMethodID(jenv->GetObjectClass(keySet), "toArray", "()[Ljava/lang/Object;"); - jobjectArray keyArray = (jobjectArray)jenv->CallObjectMethod(keySet, keySetToArrayMethod); - int arraySize = jenv->GetArrayLength(keyArray); - - Lua::LuaTable_t table(new Lua::LuaTable); - for (int i = 0; i < arraySize; i++) - { - jobject key = jenv->GetObjectArrayElement(keyArray, i); - jobject value = jenv->CallObjectMethod(object, getMethod, key); - - table->Add(Plugin::Get()->ToLuaValue(jenv, key), Plugin::Get()->ToLuaValue(jenv, value)); +JavaEnv* Plugin::FindJavaEnv(JNIEnv* jenv) { + int i; + for (i = 0; i < 30; i++) { + if (this->jenvs[i] != nullptr) { + if (this->jenvs[i]->GetEnv() == jenv) { + return this->jenvs[i]; + } } - - Lua::LuaValue value(table); - return value; } - - return NULL; + return nullptr; } void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobject argsList) { + JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); + if (env == nullptr) { + return; + } + (void) jcl; const char* eventStr = jenv->GetStringUTFChars(event, nullptr); @@ -219,7 +69,7 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobject argsList) { for (jint i = 0; i < len; i++) { jobject arrayElement = jenv->CallObjectMethod(argsList, getMethod, i); - args->push_back(Plugin::Get()->ToLuaValue(jenv, arrayElement)); + args->push_back(env->ToLuaValue(arrayElement)); } } @@ -232,14 +82,13 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobject argsList) { Plugin::Plugin() { for (int i = 0; i < 30; i++) - this->jvms[i] = nullptr; + this->jenvs[i] = nullptr; LUA_DEFINE(CreateJava) { std::string classPath; Lua::ParseArguments(L, classPath); int id = Plugin::Get()->CreateJava(classPath); - if (id < 0) return 0; return Lua::ReturnValues(L, id); }); @@ -249,7 +98,6 @@ Plugin::Plugin() int id; Lua::ParseArguments(L, id); Plugin::Get()->DestroyJava(id); - return 1; }); @@ -257,10 +105,8 @@ Plugin::Plugin() { int id; Lua::ParseArguments(L, id); - if (!Plugin::Get()->GetJavaEnv(id)) return 0; - JNIEnv* jenv = Plugin::Get()->GetJavaEnv(id); - + JNIEnv* jenv = Plugin::Get()->GetJavaEnv(id)->GetEnv(); Lua::LuaArgs_t arg_list; Lua::ParseArguments(L, arg_list); @@ -270,13 +116,10 @@ Plugin::Plugin() std::string className = arg_list[1].GetValue(); jclass clazz = jenv->FindClass(className.c_str()); if (clazz == nullptr) return 0; - JNINativeMethod methods[] = { {(char*)"callEvent", (char*)"(Ljava/lang/String;Ljava/util/List;)V", (void*)CallEvent }, }; - jenv->RegisterNatives(clazz, methods, 1); - Lua::ReturnValues(L, 1); return 1; }); @@ -287,7 +130,7 @@ Plugin::Plugin() Lua::ParseArguments(L, id); if (!Plugin::Get()->GetJavaEnv(id)) return 0; - JNIEnv* jenv = Plugin::Get()->GetJavaEnv(id); + JavaEnv* env = Plugin::Get()->GetJavaEnv(id); Lua::LuaArgs_t arg_list; Lua::ParseArguments(L, arg_list); @@ -297,108 +140,16 @@ Plugin::Plugin() std::string className = arg_list[1].GetValue(); std::string methodName = arg_list[2].GetValue(); - std::string signature = arg_list[3].GetValue(); - size_t spos = signature.find(")"); - std::string returnSignature = signature.substr(spos + 1, signature.length() - spos); - jobject* params = new jobject[arg_size - 4]; for (int i = 4; i < arg_size; i++) { auto const& value = arg_list[i]; - params[i - 4] = Plugin::Get()->ToJavaObject(jenv, value); + params[i - 4] = env->ToJavaObject(value); } - jclass clazz = jenv->FindClass(className.c_str()); - if (clazz == nullptr) return 0; - - jmethodID methodID = jenv->GetStaticMethodID(clazz, methodName.c_str(), signature.c_str()); - if (methodID == nullptr) return 0; - - jobject returnValue = nullptr; - if (!returnSignature.compare("V")) { - switch (arg_size - 4) { - case 0: - jenv->CallStaticVoidMethod(clazz, methodID); - break; - case 1: - jenv->CallStaticVoidMethod(clazz, methodID, params[0]); - break; - case 2: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1]); - break; - case 3: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2]); - break; - case 4: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3]); - break; - case 5: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4]); - break; - case 6: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5]); - break; - case 7: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6]); - break; - case 8: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7]); - break; - case 9: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8]); - break; - case 10: - jenv->CallStaticVoidMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9]); - break; - default: - Onset::Plugin::Get()->Log("Too many parameters for CallJavaStaticMethod, 10 max."); - break; - } - } - else { - switch (arg_size - 4) { - case 0: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID); - break; - case 1: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0]); - break; - case 2: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1]); - break; - case 3: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2]); - break; - case 4: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3]); - break; - case 5: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4]); - break; - case 6: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5]); - break; - case 7: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6]); - break; - case 8: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7]); - break; - case 9: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8]); - break; - case 10: - returnValue = jenv->CallStaticObjectMethod(clazz, methodID, params[0], params[1], params[2], params[3], params[4], params[5], params[6], params[7], params[8], params[9]); - break; - default: - Onset::Plugin::Get()->Log("Too many parameters for CallJavaStaticMethod, 10 max."); - break; - } - } - - if (returnValue != nullptr) { - Lua::LuaValue value = Plugin::Get()->ToLuaValue(jenv, returnValue); - + jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params); + if (returnValue != NULL) { + Lua::LuaValue value = env->ToLuaValue(returnValue); if (!(value == NULL)) { switch (value.GetType()) { @@ -422,7 +173,6 @@ Plugin::Plugin() else { Lua::ReturnValues(L, 1); } - return 1; }); } diff --git a/src/Plugin.hpp b/src/Plugin.hpp index 8ff1324..8ad127e 100644 --- a/src/Plugin.hpp +++ b/src/Plugin.hpp @@ -6,6 +6,7 @@ #include #include #include "Singleton.hpp" +#include "JavaEnv.hpp" class Plugin : public Singleton { @@ -13,8 +14,7 @@ class Plugin : public Singleton private: Plugin(); ~Plugin() = default; - JavaVM *jvms[30]; - JNIEnv* jenvs[30]; + JavaEnv* jenvs[30]; private: using FuncInfo_t = std::tuple; @@ -33,9 +33,6 @@ class Plugin : public Singleton } int CreateJava(std::string classPath); void DestroyJava(int id); - JavaVM* GetJavaVM(int id); - JNIEnv* GetJavaEnv(int id); - - jobject ToJavaObject(JNIEnv* jenv, Lua::LuaValue value); - Lua::LuaValue ToLuaValue(JNIEnv* jenv, jobject object); + JavaEnv* GetJavaEnv(int id); + JavaEnv* FindJavaEnv(JNIEnv* jenv); }; From 531aff6a53f1d15ac49069ed583aa8115f7f196c Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 29 Dec 2019 14:36:06 +0100 Subject: [PATCH 04/85] Fixed CMakeList --- src/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 4d1242f..ebe060b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -7,6 +7,8 @@ configure_file( ) add_library(OnsetJavaPlugin MODULE + JavaEnv.cpp + JavaEnv.hpp Plugin.cpp Plugin.hpp PluginInterface.cpp From 15fab9af0f4477bab6a2b4ba56c8c9dfd476e10f Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 29 Dec 2019 14:39:44 +0100 Subject: [PATCH 05/85] Fixed linux issue --- src/JavaEnv.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/JavaEnv.hpp b/src/JavaEnv.hpp index 7142c12..82b0c20 100644 --- a/src/JavaEnv.hpp +++ b/src/JavaEnv.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #include From 6ab3f37bce5cba5d678a22efe48b04cf63cc7196 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 29 Dec 2019 19:12:49 +0100 Subject: [PATCH 06/85] Fixed several stuff --- src/JavaEnv.cpp | 22 +++++++++++------ src/JavaEnv.hpp | 2 +- src/Plugin.cpp | 55 ++++++++++++++++++++++++++++++++++++++--- src/Plugin.hpp | 11 +++++++++ src/PluginInterface.cpp | 3 ++- 5 files changed, 81 insertions(+), 12 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index b10f48e..14c047a 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -75,6 +75,11 @@ jobject JavaEnv::ToJavaObject(Lua::LuaValue value) jclass jcls = jenv->FindClass("java/lang/Integer"); return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); } break; + case Lua::LuaValue::Type::NUMBER: + { + jclass jcls = jenv->FindClass("java/lang/Double"); + return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); + } break; case Lua::LuaValue::Type::BOOLEAN: { jclass jcls = jenv->FindClass("java/lang/Boolean"); @@ -126,6 +131,13 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) Lua::LuaValue value(result); return value; } + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Double"))) { + jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); + jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); + + Lua::LuaValue value(result); + return value; + } else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); @@ -173,17 +185,13 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) return NULL; } -jobject JavaEnv::CallStatic(std::string className, std::string methodName, std::string signature, jobject* params) { - size_t paramsLength = sizeof(params); - if (paramsLength > 0) { - paramsLength = paramsLength / sizeof(params[0]); - } +jobject JavaEnv::CallStatic(std::string className, std::string methodName, std::string signature, jobject* params, size_t paramsLength) { size_t spos = signature.find(")"); std::string returnSignature = signature.substr(spos + 1, signature.length() - spos); jclass clazz = this->env->FindClass(className.c_str()); - if (clazz == nullptr) return 0; + if (clazz == nullptr) return NULL; jmethodID methodID = this->env->GetStaticMethodID(clazz, methodName.c_str(), signature.c_str()); - if (methodID == nullptr) return 0; + if (methodID == nullptr) return NULL; jobject returnValue = NULL; if (!returnSignature.compare("V")) { switch (paramsLength) { diff --git a/src/JavaEnv.hpp b/src/JavaEnv.hpp index 82b0c20..d4dbf9c 100644 --- a/src/JavaEnv.hpp +++ b/src/JavaEnv.hpp @@ -22,6 +22,6 @@ class JavaEnv } Lua::LuaValue ToLuaValue(jobject object); jobject ToJavaObject(Lua::LuaValue value); - jobject CallStatic(std::string className, std::string methodName, std::string signature, jobject* params); + jobject CallStatic(std::string className, std::string methodName, std::string signature, jobject* params, size_t paramsLength); }; diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 7d49e98..fb0efae 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -18,6 +18,26 @@ typedef UINT(CALLBACK* JVMDLLFunction)(JavaVM**, void**, JavaVMInitArgs*); #endif +Lua::LuaArgs_t CallLuaFunction(lua_State* ScriptVM, const char* LuaFunctionName, Lua::LuaArgs_t* Arguments) { + Lua::LuaArgs_t ReturnValues; + int ArgCount = lua_gettop(ScriptVM); + lua_getglobal(ScriptVM, LuaFunctionName); + int argc = 0; + if (Arguments) { + for (auto const& e : *Arguments) { + Lua::PushValueToLua(e, ScriptVM); + argc++; + } + } + int Status = lua_pcall(ScriptVM, argc, LUA_MULTRET, 0); + ArgCount = lua_gettop(ScriptVM) - ArgCount; + if (Status == LUA_OK) { + Lua::ParseArguments(ScriptVM, ReturnValues); + lua_pop(ScriptVM, ArgCount); + } + return ReturnValues; +} + int Plugin::CreateJava(std::string classPath) { int id = 0; @@ -79,6 +99,34 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobject argsList) { jenv->DeleteLocalRef(event); } +jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { + JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); + if (env == nullptr) { + return NULL; + } + + (void)jcl; + + const char* packageNameStr = jenv->GetStringUTFChars(packageName, nullptr); + const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); + int argsLength = jenv->GetArrayLength(args); + auto luaArgs = new Lua::LuaArgs_t(); + for (jsize i = 0; i < argsLength; i++) { + luaArgs->push_back(env->ToLuaValue(jenv->GetObjectArrayElement(args, i))); + } + + auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, luaArgs); + size_t returnsLength = luaReturns.size(); + jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); + jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); + for (jsize i = 0; i < returnsLength; i++) { + jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(luaReturns[i])); + } + jenv->DeleteLocalRef(packageName); + jenv->DeleteLocalRef(functionName); + return returns; +} + Plugin::Plugin() { for (int i = 0; i < 30; i++) @@ -118,8 +166,9 @@ Plugin::Plugin() if (clazz == nullptr) return 0; JNINativeMethod methods[] = { {(char*)"callEvent", (char*)"(Ljava/lang/String;Ljava/util/List;)V", (void*)CallEvent }, + {(char*)"callGlobalFunction", (char*)"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)[Ljava/lang/Object;", (void*)CallGlobal } }; - jenv->RegisterNatives(clazz, methods, 1); + jenv->RegisterNatives(clazz, methods, 2); Lua::ReturnValues(L, 1); return 1; }); @@ -137,6 +186,7 @@ Plugin::Plugin() int arg_size = static_cast(arg_list.size()); if (arg_size < 4) return 0; + lua_pop(L, arg_size); std::string className = arg_list[1].GetValue(); std::string methodName = arg_list[2].GetValue(); @@ -146,8 +196,7 @@ Plugin::Plugin() auto const& value = arg_list[i]; params[i - 4] = env->ToJavaObject(value); } - - jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params); + jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params, arg_size - 4); if (returnValue != NULL) { Lua::LuaValue value = env->ToLuaValue(returnValue); if (!(value == NULL)) { diff --git a/src/Plugin.hpp b/src/Plugin.hpp index 8ad127e..c7bdf41 100644 --- a/src/Plugin.hpp +++ b/src/Plugin.hpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -15,6 +16,7 @@ class Plugin : public Singleton Plugin(); ~Plugin() = default; JavaEnv* jenvs[30]; + std::map packageStates; private: using FuncInfo_t = std::tuple; @@ -31,6 +33,15 @@ class Plugin : public Singleton { return _func_list; } + void AddPackage(std::string name, lua_State* state) { + this->packageStates[name] = state; + } + void RemovePackage(std::string name) { + this->packageStates[name] = nullptr; + } + lua_State* GetPackageState(std::string name) { + return this->packageStates[name]; + } int CreateJava(std::string classPath); void DestroyJava(int id); JavaEnv* GetJavaEnv(int id); diff --git a/src/PluginInterface.cpp b/src/PluginInterface.cpp index 0ca6105..9043392 100644 --- a/src/PluginInterface.cpp +++ b/src/PluginInterface.cpp @@ -40,9 +40,10 @@ EXPORT(void) OnPackageLoad(const char *PackageName, lua_State *L) (void)PackageName; for (auto const &f : Plugin::Get()->GetFunctions()) Lua::RegisterPluginFunction(L, std::get<0>(f), std::get<1>(f)); + Plugin::Get()->AddPackage(PackageName, L); } EXPORT(void) OnPackageUnload(const char *PackageName) { - (void)PackageName; + Plugin::Get()->RemovePackage(PackageName); } From 9447d5767b342e5fb1348a06c38859ea8a2240cf Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 29 Dec 2019 23:22:32 +0100 Subject: [PATCH 07/85] Added support for number and tried to add function support (not working yet) --- src/JavaEnv.cpp | 92 +++++++++++++++++++++++++++++++++++++++++++++++-- src/JavaEnv.hpp | 7 +++- src/Plugin.cpp | 4 +-- src/Plugin.hpp | 6 ++++ 4 files changed, 103 insertions(+), 6 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 14c047a..32ef9be 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -9,6 +9,25 @@ typedef UINT(CALLBACK* JVMDLLFunction)(JavaVM**, void**, JavaVMInitArgs*); #include #include #include +#include "Plugin.hpp" + +void JLuaFunctionClose(JNIEnv* jenv, jclass jcl, jobject instance) { + (void*)jcl; + JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); + if (env == nullptr) { + return; + } + env->LuaFunctionClose(instance); +} + +jobjectArray JLuaFunctionCall(JNIEnv* jenv, jclass jcl, jobject instance, jobjectArray args) { + (void*)jcl; + JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); + if (env == nullptr) { + return NULL; + } + return env->LuaFunctionCall(instance, args); +} JavaEnv::JavaEnv(std::string classPath) { this->env = nullptr; @@ -59,9 +78,57 @@ JavaEnv::JavaEnv(std::string classPath) { #elif _WIN32 createJavaVMFunction(&this->vm, (void**)&this->env, &vm_args); #endif + this->luaFunctionClass = this->env->FindClass("lua/LuaFunction"); + if (this->luaFunctionClass != NULL) { + JNINativeMethod methods[] = { + {(char*)"close", (char*)"()V", (void*)JLuaFunctionClose }, + {(char*)"call", (char*)"([Ljava/lang/Object;)[Ljava/lang/Object;", (void*)JLuaFunctionCall } + }; + this->env->RegisterNatives(this->luaFunctionClass, methods, 2); + printf("LuaFunction Support enabled\n"); + } +} + +void JavaEnv::LuaFunctionClose(jobject instance) { + jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); + int id = this->env->GetIntField(instance, fField); + this->luaFunctions[id] = NULL; } -jobject JavaEnv::ToJavaObject(Lua::LuaValue value) +jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { + jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); + int id = this->env->GetIntField(instance, fField); + jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); + jstring packageName = (jstring) this->env->GetObjectField(instance, pField); + const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); + lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); + this->env->DeleteLocalRef(packageName); + Lua::LuaArgs_t prevArgs; + Lua::ParseArguments(L, prevArgs); + int prevSize = static_cast(prevArgs.size()); + lua_pop(L, prevSize); + int argsLength = this->env->GetArrayLength(args); + Lua::PushValueToLua(this->luaFunctions[id], L); + for (jsize i = 0; i < argsLength; i++) { + Lua::PushValueToLua(this->ToLuaValue(this->env->GetObjectArrayElement(args, i)), L); + } + Lua::LuaArgs_t ReturnValues; + int status = lua_pcall(L, argsLength, LUA_MULTRET, 0); + if (status == LUA_OK) { + Lua::ParseArguments(L, ReturnValues); + size_t returnCount = ReturnValues.size(); + lua_pop(L, (int)returnCount); + jclass objectCls = this->env->FindClass("Ljava/lang/Object;"); + jobjectArray returns = this->env->NewObjectArray((jsize)returnCount, objectCls, NULL); + for (jsize i = 0; i < returnCount; i++) { + this->env->SetObjectArrayElement(returns, i, this->ToJavaObject(L, ReturnValues[i])); + } + return returns; + } + return NULL; +} + +jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) { JNIEnv* jenv = this->GetEnv(); switch (value.GetType()) @@ -92,12 +159,31 @@ jobject JavaEnv::ToJavaObject(Lua::LuaValue value) jmethodID putMethod = jenv->GetMethodID(jcls, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); Lua::LuaTable_t table = value.GetValue(); - table->ForEach([jenv, this, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { - jenv->CallObjectMethod(jmap, putMethod, this->ToJavaObject(k), this->ToJavaObject(v)); + table->ForEach([jenv, this, L, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { + jenv->CallObjectMethod(jmap, putMethod, this->ToJavaObject(L, k), this->ToJavaObject(L, v)); }); return jmap; } break; + case Lua::LuaValue::Type::FUNCTION: + { + if (this->luaFunctionClass == NULL) + return NULL; + std::string packageNameStr = Plugin::Get()->GetStatePackage(L); + jstring packageName = this->env->NewStringUTF(packageNameStr.c_str()); + jobject javaLuaFunction = jenv->NewObject(this->luaFunctionClass, jenv->GetMethodID(this->luaFunctionClass, "", "()V")); + int id = 1; + while (this->luaFunctions.count(id)){ + id++; + } + this->luaFunctions[id] = value; + jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); + this->env->SetIntField(javaLuaFunction, fField, id); + jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); + this->env->SetObjectField(javaLuaFunction, pField, packageName); + this->env->DeleteLocalRef(packageName); + return javaLuaFunction; + } break; case Lua::LuaValue::Type::NIL: case Lua::LuaValue::Type::INVALID: break; diff --git a/src/JavaEnv.hpp b/src/JavaEnv.hpp index d4dbf9c..2dab212 100644 --- a/src/JavaEnv.hpp +++ b/src/JavaEnv.hpp @@ -2,6 +2,7 @@ #include #include +#include #include class JavaEnv @@ -9,6 +10,8 @@ class JavaEnv private: JavaVM* vm; JNIEnv* env; + std::map luaFunctions; + jclass luaFunctionClass; public: JavaEnv(std::string classPath); void Destroy() { @@ -21,7 +24,9 @@ class JavaEnv return this->env; } Lua::LuaValue ToLuaValue(jobject object); - jobject ToJavaObject(Lua::LuaValue value); + jobject ToJavaObject(lua_State* L, Lua::LuaValue value); + jobjectArray LuaFunctionCall(jobject instance, jobjectArray args); + void LuaFunctionClose(jobject instance); jobject CallStatic(std::string className, std::string methodName, std::string signature, jobject* params, size_t paramsLength); }; diff --git a/src/Plugin.cpp b/src/Plugin.cpp index fb0efae..933e36c 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -120,7 +120,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); for (jsize i = 0; i < returnsLength; i++) { - jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(luaReturns[i])); + jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i])); } jenv->DeleteLocalRef(packageName); jenv->DeleteLocalRef(functionName); @@ -194,7 +194,7 @@ Plugin::Plugin() jobject* params = new jobject[arg_size - 4]; for (int i = 4; i < arg_size; i++) { auto const& value = arg_list[i]; - params[i - 4] = env->ToJavaObject(value); + params[i - 4] = env->ToJavaObject(L, value); } jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params, arg_size - 4); if (returnValue != NULL) { diff --git a/src/Plugin.hpp b/src/Plugin.hpp index c7bdf41..18d39a7 100644 --- a/src/Plugin.hpp +++ b/src/Plugin.hpp @@ -17,6 +17,7 @@ class Plugin : public Singleton ~Plugin() = default; JavaEnv* jenvs[30]; std::map packageStates; + std::map statePackages; private: using FuncInfo_t = std::tuple; @@ -35,13 +36,18 @@ class Plugin : public Singleton } void AddPackage(std::string name, lua_State* state) { this->packageStates[name] = state; + this->statePackages[state] = name; } void RemovePackage(std::string name) { + this->statePackages[this->packageStates[name]] = nullptr; this->packageStates[name] = nullptr; } lua_State* GetPackageState(std::string name) { return this->packageStates[name]; } + std::string GetStatePackage(lua_State* L) { + return this->statePackages[L]; + } int CreateJava(std::string classPath); void DestroyJava(int id); JavaEnv* GetJavaEnv(int id); From bf5cd78430d45bc07a7b61dc690832c5e41ab513 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 14:14:48 +0100 Subject: [PATCH 08/85] Fixed LuaFunction support and classpath generation when no classpath given --- src/CMakeLists.txt | 2 +- src/JavaEnv.cpp | 15 +++++---------- src/Plugin.cpp | 22 +++++++++++++++++++--- 3 files changed, 25 insertions(+), 14 deletions(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index ebe060b..56c75c5 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -27,7 +27,7 @@ target_include_directories(OnsetJavaPlugin PRIVATE set_property(TARGET OnsetJavaPlugin PROPERTY PREFIX "") -set_property(TARGET OnsetJavaPlugin PROPERTY CXX_STANDARD 11) +set_property(TARGET OnsetJavaPlugin PROPERTY CXX_STANDARD 17) set_property(TARGET OnsetJavaPlugin PROPERTY CXX_STANDARD_REQUIRED ON) if(MSVC) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 32ef9be..c57d463 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -11,8 +11,7 @@ typedef UINT(CALLBACK* JVMDLLFunction)(JavaVM**, void**, JavaVMInitArgs*); #include #include "Plugin.hpp" -void JLuaFunctionClose(JNIEnv* jenv, jclass jcl, jobject instance) { - (void*)jcl; +void JLuaFunctionClose(JNIEnv* jenv, jobject instance) { JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return; @@ -20,8 +19,7 @@ void JLuaFunctionClose(JNIEnv* jenv, jclass jcl, jobject instance) { env->LuaFunctionClose(instance); } -jobjectArray JLuaFunctionCall(JNIEnv* jenv, jclass jcl, jobject instance, jobjectArray args) { - (void*)jcl; +jobjectArray JLuaFunctionCall(JNIEnv* jenv, jobject instance, jobjectArray args) { JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return NULL; @@ -78,6 +76,7 @@ JavaEnv::JavaEnv(std::string classPath) { #elif _WIN32 createJavaVMFunction(&this->vm, (void**)&this->env, &vm_args); #endif + this->luaFunctionClass = this->env->FindClass("lua/LuaFunction"); if (this->luaFunctionClass != NULL) { JNINativeMethod methods[] = { @@ -85,7 +84,6 @@ JavaEnv::JavaEnv(std::string classPath) { {(char*)"call", (char*)"([Ljava/lang/Object;)[Ljava/lang/Object;", (void*)JLuaFunctionCall } }; this->env->RegisterNatives(this->luaFunctionClass, methods, 2); - printf("LuaFunction Support enabled\n"); } } @@ -97,16 +95,13 @@ void JavaEnv::LuaFunctionClose(jobject instance) { jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); - int id = this->env->GetIntField(instance, fField); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); + int id = this->env->GetIntField(instance, fField); + &id; jstring packageName = (jstring) this->env->GetObjectField(instance, pField); const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); this->env->DeleteLocalRef(packageName); - Lua::LuaArgs_t prevArgs; - Lua::ParseArguments(L, prevArgs); - int prevSize = static_cast(prevArgs.size()); - lua_pop(L, prevSize); int argsLength = this->env->GetArrayLength(args); Lua::PushValueToLua(this->luaFunctions[id], L); for (jsize i = 0; i < argsLength; i++) { diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 933e36c..6c0a5cd 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #ifdef _WIN32 #include @@ -134,9 +135,24 @@ Plugin::Plugin() LUA_DEFINE(CreateJava) { - std::string classPath; - Lua::ParseArguments(L, classPath); - int id = Plugin::Get()->CreateJava(classPath); + Lua::LuaArgs_t args; + Lua::ParseArguments(L, args); + int id = -1; + if (args.size() > 0) { + id = Plugin::Get()->CreateJava(args[0].GetValue()); + } else { + std::string classPath = "."; + if (std::filesystem::exists("java")) { + classPath = "java"; + for (const auto& entry : std::filesystem::directory_iterator("java")) { + if (!entry.is_directory()) { + classPath += ";" + entry.path().string(); + } + } + } + printf("CP: %s\n", classPath.c_str()); + id = Plugin::Get()->CreateJava(classPath); + } if (id < 0) return 0; return Lua::ReturnValues(L, id); }); From 4d4c000934e4396d3cb6fd04d8266e1835ef5023 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 14:36:36 +0100 Subject: [PATCH 09/85] Added LuaFunction support java project and removed debugging line --- .gitignore | 3 +++ OnsetJavaPluginSupport/pom.xml | 24 +++++++++++++++++++ .../src/main/java/lua/LuaFunction.java | 9 +++++++ src/Plugin.cpp | 8 +++++-- 4 files changed, 42 insertions(+), 2 deletions(-) create mode 100644 OnsetJavaPluginSupport/pom.xml create mode 100644 OnsetJavaPluginSupport/src/main/java/lua/LuaFunction.java diff --git a/.gitignore b/.gitignore index d75017b..426c29a 100644 --- a/.gitignore +++ b/.gitignore @@ -18,4 +18,7 @@ CPackSourceConfig.cmake cmake_install.cmake CMakeCache.txt .vs +.idea +*.iml +target diff --git a/OnsetJavaPluginSupport/pom.xml b/OnsetJavaPluginSupport/pom.xml new file mode 100644 index 0000000..55e1503 --- /dev/null +++ b/OnsetJavaPluginSupport/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + net.onfirenetwork + OnsetJavaPluginSupport + 1.0 + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 8 + 8 + + + + + + \ No newline at end of file diff --git a/OnsetJavaPluginSupport/src/main/java/lua/LuaFunction.java b/OnsetJavaPluginSupport/src/main/java/lua/LuaFunction.java new file mode 100644 index 0000000..2dcb2b9 --- /dev/null +++ b/OnsetJavaPluginSupport/src/main/java/lua/LuaFunction.java @@ -0,0 +1,9 @@ +package lua; + +public class LuaFunction { + private LuaFunction(){} + private String p; + private int f; + public native void close(); + public native Object[] call(Object... args); +} diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 6c0a5cd..c569268 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -146,11 +146,15 @@ Plugin::Plugin() classPath = "java"; for (const auto& entry : std::filesystem::directory_iterator("java")) { if (!entry.is_directory()) { - classPath += ";" + entry.path().string(); + std::string name = entry.path().string(); + if (name.length() > 4) { + if (!name.substr(name.length() - 4, 4).compare(".jar")) { + classPath += ";" + name; + } + } } } } - printf("CP: %s\n", classPath.c_str()); id = Plugin::Get()->CreateJava(classPath); } if (id < 0) return 0; From 2357546bd50eef2d212c464f5112fb84112c7a7e Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 14:42:37 +0100 Subject: [PATCH 10/85] Trying to add jitpack support --- jitpack.yml | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 jitpack.yml diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 0000000..7044889 --- /dev/null +++ b/jitpack.yml @@ -0,0 +1,5 @@ +jdk: + - openjdk8 +install: + - cd OnsetJavaPluginSupport + - mvn clean install \ No newline at end of file From cce8c456578bfeb8be960aac28cfce26485f5e64 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Mon, 30 Dec 2019 16:10:09 +0100 Subject: [PATCH 11/85] Update README.md --- README.md | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 6105d83..404bfb4 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ Authors: JanHolger, Digital ### Features * Create JVMs. -* Communicate from Lua <-> Java. +* Communicate between Lua <-> Java. ### Download Check out Releases for a download to Windows & Linux builds. @@ -17,12 +17,15 @@ Check out Releases for a download to Windows & Linux builds. #### Method Parameters * Lua String -> String (java.lang.String) * Lua Int -> Integer (java.lang.Integer) +* Lua Number -> Double (java.lang.Double) * Lua Bool -> Boolean (java.lang.Boolean) * Lua Table -> Map (java.util.HashMap) +* Lua Function -> LuaFunction (lua.LuaFunction, `OnsetJavaPluginSupport-1.0.jar` required) #### Return Values * String (java.lang.String) * Integer (java.lang.Integer) +* Double (java.lang.Double) * Boolean (java.lang.Boolean) * List (java.util.List) * Map (java.util.Map) @@ -35,7 +38,7 @@ Create a new JVM with a jar. Returns JVM ID. ```lua local jvmID = CreateJava(path) ``` -* **path** Relative path to the jar file, relative from the root server directory. Example: path/to/file.jar +* **path** Classpath for the jvm. This parameter is optional. When not provided it will include the "java" directory aswell as all jar files inside or "." when "java" doesn't exist. #### DestroyJava Destroy a JVM. @@ -64,21 +67,33 @@ LinkJavaAdapter(jvmID, className) * **className** Class name of the class you want to call a method in, must include package path as well. Example: dev/joseph/Adapter (dev.joseph.Adapter). ### Java Native Methods -#### callEvent -Call Lua events from Java. +You can use a native adapter to call lua functions. ```java +package example; public class Adapter { - public native static void callEvent(String event, List args); + public native static void callEvent(String event, Object... args); + public native static Object[] callGlobalFunction(String packageName, String functionName, Object... args); } ``` -Example: +```lua +LinkJavaAdapter(java, "example/Adapter") +``` +#### callEvent +Java: ```java -Adapter.callEvent("testCallEvent", Arrays.asList("lol", "haha", "yeah")); -Adapter.callEvent("testCallEvent", Arrays.asList(1, 2, "hi", 384, "yeeep", true, false)); +Adapter.callEvent("testCallEvent", "hi", Integer.valueOf(123), Boolean.valueOf(true)); ``` +Lua: ```lua -function testCallEvent(arg1) - print ('first arg is ' .. arg1) -end -AddEvent('testCallEvent', testCallEvent) +AddEvent('testCallEvent', function(s,i,b) + print(s) + print(i) + print(b) +end) +``` +#### callGlobalFunction +*Make sure to use this method only on the main thread. Using it outside the mainthread can result in unexpected behavior.* +Java: +```java +Adapter.callGlobalFunction("AddPlayerChatAll", "Hello World"); ``` From 0812b583483d35fb9eff6163d0421c545f74530d Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Mon, 30 Dec 2019 16:20:23 +0100 Subject: [PATCH 12/85] Update README.md --- README.md | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/README.md b/README.md index 404bfb4..7f7ecde 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,38 @@ Check out Releases for a download to Windows & Linux builds. We will be adding more data types later on. +#### Using the lua function support interface +##### Maven +```xml + + + jitpack.io + https://jitpack.io + + + + + com.github.OnfireNetwork + OnsetJavaPlugin + 2357546bd5 + + +``` +##### Usage +Java: +```java +public static void example(LuaFunction fn){ + fn.call("Hello from Java!"); + fn.close(); // Always call this when you don't need the function anymore to free memory +} +``` +Lua: +```lua +CallJavaStaticMethod(java, "example/Example", "example", "(Llua/LuaFunction;)V", function(msg) + print(msg) +end) +``` + ### Lua Functions #### CreateJava Create a new JVM with a jar. Returns JVM ID. From eedaffceb2e7cfd9bec9ec2db1abbe56ccac85f9 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Mon, 30 Dec 2019 16:21:04 +0100 Subject: [PATCH 13/85] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7f7ecde..93be8d3 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ Check out Releases for a download to Windows & Linux builds. * Lua Number -> Double (java.lang.Double) * Lua Bool -> Boolean (java.lang.Boolean) * Lua Table -> Map (java.util.HashMap) -* Lua Function -> LuaFunction (lua.LuaFunction, `OnsetJavaPluginSupport-1.0.jar` required) +* Lua Function -> LuaFunction (lua.LuaFunction, lua function support interface required) #### Return Values * String (java.lang.String) From 65ea808fdb41b871171e354612013559a2e411b0 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Mon, 30 Dec 2019 16:38:18 +0100 Subject: [PATCH 14/85] Update .gitmodules --- .gitmodules | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitmodules b/.gitmodules index b52a4a9..28b0527 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ [submodule "libs/sdk"] path = libs/sdk - url = git@github.com:BlueMountainsIO/OnsetSDK.git + url = https://github.com/BlueMountainsIO/OnsetSDK.git From c8acca46ca26e8bbd144faeedfdf95308de7f156 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 15:45:18 +0100 Subject: [PATCH 15/85] Tried to fix linux build --- src/JavaEnv.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index c57d463..3c95d59 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -97,7 +97,6 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); int id = this->env->GetIntField(instance, fField); - &id; jstring packageName = (jstring) this->env->GetObjectField(instance, pField); const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); @@ -115,7 +114,7 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { lua_pop(L, (int)returnCount); jclass objectCls = this->env->FindClass("Ljava/lang/Object;"); jobjectArray returns = this->env->NewObjectArray((jsize)returnCount, objectCls, NULL); - for (jsize i = 0; i < returnCount; i++) { + for (int i = 0; i < (int) returnCount; i++) { this->env->SetObjectArrayElement(returns, i, this->ToJavaObject(L, ReturnValues[i])); } return returns; From 63253b02e9369fe702f7d7997c187e8dc4634841 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 17:18:27 +0100 Subject: [PATCH 16/85] tried to fix linux --- src/Plugin.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index c569268..94b6ce5 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -2,7 +2,12 @@ #include #include #include +#ifdef _WIN32 #include +#else +#include +#endif + #ifdef _WIN32 #include From 58315c05527a4638d742611dd2816ad848a42f2e Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 17:22:40 +0100 Subject: [PATCH 17/85] tried to fix linux --- src/Plugin.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 94b6ce5..ab7c073 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -4,8 +4,10 @@ #include #ifdef _WIN32 #include +namespace fs = std::filesystem; #else #include +namespace fs = std::experimental::filesystem; #endif @@ -147,9 +149,9 @@ Plugin::Plugin() id = Plugin::Get()->CreateJava(args[0].GetValue()); } else { std::string classPath = "."; - if (std::filesystem::exists("java")) { + if (fs::exists("java")) { classPath = "java"; - for (const auto& entry : std::filesystem::directory_iterator("java")) { + for (const auto& entry : fs::directory_iterator("java")) { if (!entry.is_directory()) { std::string name = entry.path().string(); if (name.length() > 4) { From a27a2763ac22930cef6e46d1641343d28d98a293 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 17:37:22 +0100 Subject: [PATCH 18/85] tried to fix linux --- src/Plugin.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index ab7c073..12e6a62 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -2,14 +2,9 @@ #include #include #include -#ifdef _WIN32 + #include namespace fs = std::filesystem; -#else -#include -namespace fs = std::experimental::filesystem; -#endif - #ifdef _WIN32 #include From c2558f68b2e6b7fe24cd3385e6645e1f3a9e15bd Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 30 Dec 2019 17:39:28 +0100 Subject: [PATCH 19/85] tried to fix linux --- src/JavaEnv.cpp | 2 +- src/Plugin.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 3c95d59..3cac496 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -114,7 +114,7 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { lua_pop(L, (int)returnCount); jclass objectCls = this->env->FindClass("Ljava/lang/Object;"); jobjectArray returns = this->env->NewObjectArray((jsize)returnCount, objectCls, NULL); - for (int i = 0; i < (int) returnCount; i++) { + for (jsize i = 0; i < (int) returnCount; i++) { this->env->SetObjectArrayElement(returns, i, this->ToJavaObject(L, ReturnValues[i])); } return returns; diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 12e6a62..e69ee24 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -122,7 +122,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f size_t returnsLength = luaReturns.size(); jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); - for (jsize i = 0; i < returnsLength; i++) { + for (jsize i = 0; i < (int) returnsLength; i++) { jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i])); } jenv->DeleteLocalRef(packageName); From 73c708032bd01d3026acb97ca4c1dd5ad4bf609e Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 31 Dec 2019 00:31:00 +0100 Subject: [PATCH 20/85] Changed callEvent export --- src/Plugin.cpp | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index e69ee24..3c9fce0 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -73,27 +73,21 @@ JavaEnv* Plugin::FindJavaEnv(JNIEnv* jenv) { return nullptr; } -void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobject argsList) { +void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return; } - (void) jcl; const char* eventStr = jenv->GetStringUTFChars(event, nullptr); auto args = new Lua::LuaArgs_t(); - if (jenv->IsInstanceOf(argsList, jenv->FindClass("java/util/List"))) { - jclass argsCls = jenv->GetObjectClass(argsList); - jmethodID sizeMethod = jenv->GetMethodID(argsCls, "size", "()I"); - jmethodID getMethod = jenv->GetMethodID(argsCls, "get", "(I)Ljava/lang/Object;"); - jint len = jenv->CallIntMethod(argsList, sizeMethod); + int argsCount = jenv->GetArrayLength(argsList); - for (jint i = 0; i < len; i++) { - jobject arrayElement = jenv->CallObjectMethod(argsList, getMethod, i); - args->push_back(env->ToLuaValue(arrayElement)); - } + for (jsize i = 0; i < argsCount; i++) { + jobject arrayElement = jenv->GetObjectArrayElement(argsList, i); + args->push_back(env->ToLuaValue(arrayElement)); } Onset::Plugin::Get()->CallEvent(eventStr, args); From 2b11bec7b04d216e43cc948bc5c15e1c4d6a86f2 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 31 Dec 2019 22:12:35 +0100 Subject: [PATCH 21/85] Fixed linking issue --- src/Plugin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 3c9fce0..b8183a6 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -181,7 +181,7 @@ Plugin::Plugin() jclass clazz = jenv->FindClass(className.c_str()); if (clazz == nullptr) return 0; JNINativeMethod methods[] = { - {(char*)"callEvent", (char*)"(Ljava/lang/String;Ljava/util/List;)V", (void*)CallEvent }, + {(char*)"callEvent", (char*)"(Ljava/lang/String;[Ljava/lang/Object;)V", (void*)CallEvent }, {(char*)"callGlobalFunction", (char*)"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)[Ljava/lang/Object;", (void*)CallGlobal } }; jenv->RegisterNatives(clazz, methods, 2); From cf0a2943733202c2bd24264b291c14f51e900807 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 13 Jan 2020 16:56:26 +0100 Subject: [PATCH 22/85] Fixed linux classpath generation --- src/Plugin.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index b8183a6..9edce15 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -145,7 +145,11 @@ Plugin::Plugin() std::string name = entry.path().string(); if (name.length() > 4) { if (!name.substr(name.length() - 4, 4).compare(".jar")) { +#ifdef _WIN32 classPath += ";" + name; +#else + classPath += ":" + name; +#endif } } } From 815c84e175c2cfbac240aedea1be05cb75369aa7 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Thu, 19 Mar 2020 22:39:25 +0100 Subject: [PATCH 23/85] Update README.md --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 93be8d3..a7fec1c 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,10 @@ Authors: JanHolger, Digital * Create JVMs. * Communicate between Lua <-> Java. +### OnsetJava +Interested in writing your entire gamemode in java? +You can use our [language framework](https://github.com/OnfireNetwork/OnsetJava) with tons of features running on top of this plugin! + ### Download Check out Releases for a download to Windows & Linux builds. From a6c1d6c4be097c173aae8e91b13876b5170bfcf5 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Thu, 30 Apr 2020 02:20:59 +0200 Subject: [PATCH 24/85] Tried to fix Boolean --- src/JavaEnv.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 3cac496..3878723 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -72,9 +72,10 @@ JavaEnv::JavaEnv(std::string classPath) { vm_args.ignoreUnrecognized = false; #ifdef __linux__ - JNI_CreateJavaVM(&this->vm, (void**)&this->env, &vm_args); + int res = JNI_CreateJavaVM(&this->vm, (void**)&this->env, &vm_args); #elif _WIN32 - createJavaVMFunction(&this->vm, (void**)&this->env, &vm_args); + int res = createJavaVMFunction(&this->vm, (void**)&this->env, &vm_args); + printf("CreateJava Return: %d", res); #endif this->luaFunctionClass = this->env->FindClass("lua/LuaFunction"); @@ -222,7 +223,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - Lua::LuaValue value(result); + Lua::LuaValue value((bool) result); return value; } else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/List"))) { From 989f54f93884a277045014a8abe6daebadbb2e14 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Thu, 30 Apr 2020 02:41:02 +0200 Subject: [PATCH 25/85] Update README.md --- README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a7fec1c..ba93e38 100644 --- a/README.md +++ b/README.md @@ -13,9 +13,11 @@ You can use our [language framework](https://github.com/OnfireNetwork/OnsetJava) Check out Releases for a download to Windows & Linux builds. ### Installation -1. Download OnsetJavaPlugin.dll (Windows) & OnsetJavaPlugin.so (Linux) from Releases ([HERE](https://github.com/OnfireNetwork/OnsetJavaPlugin/releases)) and place inside plugins folder. -1. Ensure Java 8 JDK/JRE 64bit is installed. -1. Enable "OnsetJavaPlugin" as a plugin inside server_config.json. +1. Get OnsetJavaPlugin and place it in your plugins directory. +**Windows:** Download OnsetJavaPlugin.dll from Releases ([HERE](https://github.com/OnfireNetwork/OnsetJavaPlugin/releases)). +**Linux:** Make sure to have the latest versions of cmake and gcc/g++ or any other compiler that is cmake compatible and capable of building CXX17. The debian and ubuntu versions we tried for building didn't come with compatible versions in their package sources. You might need to manually install those. We recommend to do that on an unused vm as changing the gcc/g++ version might break some of your installed software packages. Then `git clone https://github.com/OnfireNetwork/OnsetJavaPlugin`, `cd OnsetJavaPlugin`, `cmake .` and `make` for building. +2. Ensure Java 8 JDK/JRE 64bit is installed. +3. Enable "OnsetJavaPlugin" as a plugin inside server_config.json. ### Data Types we support #### Method Parameters From 35c893db6024534905803ceea977d51fc4cd69ba Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Thu, 30 Apr 2020 02:44:29 +0200 Subject: [PATCH 26/85] Update README.md --- README.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/README.md b/README.md index ba93e38..08ca266 100644 --- a/README.md +++ b/README.md @@ -9,9 +9,6 @@ Authors: JanHolger, Digital Interested in writing your entire gamemode in java? You can use our [language framework](https://github.com/OnfireNetwork/OnsetJava) with tons of features running on top of this plugin! -### Download -Check out Releases for a download to Windows & Linux builds. - ### Installation 1. Get OnsetJavaPlugin and place it in your plugins directory. **Windows:** Download OnsetJavaPlugin.dll from Releases ([HERE](https://github.com/OnfireNetwork/OnsetJavaPlugin/releases)). From 4f2e7ca38b810e61b83bbb8c9f5e5c71dfc3d217 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Fri, 8 May 2020 18:32:23 +0200 Subject: [PATCH 27/85] Update CMakeLists.txt --- src/CMakeLists.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 56c75c5..95bb328 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -51,7 +51,6 @@ elseif(UNIX) -Wextra -pedantic -Werror - -Wno-unused-function ) endif() From 93af58368f2bb4c02433dcee75686b4ad794d872 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Fri, 8 May 2020 18:34:51 +0200 Subject: [PATCH 28/85] Update CMakeLists.txt --- src/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 95bb328..44cead6 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -51,6 +51,8 @@ elseif(UNIX) -Wextra -pedantic -Werror + -Wno-unused-variable + -Wno-unused-function ) endif() From 0af92c4c6175dce6944504624d3314b4da713094 Mon Sep 17 00:00:00 2001 From: Jan Bebendorf Date: Sun, 10 May 2020 19:28:42 +0200 Subject: [PATCH 29/85] Update CMakeLists.txt --- src/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 44cead6..881a875 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,4 +1,5 @@ set(PLUGIN_CONFIG_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/config_headers") +link_libraries(stdc++fs) configure_file( "version.hpp.in" From c9c7779b484015f4fbcbace986014a38e39127a0 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Thu, 9 Jul 2020 21:00:57 +0200 Subject: [PATCH 30/85] Tried to fix potential memory leaks --- src/JavaEnv.cpp | 32 ++++++++++++++++++++++---------- src/Plugin.cpp | 7 ++++++- 2 files changed, 28 insertions(+), 11 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 3878723..8a06c19 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -115,8 +115,11 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { lua_pop(L, (int)returnCount); jclass objectCls = this->env->FindClass("Ljava/lang/Object;"); jobjectArray returns = this->env->NewObjectArray((jsize)returnCount, objectCls, NULL); + this->env->DeleteLocalRef(objectCls); for (jsize i = 0; i < (int) returnCount; i++) { - this->env->SetObjectArrayElement(returns, i, this->ToJavaObject(L, ReturnValues[i])); + jobject obj = this->ToJavaObject(L, ReturnValues[i]); + this->env->SetObjectArrayElement(returns, i, obj); + this->env->DeleteLocalRef(obj); } return returns; } @@ -135,17 +138,23 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) case Lua::LuaValue::Type::INTEGER: { jclass jcls = jenv->FindClass("java/lang/Integer"); - return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); + jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); + jenv->DeleteLocalRef(jcls); + return obj; } break; case Lua::LuaValue::Type::NUMBER: { jclass jcls = jenv->FindClass("java/lang/Double"); - return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); + jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); + jenv->DeleteLocalRef(jcls); + return obj; } break; case Lua::LuaValue::Type::BOOLEAN: { jclass jcls = jenv->FindClass("java/lang/Boolean"); - return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); + jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); + jenv->DeleteLocalRef(jcls); + return obj; } break; case Lua::LuaValue::Type::TABLE: { @@ -157,7 +166,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) table->ForEach([jenv, this, L, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { jenv->CallObjectMethod(jmap, putMethod, this->ToJavaObject(L, k), this->ToJavaObject(L, v)); }); - + jenv->DeleteLocalRef(jcls); return jmap; } break; case Lua::LuaValue::Type::FUNCTION: @@ -208,21 +217,21 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Integer"))) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); - + jenv->DeleteLocalRef(object); Lua::LuaValue value(result); return value; } else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Double"))) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); - + jenv->DeleteLocalRef(object); Lua::LuaValue value(result); return value; } else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - + jenv->DeleteLocalRef(object); Lua::LuaValue value((bool) result); return value; } @@ -236,7 +245,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); table->Add(i + 1, this->ToLuaValue(arrayElement)); } - + jenv->DeleteLocalRef(object); Lua::LuaValue value(table); return value; } @@ -248,6 +257,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jmethodID keySetToArrayMethod = jenv->GetMethodID(jenv->GetObjectClass(keySet), "toArray", "()[Ljava/lang/Object;"); jobjectArray keyArray = (jobjectArray)jenv->CallObjectMethod(keySet, keySetToArrayMethod); + jenv->DeleteLocalRef(keySet); int arraySize = jenv->GetArrayLength(keyArray); Lua::LuaTable_t table(new Lua::LuaTable); @@ -258,7 +268,8 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); } - + jenv->DeleteLocalRef(keyArray); + jenv->DeleteLocalRef(object); Lua::LuaValue value(table); return value; } @@ -354,5 +365,6 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: break; } } + this->env->DeleteLocalRef(clazz); return returnValue; } \ No newline at end of file diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 9edce15..c57d9db 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -78,7 +78,6 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { if (env == nullptr) { return; } - (void) jcl; const char* eventStr = jenv->GetStringUTFChars(event, nullptr); auto args = new Lua::LuaArgs_t(); @@ -93,7 +92,9 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { Onset::Plugin::Get()->CallEvent(eventStr, args); jenv->ReleaseStringUTFChars(event, eventStr); + jenv->DeleteLocalRef(jcl); jenv->DeleteLocalRef(event); + jenv->DeleteLocalRef(argsList); } jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { @@ -119,8 +120,12 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f for (jsize i = 0; i < (int) returnsLength; i++) { jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i])); } + jenv->ReleaseStringUTFChars(packageName, packageNameStr); + jenv->ReleaseStringUTFChars(functionName, functionNameStr); + jenv->DeleteLocalRef(jcl); jenv->DeleteLocalRef(packageName); jenv->DeleteLocalRef(functionName); + jenv->DeleteLocalRef(args); return returns; } From 1309b65ccee25b707b363b100e85457b467e9847 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Thu, 9 Jul 2020 23:59:00 +0200 Subject: [PATCH 31/85] Added debugging for CallLuaFunction --- src/Plugin.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index c57d9db..cde38da 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -22,6 +22,8 @@ namespace fs = std::filesystem; #endif Lua::LuaArgs_t CallLuaFunction(lua_State* ScriptVM, const char* LuaFunctionName, Lua::LuaArgs_t* Arguments) { + Onset::Plugin::Get()->Log("Function Name: %s", LuaFunctionName); + Onset::Plugin::Get()->Log("Function Arg Count: %i", Arguments->size); Lua::LuaArgs_t ReturnValues; int ArgCount = lua_gettop(ScriptVM); lua_getglobal(ScriptVM, LuaFunctionName); From b8890fca43860d31d50c7ebe1fcf7b7c99465f36 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 00:00:19 +0200 Subject: [PATCH 32/85] Added debugging for CallLuaFunction --- src/Plugin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index cde38da..5727c86 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -23,7 +23,7 @@ namespace fs = std::filesystem; Lua::LuaArgs_t CallLuaFunction(lua_State* ScriptVM, const char* LuaFunctionName, Lua::LuaArgs_t* Arguments) { Onset::Plugin::Get()->Log("Function Name: %s", LuaFunctionName); - Onset::Plugin::Get()->Log("Function Arg Count: %i", Arguments->size); + Onset::Plugin::Get()->Log("Function Arg Count: %i", Arguments->size()); Lua::LuaArgs_t ReturnValues; int ArgCount = lua_gettop(ScriptVM); lua_getglobal(ScriptVM, LuaFunctionName); From 008cb8e40df71146bb160c613dc4ddb4d25eec46 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 00:25:57 +0200 Subject: [PATCH 33/85] Added debugging for CallLuaFunction --- src/Plugin.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 5727c86..3ee4e27 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -24,6 +24,10 @@ namespace fs = std::filesystem; Lua::LuaArgs_t CallLuaFunction(lua_State* ScriptVM, const char* LuaFunctionName, Lua::LuaArgs_t* Arguments) { Onset::Plugin::Get()->Log("Function Name: %s", LuaFunctionName); Onset::Plugin::Get()->Log("Function Arg Count: %i", Arguments->size()); + Lua::LuaArgs_t arg_list; + Lua::ParseArguments(ScriptVM, arg_list); + int arg_size = static_cast(arg_list.size()); + Onset::Plugin::Get()->Log("Stack: %i", arg_size); Lua::LuaArgs_t ReturnValues; int ArgCount = lua_gettop(ScriptVM); lua_getglobal(ScriptVM, LuaFunctionName); From 285e24253053d9a1e2352659427bb5f1e1203697 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 00:33:02 +0200 Subject: [PATCH 34/85] Added debugging for CallLuaFunction --- src/Plugin.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 3ee4e27..bf652f0 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -22,12 +22,10 @@ namespace fs = std::filesystem; #endif Lua::LuaArgs_t CallLuaFunction(lua_State* ScriptVM, const char* LuaFunctionName, Lua::LuaArgs_t* Arguments) { - Onset::Plugin::Get()->Log("Function Name: %s", LuaFunctionName); - Onset::Plugin::Get()->Log("Function Arg Count: %i", Arguments->size()); - Lua::LuaArgs_t arg_list; - Lua::ParseArguments(ScriptVM, arg_list); - int arg_size = static_cast(arg_list.size()); - Onset::Plugin::Get()->Log("Stack: %i", arg_size); + Lua::LuaArgs_t stack; + Lua::ParseArguments(ScriptVM, stack); + int stack_size = static_cast(stack.size()); + lua_pop(L, stack_size); Lua::LuaArgs_t ReturnValues; int ArgCount = lua_gettop(ScriptVM); lua_getglobal(ScriptVM, LuaFunctionName); From 7cdcb9bffd8cf8d04117d171481022243ddd5f80 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 00:34:33 +0200 Subject: [PATCH 35/85] Added debugging for CallLuaFunction --- src/Plugin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index bf652f0..ef7b187 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -25,7 +25,7 @@ Lua::LuaArgs_t CallLuaFunction(lua_State* ScriptVM, const char* LuaFunctionName, Lua::LuaArgs_t stack; Lua::ParseArguments(ScriptVM, stack); int stack_size = static_cast(stack.size()); - lua_pop(L, stack_size); + lua_pop(ScriptVM, stack_size); Lua::LuaArgs_t ReturnValues; int ArgCount = lua_gettop(ScriptVM); lua_getglobal(ScriptVM, LuaFunctionName); From 79aeddc3c566a1e7b4b2aebe68112c4cacb0c125 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 02:29:40 +0200 Subject: [PATCH 36/85] Added some more memory leak fixes --- src/JavaEnv.cpp | 68 ++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 62 insertions(+), 6 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 8a06c19..2b2b661 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -92,6 +92,7 @@ void JavaEnv::LuaFunctionClose(jobject instance) { jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); int id = this->env->GetIntField(instance, fField); this->luaFunctions[id] = NULL; + this->env->DeleteLocalRef(instance); } jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { @@ -101,12 +102,15 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jstring packageName = (jstring) this->env->GetObjectField(instance, pField); const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); + this->env->ReleaseStringUTFChars(packageName, packageNameStr); this->env->DeleteLocalRef(packageName); + this->env->DeleteLocalRef(instance); int argsLength = this->env->GetArrayLength(args); Lua::PushValueToLua(this->luaFunctions[id], L); for (jsize i = 0; i < argsLength; i++) { Lua::PushValueToLua(this->ToLuaValue(this->env->GetObjectArrayElement(args, i)), L); } + this->env->DeleteLocalRef(args); Lua::LuaArgs_t ReturnValues; int status = lua_pcall(L, argsLength, LUA_MULTRET, 0); if (status == LUA_OK) { @@ -202,40 +206,78 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) { JNIEnv* jenv = this->GetEnv(); jclass jcls = jenv->GetObjectClass(object); + jclass stringCls = jenv->FindClass("java/lang/String"); + jclass integerCls = jenv->FindClass("java/lang/Integer"); + jclass doubleCls = jenv->FindClass("java/lang/Double"); + jclass booleanCls = jenv->FindClass("java/lang/Boolean"); + jclass listCls = jenv->FindClass("java/util/List"); + jclass mapCls = jenv->FindClass("java/util/Map"); - if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/String"))) { + if (jenv->IsInstanceOf(object, stringCls)) { jstring element = (jstring)object; const char* pchars = jenv->GetStringUTFChars(element, nullptr); Lua::LuaValue value(pchars); jenv->ReleaseStringUTFChars(element, pchars); + jenv->DeleteLocalRef(element); + jenv->DeleteLocalRef(jcls); + jenv->DeleteLocalRef(stringCls); + jenv->DeleteLocalRef(integerCls); + jenv->DeleteLocalRef(doubleCls); + jenv->DeleteLocalRef(booleanCls); + jenv->DeleteLocalRef(listCls); + jenv->DeleteLocalRef(mapCls); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Integer"))) { + else if (jenv->IsInstanceOf(object, integerCls)) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); jenv->DeleteLocalRef(object); + jenv->DeleteLocalRef(jcls); + jenv->DeleteLocalRef(stringCls); + jenv->DeleteLocalRef(integerCls); + jenv->DeleteLocalRef(doubleCls); + jenv->DeleteLocalRef(booleanCls); + jenv->DeleteLocalRef(listCls); + jenv->DeleteLocalRef(mapCls); + Lua::LuaValue value(result); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Double"))) { + else if (jenv->IsInstanceOf(object, doubleCls)) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); jenv->DeleteLocalRef(object); + jenv->DeleteLocalRef(jcls); + jenv->DeleteLocalRef(stringCls); + jenv->DeleteLocalRef(integerCls); + jenv->DeleteLocalRef(doubleCls); + jenv->DeleteLocalRef(booleanCls); + jenv->DeleteLocalRef(listCls); + jenv->DeleteLocalRef(mapCls); + Lua::LuaValue value(result); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { + else if (jenv->IsInstanceOf(object, booleanCls)) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); jenv->DeleteLocalRef(object); + jenv->DeleteLocalRef(jcls); + jenv->DeleteLocalRef(stringCls); + jenv->DeleteLocalRef(integerCls); + jenv->DeleteLocalRef(doubleCls); + jenv->DeleteLocalRef(booleanCls); + jenv->DeleteLocalRef(listCls); + jenv->DeleteLocalRef(mapCls); + Lua::LuaValue value((bool) result); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/List"))) { + else if (jenv->IsInstanceOf(object, listCls)) { jmethodID sizeMethod = jenv->GetMethodID(jcls, "size", "()I"); jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(I)Ljava/lang/Object;"); jint len = jenv->CallIntMethod(object, sizeMethod); @@ -246,10 +288,17 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(i + 1, this->ToLuaValue(arrayElement)); } jenv->DeleteLocalRef(object); + jenv->DeleteLocalRef(jcls); + jenv->DeleteLocalRef(stringCls); + jenv->DeleteLocalRef(integerCls); + jenv->DeleteLocalRef(doubleCls); + jenv->DeleteLocalRef(booleanCls); + jenv->DeleteLocalRef(listCls); + jenv->DeleteLocalRef(mapCls); Lua::LuaValue value(table); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/Map"))) { + else if (jenv->IsInstanceOf(object, mapCls)) { jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(Ljava/lang/Object;)Ljava/lang/Object;"); jmethodID keySetMethod = jenv->GetMethodID(jcls, "keySet", "()Ljava/util/Set;"); @@ -270,6 +319,13 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) } jenv->DeleteLocalRef(keyArray); jenv->DeleteLocalRef(object); + jenv->DeleteLocalRef(jcls); + jenv->DeleteLocalRef(stringCls); + jenv->DeleteLocalRef(integerCls); + jenv->DeleteLocalRef(doubleCls); + jenv->DeleteLocalRef(booleanCls); + jenv->DeleteLocalRef(listCls); + jenv->DeleteLocalRef(mapCls); Lua::LuaValue value(table); return value; } From f06e1a67dec60b975fe48e18b95a32173b0b5bb3 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:05:33 +0200 Subject: [PATCH 37/85] Added some more memory leak fixes --- src/JavaEnv.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 2b2b661..19a1552 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -103,6 +103,7 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); this->env->ReleaseStringUTFChars(packageName, packageNameStr); + Onset::Plugin::Get()->Log("%s", packageNameStr); this->env->DeleteLocalRef(packageName); this->env->DeleteLocalRef(instance); int argsLength = this->env->GetArrayLength(args); From bc0c7ca6d9794ec47cfbe18632de08abc4821c8d Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:10:39 +0200 Subject: [PATCH 38/85] Added some more memory leak fixes --- src/JavaEnv.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 19a1552..8fba9dd 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -102,6 +102,7 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jstring packageName = (jstring) this->env->GetObjectField(instance, pField); const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); + Onset::Plugin::Get()->Log("%s", packageNameStr); this->env->ReleaseStringUTFChars(packageName, packageNameStr); Onset::Plugin::Get()->Log("%s", packageNameStr); this->env->DeleteLocalRef(packageName); From f10b68f035ea87acdf93563aeea03f0044474fb2 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:11:42 +0200 Subject: [PATCH 39/85] Debugging --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 426c29a..ecb348a 100644 --- a/.gitignore +++ b/.gitignore @@ -21,4 +21,4 @@ CMakeCache.txt .idea *.iml target - +commit.sh From 4c2e1826f50af68840e3fd6e6ada2661d9988e1c Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:15:33 +0200 Subject: [PATCH 40/85] Debugging --- src/JavaEnv.cpp | 2 -- src/Plugin.cpp | 2 ++ 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 8fba9dd..2b2b661 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -102,9 +102,7 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jstring packageName = (jstring) this->env->GetObjectField(instance, pField); const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); - Onset::Plugin::Get()->Log("%s", packageNameStr); this->env->ReleaseStringUTFChars(packageName, packageNameStr); - Onset::Plugin::Get()->Log("%s", packageNameStr); this->env->DeleteLocalRef(packageName); this->env->DeleteLocalRef(instance); int argsLength = this->env->GetArrayLength(args); diff --git a/src/Plugin.cpp b/src/Plugin.cpp index ef7b187..1f102e4 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -124,7 +124,9 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f for (jsize i = 0; i < (int) returnsLength; i++) { jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i])); } + Onset::Plugin::Get()->Log("%s", packageNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); + Onset::Plugin::Get()->Log("%s", packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteLocalRef(jcl); jenv->DeleteLocalRef(packageName); From 62ddf831a2d04873f715ca3b63465438704556d8 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:23:03 +0200 Subject: [PATCH 41/85] Debugging --- src/Plugin.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 1f102e4..8cf25a0 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -122,11 +122,11 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); for (jsize i = 0; i < (int) returnsLength; i++) { - jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i])); + jobject obj = env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i]); + jenv->SetObjectArrayElement(returns, i, obj); + env->GetEnv()->DeleteLocalRef(obj); } - Onset::Plugin::Get()->Log("%s", packageNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); - Onset::Plugin::Get()->Log("%s", packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteLocalRef(jcl); jenv->DeleteLocalRef(packageName); From 1926333ec0f6957204cfe6d59382f8f83e72484f Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:45:27 +0200 Subject: [PATCH 42/85] Debugging --- src/JavaEnv.cpp | 9 ++++++++- src/Plugin.cpp | 3 +++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 2b2b661..1356342 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -168,7 +168,11 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) Lua::LuaTable_t table = value.GetValue(); table->ForEach([jenv, this, L, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { - jenv->CallObjectMethod(jmap, putMethod, this->ToJavaObject(L, k), this->ToJavaObject(L, v)); + jobject objk = this->ToJavaObject(L, k); + jobject objv = this->ToJavaObject(L, v); + jenv->CallObjectMethod(jmap, putMethod, objk, objv); + jenv->DeleteLocalRef(objk); + jenv->DeleteLocalRef(objv); }); jenv->DeleteLocalRef(jcls); return jmap; @@ -422,5 +426,8 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: } } this->env->DeleteLocalRef(clazz); + for (int i = 0; i < paramsLength; i++) { + this->env->DeleteLocalRef(params[i]); + } return returnValue; } \ No newline at end of file diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 8cf25a0..0ca9bac 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -129,6 +129,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteLocalRef(jcl); + jenv->DeleteLocalRef(objectCls); jenv->DeleteLocalRef(packageName); jenv->DeleteLocalRef(functionName); jenv->DeleteLocalRef(args); @@ -228,6 +229,8 @@ Plugin::Plugin() params[i - 4] = env->ToJavaObject(L, value); } jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params, arg_size - 4); + + delete[] params; if (returnValue != NULL) { Lua::LuaValue value = env->ToLuaValue(returnValue); if (!(value == NULL)) { From 5003d966236c0cf5eaf4b3d94f1fefbf9e384a4e Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:46:37 +0200 Subject: [PATCH 43/85] Debugging --- src/JavaEnv.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 1356342..b89a6ae 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -426,7 +426,7 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: } } this->env->DeleteLocalRef(clazz); - for (int i = 0; i < paramsLength; i++) { + for (size_t i = 0; i < paramsLength; i++) { this->env->DeleteLocalRef(params[i]); } return returnValue; From 727b52f6c243eadfee8be6b7ed672fe998773e04 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Fri, 10 Jul 2020 03:53:22 +0200 Subject: [PATCH 44/85] Debugging --- src/JavaEnv.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index b89a6ae..9497a24 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -58,7 +58,7 @@ JavaEnv::JavaEnv(std::string classPath) { #endif static std::stringstream optionString; - optionString << "-Djava.class.path=" << classPath; + optionString << "-Djava.class.path=" << classPath << " -Xmx256M -Xms256M"; JavaVMInitArgs vm_args; auto* options = new JavaVMOption[1]; From bd5cbe111e012d2bd72187a1c00dbdb1f377f92b Mon Sep 17 00:00:00 2001 From: JanHolger Date: Mon, 13 Jul 2020 23:43:14 +0200 Subject: [PATCH 45/85] Added test for finding the memory leak --- src/Plugin.cpp | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 0ca9bac..ba993a7 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -101,6 +101,8 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { jenv->DeleteLocalRef(argsList); } +char* lastReturn; + jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { @@ -133,9 +135,18 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->DeleteLocalRef(packageName); jenv->DeleteLocalRef(functionName); jenv->DeleteLocalRef(args); + lastReturn = (char*) returns; + printf("Test A: %c\n", lastReturn[0]); return returns; } +void TestGlobal(JNIEnv* jenv, jclass jcl) { + (void)jenv; + (void)jcl; + jenv->DeleteLocalRef(jcl); + printf("Test B: %c\n", lastReturn[0]); +} + Plugin::Plugin() { for (int i = 0; i < 30; i++) @@ -198,9 +209,10 @@ Plugin::Plugin() if (clazz == nullptr) return 0; JNINativeMethod methods[] = { {(char*)"callEvent", (char*)"(Ljava/lang/String;[Ljava/lang/Object;)V", (void*)CallEvent }, - {(char*)"callGlobalFunction", (char*)"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)[Ljava/lang/Object;", (void*)CallGlobal } + {(char*)"callGlobalFunction", (char*)"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)[Ljava/lang/Object;", (void*)CallGlobal }, + {(char*)"testGlobalFunction", (char*)"()V", (void*)TestGlobal } }; - jenv->RegisterNatives(clazz, methods, 2); + jenv->RegisterNatives(clazz, methods, 3); Lua::ReturnValues(L, 1); return 1; }); From ee428ea3aae770af9806c137bb452c08c2aa474f Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 00:11:15 +0200 Subject: [PATCH 46/85] Added test for finding the memory leak --- src/Plugin.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index ba993a7..2947a68 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -137,6 +137,8 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->DeleteLocalRef(args); lastReturn = (char*) returns; printf("Test A: %c\n", lastReturn[0]); + jenv->DeleteLocalRef(returns); + printf("Test B: %c\n", lastReturn[0]); return returns; } @@ -144,7 +146,7 @@ void TestGlobal(JNIEnv* jenv, jclass jcl) { (void)jenv; (void)jcl; jenv->DeleteLocalRef(jcl); - printf("Test B: %c\n", lastReturn[0]); + printf("Test C: %c\n", lastReturn[0]); } Plugin::Plugin() From be468be1b236f4ced9f89850e6d34a4fdd193800 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 00:18:56 +0200 Subject: [PATCH 47/85] Added test for finding the memory leak --- src/Plugin.cpp | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 2947a68..2dfc886 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -101,7 +101,7 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { jenv->DeleteLocalRef(argsList); } -char* lastReturn; +jobjectArray lastReturn; jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); @@ -135,18 +135,15 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->DeleteLocalRef(packageName); jenv->DeleteLocalRef(functionName); jenv->DeleteLocalRef(args); - lastReturn = (char*) returns; - printf("Test A: %c\n", lastReturn[0]); - jenv->DeleteLocalRef(returns); - printf("Test B: %c\n", lastReturn[0]); + lastReturn = returns; return returns; } -void TestGlobal(JNIEnv* jenv, jclass jcl) { +void CleanGlobal(JNIEnv* jenv, jclass jcl) { (void)jenv; (void)jcl; jenv->DeleteLocalRef(jcl); - printf("Test C: %c\n", lastReturn[0]); + jenv->DeleteLocalRef(lastReturn); } Plugin::Plugin() @@ -212,7 +209,7 @@ Plugin::Plugin() JNINativeMethod methods[] = { {(char*)"callEvent", (char*)"(Ljava/lang/String;[Ljava/lang/Object;)V", (void*)CallEvent }, {(char*)"callGlobalFunction", (char*)"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)[Ljava/lang/Object;", (void*)CallGlobal }, - {(char*)"testGlobalFunction", (char*)"()V", (void*)TestGlobal } + {(char*)"cleanGlobalFunction", (char*)"()V", (void*)CleanGlobal } }; jenv->RegisterNatives(clazz, methods, 3); Lua::ReturnValues(L, 1); From 0377365cc057b3598f2574fbc68fbaa4af119e8a Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 01:13:28 +0200 Subject: [PATCH 48/85] Added test for finding the memory leak --- src/JavaEnv.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 9497a24..1266d58 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -194,6 +194,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); this->env->DeleteLocalRef(packageName); + printf("Creating new LuaFunction instance\n"); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: From dfa467a48e93e7e58b532a7794a2a2ef43bfda9a Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 02:06:01 +0200 Subject: [PATCH 49/85] Added test for finding the memory leak --- src/JavaEnv.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 1266d58..9497a24 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -194,7 +194,6 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); this->env->DeleteLocalRef(packageName); - printf("Creating new LuaFunction instance\n"); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: From 09bc56c6d1e4301725ec42c8367dca7206becd67 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 19:35:18 +0200 Subject: [PATCH 50/85] Tried to fix the memory leak --- src/JavaEnv.cpp | 12 +++++++++--- src/Plugin.cpp | 8 ++++++-- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 9497a24..9e52111 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -91,6 +91,7 @@ JavaEnv::JavaEnv(std::string classPath) { void JavaEnv::LuaFunctionClose(jobject instance) { jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); int id = this->env->GetIntField(instance, fField); + this->luaFunctions[id].~LuaValue(); this->luaFunctions[id] = NULL; this->env->DeleteLocalRef(instance); } @@ -108,7 +109,8 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { int argsLength = this->env->GetArrayLength(args); Lua::PushValueToLua(this->luaFunctions[id], L); for (jsize i = 0; i < argsLength; i++) { - Lua::PushValueToLua(this->ToLuaValue(this->env->GetObjectArrayElement(args, i)), L); + Lua::LuaValue val = this->ToLuaValue(this->env->GetObjectArrayElement(args, i)); + Lua::PushValueToLua(val, L); } this->env->DeleteLocalRef(args); Lua::LuaArgs_t ReturnValues; @@ -125,6 +127,7 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { this->env->SetObjectArrayElement(returns, i, obj); this->env->DeleteLocalRef(obj); } + ReturnValues.~vector(); return returns; } return NULL; @@ -137,7 +140,9 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) { case Lua::LuaValue::Type::STRING: { - return (jobject)jenv->NewStringUTF(value.GetValue().c_str()); + jobject obj = (jobject)jenv->NewStringUTF(value.GetValue().c_str()); + value.~LuaValue(); + return obj; } break; case Lua::LuaValue::Type::INTEGER: { @@ -175,6 +180,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jenv->DeleteLocalRef(objv); }); jenv->DeleteLocalRef(jcls); + value.~LuaValue(); return jmap; } break; case Lua::LuaValue::Type::FUNCTION: @@ -194,6 +200,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); this->env->DeleteLocalRef(packageName); + value.~LuaValue(); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: @@ -202,7 +209,6 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) default: break; } - return NULL; } diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 2dfc886..225de16 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -94,6 +94,7 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { } Onset::Plugin::Get()->CallEvent(eventStr, args); + delete args; jenv->ReleaseStringUTFChars(event, eventStr); jenv->DeleteLocalRef(jcl); @@ -116,10 +117,11 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f int argsLength = jenv->GetArrayLength(args); auto luaArgs = new Lua::LuaArgs_t(); for (jsize i = 0; i < argsLength; i++) { - luaArgs->push_back(env->ToLuaValue(jenv->GetObjectArrayElement(args, i))); + Lua::LuaValue val = env->ToLuaValue(jenv->GetObjectArrayElement(args, i)); + luaArgs->push_back(val); } - auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, luaArgs); + delete luaArgs; size_t returnsLength = luaReturns.size(); jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); @@ -128,6 +130,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->SetObjectArrayElement(returns, i, obj); env->GetEnv()->DeleteLocalRef(obj); } + luaReturns.~vector(); jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteLocalRef(jcl); @@ -263,6 +266,7 @@ Plugin::Plugin() break; } } + value.~LuaValue(); } else { Lua::ReturnValues(L, 1); From 9916e5f30eb4ac961847a882ca21a53aa53684a1 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 19:54:47 +0200 Subject: [PATCH 51/85] Tried to fix the memory leak --- src/JavaEnv.cpp | 9 ++------- src/Plugin.cpp | 4 +--- 2 files changed, 3 insertions(+), 10 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 9e52111..b8e2622 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -91,7 +91,6 @@ JavaEnv::JavaEnv(std::string classPath) { void JavaEnv::LuaFunctionClose(jobject instance) { jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); int id = this->env->GetIntField(instance, fField); - this->luaFunctions[id].~LuaValue(); this->luaFunctions[id] = NULL; this->env->DeleteLocalRef(instance); } @@ -127,7 +126,6 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { this->env->SetObjectArrayElement(returns, i, obj); this->env->DeleteLocalRef(obj); } - ReturnValues.~vector(); return returns; } return NULL; @@ -141,7 +139,6 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) case Lua::LuaValue::Type::STRING: { jobject obj = (jobject)jenv->NewStringUTF(value.GetValue().c_str()); - value.~LuaValue(); return obj; } break; case Lua::LuaValue::Type::INTEGER: @@ -180,7 +177,6 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jenv->DeleteLocalRef(objv); }); jenv->DeleteLocalRef(jcls); - value.~LuaValue(); return jmap; } break; case Lua::LuaValue::Type::FUNCTION: @@ -200,7 +196,6 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); this->env->DeleteLocalRef(packageName); - value.~LuaValue(); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: @@ -292,7 +287,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(I)Ljava/lang/Object;"); jint len = jenv->CallIntMethod(object, sizeMethod); - Lua::LuaTable_t table(new Lua::LuaTable); + Lua::LuaTable_t table = Lua::LuaTable::Create(); for (jint i = 0; i < len; i++) { jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); table->Add(i + 1, this->ToLuaValue(arrayElement)); @@ -319,7 +314,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jenv->DeleteLocalRef(keySet); int arraySize = jenv->GetArrayLength(keyArray); - Lua::LuaTable_t table(new Lua::LuaTable); + Lua::LuaTable_t table = Lua::LuaTable::Create(); for (int i = 0; i < arraySize; i++) { jobject key = jenv->GetObjectArrayElement(keyArray, i); diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 225de16..741a8ef 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -84,7 +84,7 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { } const char* eventStr = jenv->GetStringUTFChars(event, nullptr); - auto args = new Lua::LuaArgs_t(); + Lua::LuaArgs_t args = Lua::LuaArgs_t(); int argsCount = jenv->GetArrayLength(argsList); @@ -130,7 +130,6 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->SetObjectArrayElement(returns, i, obj); env->GetEnv()->DeleteLocalRef(obj); } - luaReturns.~vector(); jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteLocalRef(jcl); @@ -266,7 +265,6 @@ Plugin::Plugin() break; } } - value.~LuaValue(); } else { Lua::ReturnValues(L, 1); From d5f43c067611df7f9fe4e085cf972b4953e4eaea Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 20:03:24 +0200 Subject: [PATCH 52/85] Tried to fix the memory leak --- src/Plugin.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 741a8ef..a55487e 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -84,7 +84,7 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { } const char* eventStr = jenv->GetStringUTFChars(event, nullptr); - Lua::LuaArgs_t args = Lua::LuaArgs_t(); + auto args = new Lua::LuaArgs_t(); int argsCount = jenv->GetArrayLength(argsList); @@ -265,6 +265,7 @@ Plugin::Plugin() break; } } + value.~LuaValue(); } else { Lua::ReturnValues(L, 1); From cdb5d5baddd2a9be8aebaeede0ebcab0cd395229 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Tue, 14 Jul 2020 23:03:28 +0200 Subject: [PATCH 53/85] Tried to fix the memory leak --- src/Plugin.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index a55487e..c9e5721 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -142,6 +142,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f } void CleanGlobal(JNIEnv* jenv, jclass jcl) { + printf("Cleaning!!!"); (void)jenv; (void)jcl; jenv->DeleteLocalRef(jcl); From 09581b8fdcf7ea6602913e952a6c61445c32042f Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 00:42:06 +0200 Subject: [PATCH 54/85] Tried to fix the memory leak --- src/Plugin.cpp | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index c9e5721..751acdd 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -103,8 +103,10 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { } jobjectArray lastReturn; +int dispatchCount = 0; jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { + jenv->DeleteLocalRef(jcl); JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return NULL; @@ -114,6 +116,32 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* packageNameStr = jenv->GetStringUTFChars(packageName, nullptr); const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); + + jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); + + if (strcmp(functionNameStr, "CallRemoteEvent") == 0) { + jstring str = (jstring)jenv->GetObjectArrayElement(args, 0); + const char* eventName = jenv->GetStringUTFChars(packageName, nullptr); + if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { + if (dispatchCount > 10) { + jenv->ReleaseStringUTFChars(str, eventName); + jenv->ReleaseStringUTFChars(packageName, packageNameStr); + jenv->ReleaseStringUTFChars(functionName, functionNameStr); + jenv->DeleteLocalRef(str); + jenv->DeleteLocalRef(objectCls); + jenv->DeleteLocalRef(packageName); + jenv->DeleteLocalRef(functionName); + jenv->DeleteLocalRef(args); + jobjectArray returns = jenv->NewObjectArray((jsize)0, objectCls, NULL); + lastReturn = returns; + return lastReturn; + } + dispatchCount++; + } + jenv->ReleaseStringUTFChars(str, eventName); + jenv->DeleteLocalRef(str); + } + int argsLength = jenv->GetArrayLength(args); auto luaArgs = new Lua::LuaArgs_t(); for (jsize i = 0; i < argsLength; i++) { @@ -123,7 +151,6 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, luaArgs); delete luaArgs; size_t returnsLength = luaReturns.size(); - jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); for (jsize i = 0; i < (int) returnsLength; i++) { jobject obj = env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i]); @@ -142,9 +169,6 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f } void CleanGlobal(JNIEnv* jenv, jclass jcl) { - printf("Cleaning!!!"); - (void)jenv; - (void)jcl; jenv->DeleteLocalRef(jcl); jenv->DeleteLocalRef(lastReturn); } From 24134fb2c72f8d37110b93d823d995720e0f4181 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 00:46:13 +0200 Subject: [PATCH 55/85] Tried to fix the memory leak --- src/Plugin.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 751acdd..bf035f7 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -123,7 +123,9 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jstring str = (jstring)jenv->GetObjectArrayElement(args, 0); const char* eventName = jenv->GetStringUTFChars(packageName, nullptr); if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { + printf("DISPATCH #1\n"); if (dispatchCount > 10) { + printf("DISPATCH #2\n"); jenv->ReleaseStringUTFChars(str, eventName); jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); From 4b89c07d124836b16854501389c677da940f037e Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 00:48:07 +0200 Subject: [PATCH 56/85] Tried to fix the memory leak --- src/Plugin.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index bf035f7..93b3d7a 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -118,10 +118,11 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); - + printf("SomeFunction: %s\n", functionNameStr); if (strcmp(functionNameStr, "CallRemoteEvent") == 0) { jstring str = (jstring)jenv->GetObjectArrayElement(args, 0); const char* eventName = jenv->GetStringUTFChars(packageName, nullptr); + printf("SomeEvent: %s\n", eventName); if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { printf("DISPATCH #1\n"); if (dispatchCount > 10) { From 3bff84586fe35e0c1fbd38bb2aa3f20caf89d49f Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 00:52:35 +0200 Subject: [PATCH 57/85] Tried to fix the memory leak --- src/Plugin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 93b3d7a..15791e9 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -121,7 +121,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f printf("SomeFunction: %s\n", functionNameStr); if (strcmp(functionNameStr, "CallRemoteEvent") == 0) { jstring str = (jstring)jenv->GetObjectArrayElement(args, 0); - const char* eventName = jenv->GetStringUTFChars(packageName, nullptr); + const char* eventName = jenv->GetStringUTFChars(str, nullptr); printf("SomeEvent: %s\n", eventName); if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { printf("DISPATCH #1\n"); From c8b1b38a465c8e682083ed06c3571ad9ce6cf6fe Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 00:57:21 +0200 Subject: [PATCH 58/85] Tried to fix the memory leak --- src/Plugin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 15791e9..d8078da 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -120,7 +120,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); printf("SomeFunction: %s\n", functionNameStr); if (strcmp(functionNameStr, "CallRemoteEvent") == 0) { - jstring str = (jstring)jenv->GetObjectArrayElement(args, 0); + jstring str = (jstring)jenv->GetObjectArrayElement(args, 1); const char* eventName = jenv->GetStringUTFChars(str, nullptr); printf("SomeEvent: %s\n", eventName); if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { From 72208094dcb74aeccf59deb273ce1837985e1991 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 00:59:36 +0200 Subject: [PATCH 59/85] Tried to fix the memory leak --- src/Plugin.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index d8078da..9014d8f 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -125,7 +125,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f printf("SomeEvent: %s\n", eventName); if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { printf("DISPATCH #1\n"); - if (dispatchCount > 10) { + if (dispatchCount > 20) { printf("DISPATCH #2\n"); jenv->ReleaseStringUTFChars(str, eventName); jenv->ReleaseStringUTFChars(packageName, packageNameStr); @@ -137,7 +137,8 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->DeleteLocalRef(args); jobjectArray returns = jenv->NewObjectArray((jsize)0, objectCls, NULL); lastReturn = returns; - return lastReturn; + printf("DISPATCH #3\n"); + return returns; } dispatchCount++; } From 39f4b77861a05c08c4d78a14f27735363ccd4176 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 01:00:34 +0200 Subject: [PATCH 60/85] Tried to fix the memory leak --- src/Plugin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 9014d8f..a9bc7b0 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -125,7 +125,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f printf("SomeEvent: %s\n", eventName); if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { printf("DISPATCH #1\n"); - if (dispatchCount > 20) { + if (dispatchCount > 100) { printf("DISPATCH #2\n"); jenv->ReleaseStringUTFChars(str, eventName); jenv->ReleaseStringUTFChars(packageName, packageNameStr); From afcbe742eaa1745167cdf63027c60c6c8d98a6ed Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 01:03:13 +0200 Subject: [PATCH 61/85] Tried to fix the memory leak --- src/Plugin.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index a9bc7b0..a82c6a5 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -125,19 +125,18 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f printf("SomeEvent: %s\n", eventName); if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { printf("DISPATCH #1\n"); - if (dispatchCount > 100) { + if (dispatchCount > 85) { printf("DISPATCH #2\n"); jenv->ReleaseStringUTFChars(str, eventName); jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteLocalRef(str); - jenv->DeleteLocalRef(objectCls); jenv->DeleteLocalRef(packageName); jenv->DeleteLocalRef(functionName); jenv->DeleteLocalRef(args); jobjectArray returns = jenv->NewObjectArray((jsize)0, objectCls, NULL); + jenv->DeleteLocalRef(objectCls); lastReturn = returns; - printf("DISPATCH #3\n"); return returns; } dispatchCount++; From 7ccc72cb9c18babe8724f90fe00d4ba7a9da4dde Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 01:21:25 +0200 Subject: [PATCH 62/85] Tried to fix the memory leak --- src/Plugin.cpp | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index a82c6a5..24d2607 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -84,17 +84,16 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { } const char* eventStr = jenv->GetStringUTFChars(event, nullptr); - auto args = new Lua::LuaArgs_t(); + Lua::LuaArgs_t args; int argsCount = jenv->GetArrayLength(argsList); for (jsize i = 0; i < argsCount; i++) { jobject arrayElement = jenv->GetObjectArrayElement(argsList, i); - args->push_back(env->ToLuaValue(arrayElement)); + args.push_back(env->ToLuaValue(arrayElement)); } - Onset::Plugin::Get()->CallEvent(eventStr, args); - delete args; + Onset::Plugin::Get()->CallEvent(eventStr, &args); jenv->ReleaseStringUTFChars(event, eventStr); jenv->DeleteLocalRef(jcl); @@ -118,6 +117,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); + /* printf("SomeFunction: %s\n", functionNameStr); if (strcmp(functionNameStr, "CallRemoteEvent") == 0) { jstring str = (jstring)jenv->GetObjectArrayElement(args, 1); @@ -144,15 +144,14 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->ReleaseStringUTFChars(str, eventName); jenv->DeleteLocalRef(str); } - + */ int argsLength = jenv->GetArrayLength(args); - auto luaArgs = new Lua::LuaArgs_t(); + Lua::LuaArgs_t luaArgs; for (jsize i = 0; i < argsLength; i++) { Lua::LuaValue val = env->ToLuaValue(jenv->GetObjectArrayElement(args, i)); - luaArgs->push_back(val); + luaArgs.push_back(val); } - auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, luaArgs); - delete luaArgs; + auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, &luaArgs); size_t returnsLength = luaReturns.size(); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); for (jsize i = 0; i < (int) returnsLength; i++) { From c469b58f4b74ce6b240d2b17d035a80983122ca1 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 19:40:30 +0200 Subject: [PATCH 63/85] Fixed Windows Builds --- src/CMakeLists.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 881a875..4f5ad00 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,5 +1,8 @@ set(PLUGIN_CONFIG_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/config_headers") + +if(UNIX) link_libraries(stdc++fs) +endif() configure_file( "version.hpp.in" From 06e2a34a563a252f8c851930a2e7778a319c462f Mon Sep 17 00:00:00 2001 From: JanHolger Date: Wed, 15 Jul 2020 20:35:46 +0200 Subject: [PATCH 64/85] Fixed Windows Builds --- src/JavaEnv.cpp | 118 ++++++++++++++++++++++++------------------------ src/Plugin.cpp | 36 ++------------- 2 files changed, 64 insertions(+), 90 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index b8e2622..3e8afb9 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -145,21 +145,21 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) { jclass jcls = jenv->FindClass("java/lang/Integer"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); - jenv->DeleteLocalRef(jcls); + jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::NUMBER: { jclass jcls = jenv->FindClass("java/lang/Double"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); - jenv->DeleteLocalRef(jcls); + jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::BOOLEAN: { jclass jcls = jenv->FindClass("java/lang/Boolean"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); - jenv->DeleteLocalRef(jcls); + jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::TABLE: @@ -173,10 +173,10 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jobject objk = this->ToJavaObject(L, k); jobject objv = this->ToJavaObject(L, v); jenv->CallObjectMethod(jmap, putMethod, objk, objv); - jenv->DeleteLocalRef(objk); - jenv->DeleteLocalRef(objv); + jenv->DeleteGlobalRef(objk); + jenv->DeleteGlobalRef(objv); }); - jenv->DeleteLocalRef(jcls); + jenv->DeleteGlobalRef(jcls); return jmap; } break; case Lua::LuaValue::Type::FUNCTION: @@ -195,7 +195,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) this->env->SetIntField(javaLuaFunction, fField, id); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); - this->env->DeleteLocalRef(packageName); + this->env->DeleteGlobalRef(packageName); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: @@ -226,28 +226,28 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jenv->ReleaseStringUTFChars(element, pchars); - jenv->DeleteLocalRef(element); - jenv->DeleteLocalRef(jcls); - jenv->DeleteLocalRef(stringCls); - jenv->DeleteLocalRef(integerCls); - jenv->DeleteLocalRef(doubleCls); - jenv->DeleteLocalRef(booleanCls); - jenv->DeleteLocalRef(listCls); - jenv->DeleteLocalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); return value; } else if (jenv->IsInstanceOf(object, integerCls)) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); - jenv->DeleteLocalRef(object); - jenv->DeleteLocalRef(jcls); - jenv->DeleteLocalRef(stringCls); - jenv->DeleteLocalRef(integerCls); - jenv->DeleteLocalRef(doubleCls); - jenv->DeleteLocalRef(booleanCls); - jenv->DeleteLocalRef(listCls); - jenv->DeleteLocalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; @@ -255,14 +255,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) else if (jenv->IsInstanceOf(object, doubleCls)) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); - jenv->DeleteLocalRef(object); - jenv->DeleteLocalRef(jcls); - jenv->DeleteLocalRef(stringCls); - jenv->DeleteLocalRef(integerCls); - jenv->DeleteLocalRef(doubleCls); - jenv->DeleteLocalRef(booleanCls); - jenv->DeleteLocalRef(listCls); - jenv->DeleteLocalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; @@ -270,14 +270,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) else if (jenv->IsInstanceOf(object, booleanCls)) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - jenv->DeleteLocalRef(object); - jenv->DeleteLocalRef(jcls); - jenv->DeleteLocalRef(stringCls); - jenv->DeleteLocalRef(integerCls); - jenv->DeleteLocalRef(doubleCls); - jenv->DeleteLocalRef(booleanCls); - jenv->DeleteLocalRef(listCls); - jenv->DeleteLocalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value((bool) result); return value; @@ -292,14 +292,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); table->Add(i + 1, this->ToLuaValue(arrayElement)); } - jenv->DeleteLocalRef(object); - jenv->DeleteLocalRef(jcls); - jenv->DeleteLocalRef(stringCls); - jenv->DeleteLocalRef(integerCls); - jenv->DeleteLocalRef(doubleCls); - jenv->DeleteLocalRef(booleanCls); - jenv->DeleteLocalRef(listCls); - jenv->DeleteLocalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(table); return value; } @@ -322,19 +322,19 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); } - jenv->DeleteLocalRef(keyArray); - jenv->DeleteLocalRef(object); - jenv->DeleteLocalRef(jcls); - jenv->DeleteLocalRef(stringCls); - jenv->DeleteLocalRef(integerCls); - jenv->DeleteLocalRef(doubleCls); - jenv->DeleteLocalRef(booleanCls); - jenv->DeleteLocalRef(listCls); - jenv->DeleteLocalRef(mapCls); + jenv->DeleteGlobalRef(keyArray); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(table); return value; } - + jenv->DeleteGlobalRef(object); return NULL; } @@ -426,9 +426,9 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: break; } } - this->env->DeleteLocalRef(clazz); + this->env->DeleteGlobalRef(clazz); for (size_t i = 0; i < paramsLength; i++) { - this->env->DeleteLocalRef(params[i]); + this->env->DeleteGlobalRef(params[i]); } return returnValue; } \ No newline at end of file diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 24d2607..31d8a3a 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -108,6 +108,9 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->DeleteLocalRef(jcl); JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { + jenv->DeleteLocalRef(packageName); + jenv->DeleteLocalRef(functionName); + jenv->DeleteLocalRef(args); return NULL; } @@ -117,34 +120,6 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); - /* - printf("SomeFunction: %s\n", functionNameStr); - if (strcmp(functionNameStr, "CallRemoteEvent") == 0) { - jstring str = (jstring)jenv->GetObjectArrayElement(args, 1); - const char* eventName = jenv->GetStringUTFChars(str, nullptr); - printf("SomeEvent: %s\n", eventName); - if (strcmp(eventName, "GlobalUI:DispatchToUI") == 0) { - printf("DISPATCH #1\n"); - if (dispatchCount > 85) { - printf("DISPATCH #2\n"); - jenv->ReleaseStringUTFChars(str, eventName); - jenv->ReleaseStringUTFChars(packageName, packageNameStr); - jenv->ReleaseStringUTFChars(functionName, functionNameStr); - jenv->DeleteLocalRef(str); - jenv->DeleteLocalRef(packageName); - jenv->DeleteLocalRef(functionName); - jenv->DeleteLocalRef(args); - jobjectArray returns = jenv->NewObjectArray((jsize)0, objectCls, NULL); - jenv->DeleteLocalRef(objectCls); - lastReturn = returns; - return returns; - } - dispatchCount++; - } - jenv->ReleaseStringUTFChars(str, eventName); - jenv->DeleteLocalRef(str); - } - */ int argsLength = jenv->GetArrayLength(args); Lua::LuaArgs_t luaArgs; for (jsize i = 0; i < argsLength; i++) { @@ -161,8 +136,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f } jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); - jenv->DeleteLocalRef(jcl); - jenv->DeleteLocalRef(objectCls); + jenv->DeleteGlobalRef(objectCls); jenv->DeleteLocalRef(packageName); jenv->DeleteLocalRef(functionName); jenv->DeleteLocalRef(args); @@ -172,7 +146,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f void CleanGlobal(JNIEnv* jenv, jclass jcl) { jenv->DeleteLocalRef(jcl); - jenv->DeleteLocalRef(lastReturn); + jenv->DeleteGlobalRef(lastReturn); } Plugin::Plugin() From 02ecc016667a37820bc35978fbd661e8cffd8f81 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 13:48:58 +0200 Subject: [PATCH 65/85] Added debug print --- libs/sdk | 2 +- src/Plugin.cpp | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/libs/sdk b/libs/sdk index ecbf6d0..e44cc88 160000 --- a/libs/sdk +++ b/libs/sdk @@ -1 +1 @@ -Subproject commit ecbf6d0ba1268765bf58cb953ecd5768314328c4 +Subproject commit e44cc88a1aa0a313dcadba74b08912e2b7fe02d3 diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 31d8a3a..74077c4 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -119,6 +119,8 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* packageNameStr = jenv->GetStringUTFChars(packageName, nullptr); const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); + printf("Before CallGlobal: %s", functionNameStr); + jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); int argsLength = jenv->GetArrayLength(args); Lua::LuaArgs_t luaArgs; @@ -134,6 +136,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->SetObjectArrayElement(returns, i, obj); env->GetEnv()->DeleteLocalRef(obj); } + printf("After CallGlobal: %s", functionNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteGlobalRef(objectCls); From 8d9f169bc22f2c1a9884c2c3de14678392c1bfb8 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 13:50:29 +0200 Subject: [PATCH 66/85] Added debug print --- src/Plugin.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 74077c4..3eb6530 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -119,7 +119,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* packageNameStr = jenv->GetStringUTFChars(packageName, nullptr); const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); - printf("Before CallGlobal: %s", functionNameStr); + printf("Before CallGlobal: %s\n", functionNameStr); jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); int argsLength = jenv->GetArrayLength(args); @@ -136,7 +136,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->SetObjectArrayElement(returns, i, obj); env->GetEnv()->DeleteLocalRef(obj); } - printf("After CallGlobal: %s", functionNameStr); + printf("After CallGlobal: %s\n", functionNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteGlobalRef(objectCls); From f64da3a419568ee94b8b708ed0d05178e2e1ac6b Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 14:07:23 +0200 Subject: [PATCH 67/85] Removed some memory clearing --- src/Plugin.cpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 3eb6530..14cfb59 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -101,16 +101,12 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { jenv->DeleteLocalRef(argsList); } -jobjectArray lastReturn; int dispatchCount = 0; jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { jenv->DeleteLocalRef(jcl); JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { - jenv->DeleteLocalRef(packageName); - jenv->DeleteLocalRef(functionName); - jenv->DeleteLocalRef(args); return NULL; } @@ -140,16 +136,11 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteGlobalRef(objectCls); - jenv->DeleteLocalRef(packageName); - jenv->DeleteLocalRef(functionName); - jenv->DeleteLocalRef(args); - lastReturn = returns; return returns; } void CleanGlobal(JNIEnv* jenv, jclass jcl) { jenv->DeleteLocalRef(jcl); - jenv->DeleteGlobalRef(lastReturn); } Plugin::Plugin() From 2579996d3834a7d25bcc9c63a2427b06177a74df Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 14:10:40 +0200 Subject: [PATCH 68/85] Removed some memory clearing --- src/Plugin.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 14cfb59..75e317b 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -136,6 +136,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); jenv->DeleteGlobalRef(objectCls); + printf("Testing"); return returns; } From a51e166741c15a13e07b7c6c7e82892c299cdb3f Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 14:13:21 +0200 Subject: [PATCH 69/85] Removed some memory clearing --- src/Plugin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 75e317b..2029d89 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -135,7 +135,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f printf("After CallGlobal: %s\n", functionNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); jenv->ReleaseStringUTFChars(functionName, functionNameStr); - jenv->DeleteGlobalRef(objectCls); + //jenv->DeleteGlobalRef(objectCls); printf("Testing"); return returns; } From c38ce1ad69217d8f94e76f5a828020d190cad9c9 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 14:16:48 +0200 Subject: [PATCH 70/85] Removed some memory clearing --- src/Plugin.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 2029d89..687050a 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -134,9 +134,10 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f } printf("After CallGlobal: %s\n", functionNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); + printf("FuckYouJava\n"); jenv->ReleaseStringUTFChars(functionName, functionNameStr); //jenv->DeleteGlobalRef(objectCls); - printf("Testing"); + printf("Testing\n"); return returns; } From e496b5e150b4176b0a70c9ee4e401def3bd842e4 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 14:41:59 +0200 Subject: [PATCH 71/85] Removed some memory clearing --- src/JavaEnv.cpp | 14 +++++++------- src/Plugin.cpp | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 3e8afb9..38bf343 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -145,21 +145,21 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) { jclass jcls = jenv->FindClass("java/lang/Integer"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); - jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::NUMBER: { jclass jcls = jenv->FindClass("java/lang/Double"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); - jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::BOOLEAN: { jclass jcls = jenv->FindClass("java/lang/Boolean"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); - jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::TABLE: @@ -173,10 +173,10 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jobject objk = this->ToJavaObject(L, k); jobject objv = this->ToJavaObject(L, v); jenv->CallObjectMethod(jmap, putMethod, objk, objv); - jenv->DeleteGlobalRef(objk); - jenv->DeleteGlobalRef(objv); + //jenv->DeleteGlobalRef(objk); + //jenv->DeleteGlobalRef(objv); }); - jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(jcls); return jmap; } break; case Lua::LuaValue::Type::FUNCTION: @@ -195,7 +195,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) this->env->SetIntField(javaLuaFunction, fField, id); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); - this->env->DeleteGlobalRef(packageName); + //this->env->DeleteGlobalRef(packageName); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 687050a..8e4fe0e 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -130,7 +130,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f for (jsize i = 0; i < (int) returnsLength; i++) { jobject obj = env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i]); jenv->SetObjectArrayElement(returns, i, obj); - env->GetEnv()->DeleteLocalRef(obj); + //env->GetEnv()->DeleteLocalRef(obj); } printf("After CallGlobal: %s\n", functionNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); From 1953c2ab19ce8a0287a153e6c11a365a078a7573 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 14:51:46 +0200 Subject: [PATCH 72/85] Removed some memory clearing --- src/JavaEnv.cpp | 106 ++++++++++++++++++++++++------------------------ src/Plugin.cpp | 15 +++---- 2 files changed, 61 insertions(+), 60 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 38bf343..de882e5 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -226,28 +226,28 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jenv->ReleaseStringUTFChars(element, pchars); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + //jenv->DeleteGlobalRef(object); + //jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(stringCls); + //jenv->DeleteGlobalRef(integerCls); + //jenv->DeleteGlobalRef(doubleCls); + //jenv->DeleteGlobalRef(booleanCls); + //jenv->DeleteGlobalRef(listCls); + //jenv->DeleteGlobalRef(mapCls); return value; } else if (jenv->IsInstanceOf(object, integerCls)) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + //jenv->DeleteGlobalRef(object); + //jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(stringCls); + //jenv->DeleteGlobalRef(integerCls); + //jenv->DeleteGlobalRef(doubleCls); + //jenv->DeleteGlobalRef(booleanCls); + //jenv->DeleteGlobalRef(listCls); + //jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; @@ -255,14 +255,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) else if (jenv->IsInstanceOf(object, doubleCls)) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + //jenv->DeleteGlobalRef(object); + //jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(stringCls); + //jenv->DeleteGlobalRef(integerCls); + //jenv->DeleteGlobalRef(doubleCls); + //jenv->DeleteGlobalRef(booleanCls); + //jenv->DeleteGlobalRef(listCls); + //jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; @@ -270,14 +270,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) else if (jenv->IsInstanceOf(object, booleanCls)) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + //jenv->DeleteGlobalRef(object); + //jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(stringCls); + //jenv->DeleteGlobalRef(integerCls); + //jenv->DeleteGlobalRef(doubleCls); + //jenv->DeleteGlobalRef(booleanCls); + //jenv->DeleteGlobalRef(listCls); + //jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value((bool) result); return value; @@ -292,14 +292,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); table->Add(i + 1, this->ToLuaValue(arrayElement)); } - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + //jenv->DeleteGlobalRef(object); + //jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(stringCls); + //jenv->DeleteGlobalRef(integerCls); + //jenv->DeleteGlobalRef(doubleCls); + //jenv->DeleteGlobalRef(booleanCls); + //jenv->DeleteGlobalRef(listCls); + //jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(table); return value; } @@ -311,7 +311,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jmethodID keySetToArrayMethod = jenv->GetMethodID(jenv->GetObjectClass(keySet), "toArray", "()[Ljava/lang/Object;"); jobjectArray keyArray = (jobjectArray)jenv->CallObjectMethod(keySet, keySetToArrayMethod); - jenv->DeleteLocalRef(keySet); + //jenv->DeleteLocalRef(keySet); int arraySize = jenv->GetArrayLength(keyArray); Lua::LuaTable_t table = Lua::LuaTable::Create(); @@ -322,19 +322,19 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); } - jenv->DeleteGlobalRef(keyArray); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + //jenv->DeleteGlobalRef(keyArray); + //jenv->DeleteGlobalRef(object); + //jenv->DeleteGlobalRef(jcls); + //jenv->DeleteGlobalRef(stringCls); + //jenv->DeleteGlobalRef(integerCls); + //jenv->DeleteGlobalRef(doubleCls); + //jenv->DeleteGlobalRef(booleanCls); + //jenv->DeleteGlobalRef(listCls); + //jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(table); return value; } - jenv->DeleteGlobalRef(object); + //jenv->DeleteGlobalRef(object); return NULL; } @@ -426,9 +426,9 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: break; } } - this->env->DeleteGlobalRef(clazz); + //this->env->DeleteGlobalRef(clazz); for (size_t i = 0; i < paramsLength; i++) { - this->env->DeleteGlobalRef(params[i]); + //this->env->DeleteGlobalRef(params[i]); } return returnValue; } \ No newline at end of file diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 8e4fe0e..bd3858e 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -96,15 +96,15 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { Onset::Plugin::Get()->CallEvent(eventStr, &args); jenv->ReleaseStringUTFChars(event, eventStr); - jenv->DeleteLocalRef(jcl); - jenv->DeleteLocalRef(event); - jenv->DeleteLocalRef(argsList); + //jenv->DeleteLocalRef(jcl); + //jenv->DeleteLocalRef(event); + //jenv->DeleteLocalRef(argsList); } int dispatchCount = 0; jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { - jenv->DeleteLocalRef(jcl); + //jenv->DeleteLocalRef(jcl); JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return NULL; @@ -133,16 +133,17 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f //env->GetEnv()->DeleteLocalRef(obj); } printf("After CallGlobal: %s\n", functionNameStr); - jenv->ReleaseStringUTFChars(packageName, packageNameStr); + //jenv->ReleaseStringUTFChars(packageName, packageNameStr); printf("FuckYouJava\n"); - jenv->ReleaseStringUTFChars(functionName, functionNameStr); + //jenv->ReleaseStringUTFChars(functionName, functionNameStr); //jenv->DeleteGlobalRef(objectCls); printf("Testing\n"); return returns; } void CleanGlobal(JNIEnv* jenv, jclass jcl) { - jenv->DeleteLocalRef(jcl); + jenv; + jcl; } Plugin::Plugin() From f1abe062bcb08071f11c195a9a84bb7e5e1693f6 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 14:54:01 +0200 Subject: [PATCH 73/85] Removed some memory clearing --- src/Plugin.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index bd3858e..6669603 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -78,6 +78,7 @@ JavaEnv* Plugin::FindJavaEnv(JNIEnv* jenv) { } void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { + (void)jcl; JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return; @@ -95,7 +96,7 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { Onset::Plugin::Get()->CallEvent(eventStr, &args); - jenv->ReleaseStringUTFChars(event, eventStr); + //jenv->ReleaseStringUTFChars(event, eventStr); //jenv->DeleteLocalRef(jcl); //jenv->DeleteLocalRef(event); //jenv->DeleteLocalRef(argsList); @@ -142,8 +143,8 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f } void CleanGlobal(JNIEnv* jenv, jclass jcl) { - jenv; - jcl; + (void) jenv; + (void) jcl; } Plugin::Plugin() From df45709c8a3222bac1a2e0561bb0c3d1470dcfe4 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 15:09:55 +0200 Subject: [PATCH 74/85] Revert "Removed some memory clearing" This reverts commit f1abe062bcb08071f11c195a9a84bb7e5e1693f6. --- src/Plugin.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 6669603..bd3858e 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -78,7 +78,6 @@ JavaEnv* Plugin::FindJavaEnv(JNIEnv* jenv) { } void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { - (void)jcl; JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return; @@ -96,7 +95,7 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { Onset::Plugin::Get()->CallEvent(eventStr, &args); - //jenv->ReleaseStringUTFChars(event, eventStr); + jenv->ReleaseStringUTFChars(event, eventStr); //jenv->DeleteLocalRef(jcl); //jenv->DeleteLocalRef(event); //jenv->DeleteLocalRef(argsList); @@ -143,8 +142,8 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f } void CleanGlobal(JNIEnv* jenv, jclass jcl) { - (void) jenv; - (void) jcl; + jenv; + jcl; } Plugin::Plugin() From 58d7bfd6e02833dc71e3507dcc5b9b01e4dc63ee Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 15:12:03 +0200 Subject: [PATCH 75/85] Revert "Removed some memory clearing" This reverts commit 1953c2ab19ce8a0287a153e6c11a365a078a7573. --- src/JavaEnv.cpp | 106 ++++++++++++++++++++++++------------------------ src/Plugin.cpp | 15 ++++--- 2 files changed, 60 insertions(+), 61 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index de882e5..38bf343 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -226,28 +226,28 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jenv->ReleaseStringUTFChars(element, pchars); - //jenv->DeleteGlobalRef(object); - //jenv->DeleteGlobalRef(jcls); - //jenv->DeleteGlobalRef(stringCls); - //jenv->DeleteGlobalRef(integerCls); - //jenv->DeleteGlobalRef(doubleCls); - //jenv->DeleteGlobalRef(booleanCls); - //jenv->DeleteGlobalRef(listCls); - //jenv->DeleteGlobalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); return value; } else if (jenv->IsInstanceOf(object, integerCls)) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); - //jenv->DeleteGlobalRef(object); - //jenv->DeleteGlobalRef(jcls); - //jenv->DeleteGlobalRef(stringCls); - //jenv->DeleteGlobalRef(integerCls); - //jenv->DeleteGlobalRef(doubleCls); - //jenv->DeleteGlobalRef(booleanCls); - //jenv->DeleteGlobalRef(listCls); - //jenv->DeleteGlobalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; @@ -255,14 +255,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) else if (jenv->IsInstanceOf(object, doubleCls)) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); - //jenv->DeleteGlobalRef(object); - //jenv->DeleteGlobalRef(jcls); - //jenv->DeleteGlobalRef(stringCls); - //jenv->DeleteGlobalRef(integerCls); - //jenv->DeleteGlobalRef(doubleCls); - //jenv->DeleteGlobalRef(booleanCls); - //jenv->DeleteGlobalRef(listCls); - //jenv->DeleteGlobalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; @@ -270,14 +270,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) else if (jenv->IsInstanceOf(object, booleanCls)) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - //jenv->DeleteGlobalRef(object); - //jenv->DeleteGlobalRef(jcls); - //jenv->DeleteGlobalRef(stringCls); - //jenv->DeleteGlobalRef(integerCls); - //jenv->DeleteGlobalRef(doubleCls); - //jenv->DeleteGlobalRef(booleanCls); - //jenv->DeleteGlobalRef(listCls); - //jenv->DeleteGlobalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value((bool) result); return value; @@ -292,14 +292,14 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); table->Add(i + 1, this->ToLuaValue(arrayElement)); } - //jenv->DeleteGlobalRef(object); - //jenv->DeleteGlobalRef(jcls); - //jenv->DeleteGlobalRef(stringCls); - //jenv->DeleteGlobalRef(integerCls); - //jenv->DeleteGlobalRef(doubleCls); - //jenv->DeleteGlobalRef(booleanCls); - //jenv->DeleteGlobalRef(listCls); - //jenv->DeleteGlobalRef(mapCls); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(table); return value; } @@ -311,7 +311,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jmethodID keySetToArrayMethod = jenv->GetMethodID(jenv->GetObjectClass(keySet), "toArray", "()[Ljava/lang/Object;"); jobjectArray keyArray = (jobjectArray)jenv->CallObjectMethod(keySet, keySetToArrayMethod); - //jenv->DeleteLocalRef(keySet); + jenv->DeleteLocalRef(keySet); int arraySize = jenv->GetArrayLength(keyArray); Lua::LuaTable_t table = Lua::LuaTable::Create(); @@ -322,19 +322,19 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); } - //jenv->DeleteGlobalRef(keyArray); - //jenv->DeleteGlobalRef(object); - //jenv->DeleteGlobalRef(jcls); - //jenv->DeleteGlobalRef(stringCls); - //jenv->DeleteGlobalRef(integerCls); - //jenv->DeleteGlobalRef(doubleCls); - //jenv->DeleteGlobalRef(booleanCls); - //jenv->DeleteGlobalRef(listCls); - //jenv->DeleteGlobalRef(mapCls); + jenv->DeleteGlobalRef(keyArray); + jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringCls); + jenv->DeleteGlobalRef(integerCls); + jenv->DeleteGlobalRef(doubleCls); + jenv->DeleteGlobalRef(booleanCls); + jenv->DeleteGlobalRef(listCls); + jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(table); return value; } - //jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(object); return NULL; } @@ -426,9 +426,9 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: break; } } - //this->env->DeleteGlobalRef(clazz); + this->env->DeleteGlobalRef(clazz); for (size_t i = 0; i < paramsLength; i++) { - //this->env->DeleteGlobalRef(params[i]); + this->env->DeleteGlobalRef(params[i]); } return returnValue; } \ No newline at end of file diff --git a/src/Plugin.cpp b/src/Plugin.cpp index bd3858e..8e4fe0e 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -96,15 +96,15 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { Onset::Plugin::Get()->CallEvent(eventStr, &args); jenv->ReleaseStringUTFChars(event, eventStr); - //jenv->DeleteLocalRef(jcl); - //jenv->DeleteLocalRef(event); - //jenv->DeleteLocalRef(argsList); + jenv->DeleteLocalRef(jcl); + jenv->DeleteLocalRef(event); + jenv->DeleteLocalRef(argsList); } int dispatchCount = 0; jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { - //jenv->DeleteLocalRef(jcl); + jenv->DeleteLocalRef(jcl); JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return NULL; @@ -133,17 +133,16 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f //env->GetEnv()->DeleteLocalRef(obj); } printf("After CallGlobal: %s\n", functionNameStr); - //jenv->ReleaseStringUTFChars(packageName, packageNameStr); + jenv->ReleaseStringUTFChars(packageName, packageNameStr); printf("FuckYouJava\n"); - //jenv->ReleaseStringUTFChars(functionName, functionNameStr); + jenv->ReleaseStringUTFChars(functionName, functionNameStr); //jenv->DeleteGlobalRef(objectCls); printf("Testing\n"); return returns; } void CleanGlobal(JNIEnv* jenv, jclass jcl) { - jenv; - jcl; + jenv->DeleteLocalRef(jcl); } Plugin::Plugin() From 12514488cda0ba6181465fb308410102137d5cf0 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 15:12:44 +0200 Subject: [PATCH 76/85] Revert "Removed some memory clearing" This reverts commit e496b5e150b4176b0a70c9ee4e401def3bd842e4. --- src/JavaEnv.cpp | 14 +++++++------- src/Plugin.cpp | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 38bf343..3e8afb9 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -145,21 +145,21 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) { jclass jcls = jenv->FindClass("java/lang/Integer"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); - //jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::NUMBER: { jclass jcls = jenv->FindClass("java/lang/Double"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); - //jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::BOOLEAN: { jclass jcls = jenv->FindClass("java/lang/Boolean"); jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); - //jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(jcls); return obj; } break; case Lua::LuaValue::Type::TABLE: @@ -173,10 +173,10 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jobject objk = this->ToJavaObject(L, k); jobject objv = this->ToJavaObject(L, v); jenv->CallObjectMethod(jmap, putMethod, objk, objv); - //jenv->DeleteGlobalRef(objk); - //jenv->DeleteGlobalRef(objv); + jenv->DeleteGlobalRef(objk); + jenv->DeleteGlobalRef(objv); }); - //jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(jcls); return jmap; } break; case Lua::LuaValue::Type::FUNCTION: @@ -195,7 +195,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) this->env->SetIntField(javaLuaFunction, fField, id); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); - //this->env->DeleteGlobalRef(packageName); + this->env->DeleteGlobalRef(packageName); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 8e4fe0e..687050a 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -130,7 +130,7 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f for (jsize i = 0; i < (int) returnsLength; i++) { jobject obj = env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i]); jenv->SetObjectArrayElement(returns, i, obj); - //env->GetEnv()->DeleteLocalRef(obj); + env->GetEnv()->DeleteLocalRef(obj); } printf("After CallGlobal: %s\n", functionNameStr); jenv->ReleaseStringUTFChars(packageName, packageNameStr); From cf012e0202c285b6656264809c29e64b82eb8fc8 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 15:46:17 +0200 Subject: [PATCH 77/85] Reverted to before the memory leak fixing --- src/JavaEnv.cpp | 150 ++++++++------------------------- src/JavaEnv.hpp | 1 - src/Plugin.cpp | 220 +++++++++++++++++++++--------------------------- src/Plugin.hpp | 8 +- 4 files changed, 139 insertions(+), 240 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 3e8afb9..dfb636b 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -30,7 +30,7 @@ jobjectArray JLuaFunctionCall(JNIEnv* jenv, jobject instance, jobjectArray args) JavaEnv::JavaEnv(std::string classPath) { this->env = nullptr; this->vm = nullptr; - #ifdef _WIN32 +#ifdef _WIN32 char inputJdkDll[] = "%JAVA_HOME%\\jre\\bin\\server\\jvm.dll"; TCHAR outputJdkDll[32000]; DWORD jdkResult = ExpandEnvironmentStrings((LPCTSTR)inputJdkDll, outputJdkDll, sizeof(outputJdkDll) / sizeof(*outputJdkDll)); @@ -55,10 +55,10 @@ JavaEnv::JavaEnv(std::string classPath) { Onset::Plugin::Get()->Log("Failed to find JDK/JRE jvm.dll, please ensure Java 8 is installed."); return; } - #endif +#endif static std::stringstream optionString; - optionString << "-Djava.class.path=" << classPath << " -Xmx256M -Xms256M"; + optionString << "-Djava.class.path=" << classPath; JavaVMInitArgs vm_args; auto* options = new JavaVMOption[1]; @@ -71,12 +71,12 @@ JavaEnv::JavaEnv(std::string classPath) { vm_args.options = options; vm_args.ignoreUnrecognized = false; - #ifdef __linux__ - int res = JNI_CreateJavaVM(&this->vm, (void**)&this->env, &vm_args); - #elif _WIN32 - int res = createJavaVMFunction(&this->vm, (void**)&this->env, &vm_args); - printf("CreateJava Return: %d", res); - #endif +#ifdef __linux__ + int res = JNI_CreateJavaVM(&this->vm, (void**)&this->env, &vm_args); +#elif _WIN32 + int res = createJavaVMFunction(&this->vm, (void**)&this->env, &vm_args); + printf("CreateJava Return: %d", res); +#endif this->luaFunctionClass = this->env->FindClass("lua/LuaFunction"); if (this->luaFunctionClass != NULL) { @@ -92,26 +92,21 @@ void JavaEnv::LuaFunctionClose(jobject instance) { jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); int id = this->env->GetIntField(instance, fField); this->luaFunctions[id] = NULL; - this->env->DeleteLocalRef(instance); } jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jfieldID fField = this->env->GetFieldID(this->luaFunctionClass, "f", "I"); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); int id = this->env->GetIntField(instance, fField); - jstring packageName = (jstring) this->env->GetObjectField(instance, pField); + jstring packageName = (jstring)this->env->GetObjectField(instance, pField); const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); - this->env->ReleaseStringUTFChars(packageName, packageNameStr); this->env->DeleteLocalRef(packageName); - this->env->DeleteLocalRef(instance); int argsLength = this->env->GetArrayLength(args); Lua::PushValueToLua(this->luaFunctions[id], L); for (jsize i = 0; i < argsLength; i++) { - Lua::LuaValue val = this->ToLuaValue(this->env->GetObjectArrayElement(args, i)); - Lua::PushValueToLua(val, L); + Lua::PushValueToLua(this->ToLuaValue(this->env->GetObjectArrayElement(args, i)), L); } - this->env->DeleteLocalRef(args); Lua::LuaArgs_t ReturnValues; int status = lua_pcall(L, argsLength, LUA_MULTRET, 0); if (status == LUA_OK) { @@ -120,11 +115,8 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { lua_pop(L, (int)returnCount); jclass objectCls = this->env->FindClass("Ljava/lang/Object;"); jobjectArray returns = this->env->NewObjectArray((jsize)returnCount, objectCls, NULL); - this->env->DeleteLocalRef(objectCls); - for (jsize i = 0; i < (int) returnCount; i++) { - jobject obj = this->ToJavaObject(L, ReturnValues[i]); - this->env->SetObjectArrayElement(returns, i, obj); - this->env->DeleteLocalRef(obj); + for (jsize i = 0; i < (int)returnCount; i++) { + this->env->SetObjectArrayElement(returns, i, this->ToJavaObject(L, ReturnValues[i])); } return returns; } @@ -138,29 +130,22 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) { case Lua::LuaValue::Type::STRING: { - jobject obj = (jobject)jenv->NewStringUTF(value.GetValue().c_str()); - return obj; + return (jobject)jenv->NewStringUTF(value.GetValue().c_str()); } break; case Lua::LuaValue::Type::INTEGER: { jclass jcls = jenv->FindClass("java/lang/Integer"); - jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); - jenv->DeleteGlobalRef(jcls); - return obj; + return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(I)V"), value.GetValue()); } break; case Lua::LuaValue::Type::NUMBER: { jclass jcls = jenv->FindClass("java/lang/Double"); - jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); - jenv->DeleteGlobalRef(jcls); - return obj; + return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(D)V"), value.GetValue()); } break; case Lua::LuaValue::Type::BOOLEAN: { jclass jcls = jenv->FindClass("java/lang/Boolean"); - jobject obj = jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); - jenv->DeleteGlobalRef(jcls); - return obj; + return jenv->NewObject(jcls, jenv->GetMethodID(jcls, "", "(Z)V"), value.GetValue()); } break; case Lua::LuaValue::Type::TABLE: { @@ -170,13 +155,9 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) Lua::LuaTable_t table = value.GetValue(); table->ForEach([jenv, this, L, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { - jobject objk = this->ToJavaObject(L, k); - jobject objv = this->ToJavaObject(L, v); - jenv->CallObjectMethod(jmap, putMethod, objk, objv); - jenv->DeleteGlobalRef(objk); - jenv->DeleteGlobalRef(objv); + jenv->CallObjectMethod(jmap, putMethod, this->ToJavaObject(L, k), this->ToJavaObject(L, v)); }); - jenv->DeleteGlobalRef(jcls); + return jmap; } break; case Lua::LuaValue::Type::FUNCTION: @@ -187,7 +168,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) jstring packageName = this->env->NewStringUTF(packageNameStr.c_str()); jobject javaLuaFunction = jenv->NewObject(this->luaFunctionClass, jenv->GetMethodID(this->luaFunctionClass, "", "()V")); int id = 1; - while (this->luaFunctions.count(id)){ + while (this->luaFunctions.count(id)) { id++; } this->luaFunctions[id] = value; @@ -195,7 +176,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) this->env->SetIntField(javaLuaFunction, fField, id); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); - this->env->DeleteGlobalRef(packageName); + this->env->DeleteLocalRef(packageName); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: @@ -204,6 +185,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) default: break; } + return NULL; } @@ -211,99 +193,54 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) { JNIEnv* jenv = this->GetEnv(); jclass jcls = jenv->GetObjectClass(object); - jclass stringCls = jenv->FindClass("java/lang/String"); - jclass integerCls = jenv->FindClass("java/lang/Integer"); - jclass doubleCls = jenv->FindClass("java/lang/Double"); - jclass booleanCls = jenv->FindClass("java/lang/Boolean"); - jclass listCls = jenv->FindClass("java/util/List"); - jclass mapCls = jenv->FindClass("java/util/Map"); - - if (jenv->IsInstanceOf(object, stringCls)) { + + if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/String"))) { jstring element = (jstring)object; const char* pchars = jenv->GetStringUTFChars(element, nullptr); Lua::LuaValue value(pchars); jenv->ReleaseStringUTFChars(element, pchars); - - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + jenv->DeleteLocalRef(element); return value; } - else if (jenv->IsInstanceOf(object, integerCls)) { + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Integer"))) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; } - else if (jenv->IsInstanceOf(object, doubleCls)) { + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Double"))) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); Lua::LuaValue value(result); return value; } - else if (jenv->IsInstanceOf(object, booleanCls)) { + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); - - Lua::LuaValue value((bool) result); + + Lua::LuaValue value((bool)result); return value; } - else if (jenv->IsInstanceOf(object, listCls)) { + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/List"))) { jmethodID sizeMethod = jenv->GetMethodID(jcls, "size", "()I"); jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(I)Ljava/lang/Object;"); jint len = jenv->CallIntMethod(object, sizeMethod); - Lua::LuaTable_t table = Lua::LuaTable::Create(); + Lua::LuaTable_t table(new Lua::LuaTable); for (jint i = 0; i < len; i++) { jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); table->Add(i + 1, this->ToLuaValue(arrayElement)); } - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + Lua::LuaValue value(table); return value; } - else if (jenv->IsInstanceOf(object, mapCls)) { + else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/Map"))) { jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(Ljava/lang/Object;)Ljava/lang/Object;"); jmethodID keySetMethod = jenv->GetMethodID(jcls, "keySet", "()Ljava/util/Set;"); @@ -311,10 +248,9 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jmethodID keySetToArrayMethod = jenv->GetMethodID(jenv->GetObjectClass(keySet), "toArray", "()[Ljava/lang/Object;"); jobjectArray keyArray = (jobjectArray)jenv->CallObjectMethod(keySet, keySetToArrayMethod); - jenv->DeleteLocalRef(keySet); int arraySize = jenv->GetArrayLength(keyArray); - Lua::LuaTable_t table = Lua::LuaTable::Create(); + Lua::LuaTable_t table(new Lua::LuaTable); for (int i = 0; i < arraySize; i++) { jobject key = jenv->GetObjectArrayElement(keyArray, i); @@ -322,19 +258,11 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); } - jenv->DeleteGlobalRef(keyArray); - jenv->DeleteGlobalRef(object); - jenv->DeleteGlobalRef(jcls); - jenv->DeleteGlobalRef(stringCls); - jenv->DeleteGlobalRef(integerCls); - jenv->DeleteGlobalRef(doubleCls); - jenv->DeleteGlobalRef(booleanCls); - jenv->DeleteGlobalRef(listCls); - jenv->DeleteGlobalRef(mapCls); + Lua::LuaValue value(table); return value; } - jenv->DeleteGlobalRef(object); + return NULL; } @@ -426,9 +354,5 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: break; } } - this->env->DeleteGlobalRef(clazz); - for (size_t i = 0; i < paramsLength; i++) { - this->env->DeleteGlobalRef(params[i]); - } return returnValue; } \ No newline at end of file diff --git a/src/JavaEnv.hpp b/src/JavaEnv.hpp index 2dab212..eb0580b 100644 --- a/src/JavaEnv.hpp +++ b/src/JavaEnv.hpp @@ -29,4 +29,3 @@ class JavaEnv void LuaFunctionClose(jobject instance); jobject CallStatic(std::string className, std::string methodName, std::string signature, jobject* params, size_t paramsLength); }; - diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 687050a..2ef61e2 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -7,7 +7,7 @@ namespace fs = std::filesystem; #ifdef _WIN32 - #include +#include #endif #include "Plugin.hpp" @@ -18,14 +18,10 @@ namespace fs = std::filesystem; #define LUA_DEFINE(name) Define(#name, [](lua_State *L) -> int #ifdef _WIN32 - typedef UINT(CALLBACK* JVMDLLFunction)(JavaVM**, void**, JavaVMInitArgs*); +typedef UINT(CALLBACK* JVMDLLFunction)(JavaVM**, void**, JavaVMInitArgs*); #endif Lua::LuaArgs_t CallLuaFunction(lua_State* ScriptVM, const char* LuaFunctionName, Lua::LuaArgs_t* Arguments) { - Lua::LuaArgs_t stack; - Lua::ParseArguments(ScriptVM, stack); - int stack_size = static_cast(stack.size()); - lua_pop(ScriptVM, stack_size); Lua::LuaArgs_t ReturnValues; int ArgCount = lua_gettop(ScriptVM); lua_getglobal(ScriptVM, LuaFunctionName); @@ -82,29 +78,25 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { if (env == nullptr) { return; } + (void)jcl; const char* eventStr = jenv->GetStringUTFChars(event, nullptr); - Lua::LuaArgs_t args; + auto args = new Lua::LuaArgs_t(); int argsCount = jenv->GetArrayLength(argsList); for (jsize i = 0; i < argsCount; i++) { jobject arrayElement = jenv->GetObjectArrayElement(argsList, i); - args.push_back(env->ToLuaValue(arrayElement)); + args->push_back(env->ToLuaValue(arrayElement)); } - Onset::Plugin::Get()->CallEvent(eventStr, &args); + Onset::Plugin::Get()->CallEvent(eventStr, args); jenv->ReleaseStringUTFChars(event, eventStr); - jenv->DeleteLocalRef(jcl); jenv->DeleteLocalRef(event); - jenv->DeleteLocalRef(argsList); } -int dispatchCount = 0; - jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { - jenv->DeleteLocalRef(jcl); JavaEnv* env = Plugin::Get()->FindJavaEnv(jenv); if (env == nullptr) { return NULL; @@ -114,37 +106,24 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* packageNameStr = jenv->GetStringUTFChars(packageName, nullptr); const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); - - printf("Before CallGlobal: %s\n", functionNameStr); - - jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); int argsLength = jenv->GetArrayLength(args); - Lua::LuaArgs_t luaArgs; + auto luaArgs = new Lua::LuaArgs_t(); for (jsize i = 0; i < argsLength; i++) { - Lua::LuaValue val = env->ToLuaValue(jenv->GetObjectArrayElement(args, i)); - luaArgs.push_back(val); + luaArgs->push_back(env->ToLuaValue(jenv->GetObjectArrayElement(args, i))); } - auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, &luaArgs); + + auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, luaArgs); size_t returnsLength = luaReturns.size(); + jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); - for (jsize i = 0; i < (int) returnsLength; i++) { - jobject obj = env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i]); - jenv->SetObjectArrayElement(returns, i, obj); - env->GetEnv()->DeleteLocalRef(obj); + for (jsize i = 0; i < (int)returnsLength; i++) { + jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i])); } - printf("After CallGlobal: %s\n", functionNameStr); - jenv->ReleaseStringUTFChars(packageName, packageNameStr); - printf("FuckYouJava\n"); - jenv->ReleaseStringUTFChars(functionName, functionNameStr); - //jenv->DeleteGlobalRef(objectCls); - printf("Testing\n"); + jenv->DeleteLocalRef(packageName); + jenv->DeleteLocalRef(functionName); return returns; } -void CleanGlobal(JNIEnv* jenv, jclass jcl) { - jenv->DeleteLocalRef(jcl); -} - Plugin::Plugin() { for (int i = 0; i < 30; i++) @@ -157,7 +136,8 @@ Plugin::Plugin() int id = -1; if (args.size() > 0) { id = Plugin::Get()->CreateJava(args[0].GetValue()); - } else { + } + else { std::string classPath = "."; if (fs::exists("java")) { classPath = "java"; @@ -182,91 +162,87 @@ Plugin::Plugin() return Lua::ReturnValues(L, id); }); - LUA_DEFINE(DestroyJava) - { - int id; - Lua::ParseArguments(L, id); - Plugin::Get()->DestroyJava(id); - return 1; - }); - - LUA_DEFINE(LinkJavaAdapter) - { - int id; - Lua::ParseArguments(L, id); - if (!Plugin::Get()->GetJavaEnv(id)) return 0; - JNIEnv* jenv = Plugin::Get()->GetJavaEnv(id)->GetEnv(); - Lua::LuaArgs_t arg_list; - Lua::ParseArguments(L, arg_list); - - int arg_size = static_cast(arg_list.size()); - if (arg_size < 2) return 0; - - std::string className = arg_list[1].GetValue(); - jclass clazz = jenv->FindClass(className.c_str()); - if (clazz == nullptr) return 0; - JNINativeMethod methods[] = { - {(char*)"callEvent", (char*)"(Ljava/lang/String;[Ljava/lang/Object;)V", (void*)CallEvent }, - {(char*)"callGlobalFunction", (char*)"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)[Ljava/lang/Object;", (void*)CallGlobal }, - {(char*)"cleanGlobalFunction", (char*)"()V", (void*)CleanGlobal } - }; - jenv->RegisterNatives(clazz, methods, 3); - Lua::ReturnValues(L, 1); - return 1; - }); - - LUA_DEFINE(CallJavaStaticMethod) - { - int id; - Lua::ParseArguments(L, id); - - if (!Plugin::Get()->GetJavaEnv(id)) return 0; - JavaEnv* env = Plugin::Get()->GetJavaEnv(id); - - Lua::LuaArgs_t arg_list; - Lua::ParseArguments(L, arg_list); - - int arg_size = static_cast(arg_list.size()); - if (arg_size < 4) return 0; - lua_pop(L, arg_size); - - std::string className = arg_list[1].GetValue(); - std::string methodName = arg_list[2].GetValue(); - std::string signature = arg_list[3].GetValue(); - jobject* params = new jobject[arg_size - 4]; - for (int i = 4; i < arg_size; i++) { - auto const& value = arg_list[i]; - params[i - 4] = env->ToJavaObject(L, value); - } - jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params, arg_size - 4); +LUA_DEFINE(DestroyJava) +{ + int id; + Lua::ParseArguments(L, id); + Plugin::Get()->DestroyJava(id); + return 1; +}); - delete[] params; - if (returnValue != NULL) { - Lua::LuaValue value = env->ToLuaValue(returnValue); - if (!(value == NULL)) { - switch (value.GetType()) - { - case Lua::LuaValue::Type::STRING: - Lua::ReturnValues(L, value.GetValue().c_str()); - break; - case Lua::LuaValue::Type::INTEGER: - Lua::ReturnValues(L, value.GetValue()); - break; - case Lua::LuaValue::Type::BOOLEAN: - Lua::ReturnValues(L, value.GetValue()); - break; - case Lua::LuaValue::Type::TABLE: - Lua::ReturnValues(L, value.GetValue()); - break; - default: - break; - } +LUA_DEFINE(LinkJavaAdapter) +{ + int id; + Lua::ParseArguments(L, id); + if (!Plugin::Get()->GetJavaEnv(id)) return 0; + JNIEnv* jenv = Plugin::Get()->GetJavaEnv(id)->GetEnv(); + Lua::LuaArgs_t arg_list; + Lua::ParseArguments(L, arg_list); + + int arg_size = static_cast(arg_list.size()); + if (arg_size < 2) return 0; + + std::string className = arg_list[1].GetValue(); + jclass clazz = jenv->FindClass(className.c_str()); + if (clazz == nullptr) return 0; + JNINativeMethod methods[] = { + {(char*)"callEvent", (char*)"(Ljava/lang/String;[Ljava/lang/Object;)V", (void*)CallEvent }, + {(char*)"callGlobalFunction", (char*)"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)[Ljava/lang/Object;", (void*)CallGlobal } + }; + jenv->RegisterNatives(clazz, methods, 2); + Lua::ReturnValues(L, 1); + return 1; +}); + +LUA_DEFINE(CallJavaStaticMethod) +{ + int id; + Lua::ParseArguments(L, id); + + if (!Plugin::Get()->GetJavaEnv(id)) return 0; + JavaEnv* env = Plugin::Get()->GetJavaEnv(id); + + Lua::LuaArgs_t arg_list; + Lua::ParseArguments(L, arg_list); + + int arg_size = static_cast(arg_list.size()); + if (arg_size < 4) return 0; + lua_pop(L, arg_size); + + std::string className = arg_list[1].GetValue(); + std::string methodName = arg_list[2].GetValue(); + std::string signature = arg_list[3].GetValue(); + jobject* params = new jobject[arg_size - 4]; + for (int i = 4; i < arg_size; i++) { + auto const& value = arg_list[i]; + params[i - 4] = env->ToJavaObject(L, value); + } + jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params, arg_size - 4); + if (returnValue != NULL) { + Lua::LuaValue value = env->ToLuaValue(returnValue); + if (!(value == NULL)) { + switch (value.GetType()) + { + case Lua::LuaValue::Type::STRING: + Lua::ReturnValues(L, value.GetValue().c_str()); + break; + case Lua::LuaValue::Type::INTEGER: + Lua::ReturnValues(L, value.GetValue()); + break; + case Lua::LuaValue::Type::BOOLEAN: + Lua::ReturnValues(L, value.GetValue()); + break; + case Lua::LuaValue::Type::TABLE: + Lua::ReturnValues(L, value.GetValue()); + break; + default: + break; } - value.~LuaValue(); } - else { - Lua::ReturnValues(L, 1); - } - return 1; - }); -} + } + else { + Lua::ReturnValues(L, 1); + } + return 1; +}); +} \ No newline at end of file diff --git a/src/Plugin.hpp b/src/Plugin.hpp index 18d39a7..d4f9290 100644 --- a/src/Plugin.hpp +++ b/src/Plugin.hpp @@ -20,17 +20,17 @@ class Plugin : public Singleton std::map statePackages; private: - using FuncInfo_t = std::tuple; + using FuncInfo_t = std::tuple; std::vector _func_list; private: - inline void Define(const char * name, lua_CFunction func) + inline void Define(const char* name, lua_CFunction func) { _func_list.emplace_back(name, func); } public: - decltype(_func_list) const &GetFunctions() const + decltype(_func_list) const& GetFunctions() const { return _func_list; } @@ -52,4 +52,4 @@ class Plugin : public Singleton void DestroyJava(int id); JavaEnv* GetJavaEnv(int id); JavaEnv* FindJavaEnv(JNIEnv* jenv); -}; +}; \ No newline at end of file From 1856df85ddb3a3bc9070b04586d147507be7fc7c Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 16:24:25 +0200 Subject: [PATCH 78/85] Memory leak fix --- src/JavaEnv.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index dfb636b..9955c49 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -201,28 +201,28 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) Lua::LuaValue value(pchars); jenv->ReleaseStringUTFChars(element, pchars); - jenv->DeleteLocalRef(element); + jenv->DeleteGlobalRef(object); return value; } else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Integer"))) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); - + jenv->DeleteGlobalRef(object); Lua::LuaValue value(result); return value; } else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Double"))) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); - + jenv->DeleteGlobalRef(object); Lua::LuaValue value(result); return value; } else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); - + jenv->DeleteGlobalRef(object); Lua::LuaValue value((bool)result); return value; } @@ -236,7 +236,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jobject arrayElement = jenv->CallObjectMethod(object, getMethod, i); table->Add(i + 1, this->ToLuaValue(arrayElement)); } - + jenv->DeleteGlobalRef(object); Lua::LuaValue value(table); return value; } @@ -258,7 +258,7 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); } - + jenv->DeleteGlobalRef(object); Lua::LuaValue value(table); return value; } From d459e4f42cd57c4f03a113fd5d599706db8e8e02 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 16:37:42 +0200 Subject: [PATCH 79/85] Memory leak fix --- src/JavaEnv.cpp | 92 ++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 84 insertions(+), 8 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 9955c49..e20ae65 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -194,7 +194,15 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) JNIEnv* jenv = this->GetEnv(); jclass jcls = jenv->GetObjectClass(object); - if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/String"))) { + jclass stringClass = jenv->FindClass("java/lang/String"); + jclass integerClass = jenv->FindClass("java/lang/Integer"); + jclass doubleClass = jenv->FindClass("java/lang/Double"); + jclass booleanClass = jenv->FindClass("java/lang/Boolean"); + jclass listClass = jenv->FindClass("java/util/List"); + jclass mapClass = jenv->FindClass("java/util/Map"); + + + if (jenv->IsInstanceOf(object, stringClass)) { jstring element = (jstring)object; const char* pchars = jenv->GetStringUTFChars(element, nullptr); @@ -202,31 +210,66 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) jenv->ReleaseStringUTFChars(element, pchars); jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + + jenv->DeleteGlobalRef(stringClass); + jenv->DeleteGlobalRef(integerClass); + jenv->DeleteGlobalRef(doubleClass); + jenv->DeleteGlobalRef(booleanClass); + jenv->DeleteGlobalRef(listClass); + jenv->DeleteGlobalRef(mapClass); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Integer"))) { + else if (jenv->IsInstanceOf(object, integerClass)) { jmethodID intValueMethod = jenv->GetMethodID(jcls, "intValue", "()I"); jint result = jenv->CallIntMethod(object, intValueMethod); jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + + jenv->DeleteGlobalRef(stringClass); + jenv->DeleteGlobalRef(integerClass); + jenv->DeleteGlobalRef(doubleClass); + jenv->DeleteGlobalRef(booleanClass); + jenv->DeleteGlobalRef(listClass); + jenv->DeleteGlobalRef(mapClass); + Lua::LuaValue value(result); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Double"))) { + else if (jenv->IsInstanceOf(object, doubleClass)) { jmethodID doubleValueMethod = jenv->GetMethodID(jcls, "doubleValue", "()D"); jdouble result = jenv->CallDoubleMethod(object, doubleValueMethod); jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + + jenv->DeleteGlobalRef(stringClass); + jenv->DeleteGlobalRef(integerClass); + jenv->DeleteGlobalRef(doubleClass); + jenv->DeleteGlobalRef(booleanClass); + jenv->DeleteGlobalRef(listClass); + jenv->DeleteGlobalRef(mapClass); + Lua::LuaValue value(result); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/lang/Boolean"))) { + else if (jenv->IsInstanceOf(object, booleanClass)) { jmethodID boolValueMethod = jenv->GetMethodID(jcls, "booleanValue", "()Z"); jboolean result = jenv->CallBooleanMethod(object, boolValueMethod); jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + + jenv->DeleteGlobalRef(stringClass); + jenv->DeleteGlobalRef(integerClass); + jenv->DeleteGlobalRef(doubleClass); + jenv->DeleteGlobalRef(booleanClass); + jenv->DeleteGlobalRef(listClass); + jenv->DeleteGlobalRef(mapClass); + Lua::LuaValue value((bool)result); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/List"))) { + else if (jenv->IsInstanceOf(object, listClass)) { jmethodID sizeMethod = jenv->GetMethodID(jcls, "size", "()I"); jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(I)Ljava/lang/Object;"); jint len = jenv->CallIntMethod(object, sizeMethod); @@ -237,16 +280,25 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(i + 1, this->ToLuaValue(arrayElement)); } jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + + jenv->DeleteGlobalRef(stringClass); + jenv->DeleteGlobalRef(integerClass); + jenv->DeleteGlobalRef(doubleClass); + jenv->DeleteGlobalRef(booleanClass); + jenv->DeleteGlobalRef(listClass); + jenv->DeleteGlobalRef(mapClass); + Lua::LuaValue value(table); return value; } - else if (jenv->IsInstanceOf(object, jenv->FindClass("java/util/Map"))) { + else if (jenv->IsInstanceOf(object, mapClass)) { jmethodID getMethod = jenv->GetMethodID(jcls, "get", "(Ljava/lang/Object;)Ljava/lang/Object;"); jmethodID keySetMethod = jenv->GetMethodID(jcls, "keySet", "()Ljava/util/Set;"); jobject keySet = jenv->CallObjectMethod(object, keySetMethod); - - jmethodID keySetToArrayMethod = jenv->GetMethodID(jenv->GetObjectClass(keySet), "toArray", "()[Ljava/lang/Object;"); + jclass keySetClass = jenv->GetObjectClass(keySet); + jmethodID keySetToArrayMethod = jenv->GetMethodID(keySetClass, "toArray", "()[Ljava/lang/Object;"); jobjectArray keyArray = (jobjectArray)jenv->CallObjectMethod(keySet, keySetToArrayMethod); int arraySize = jenv->GetArrayLength(keyArray); @@ -259,10 +311,30 @@ Lua::LuaValue JavaEnv::ToLuaValue(jobject object) table->Add(this->ToLuaValue(key), this->ToLuaValue(value)); } jenv->DeleteGlobalRef(object); + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(keySet); + jenv->DeleteGlobalRef(keySetClass); + jenv->DeleteGlobalRef(keyArray); + + jenv->DeleteGlobalRef(stringClass); + jenv->DeleteGlobalRef(integerClass); + jenv->DeleteGlobalRef(doubleClass); + jenv->DeleteGlobalRef(booleanClass); + jenv->DeleteGlobalRef(listClass); + jenv->DeleteGlobalRef(mapClass); + Lua::LuaValue value(table); return value; } + jenv->DeleteGlobalRef(jcls); + jenv->DeleteGlobalRef(stringClass); + jenv->DeleteGlobalRef(integerClass); + jenv->DeleteGlobalRef(doubleClass); + jenv->DeleteGlobalRef(booleanClass); + jenv->DeleteGlobalRef(listClass); + jenv->DeleteGlobalRef(mapClass); + return NULL; } @@ -354,5 +426,9 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: break; } } + for (int i = 0; i < paramsLength; i++) { + this->env->DeleteGlobalRef(params[i]); + } + this->env->DeleteGlobalRef(clazz); return returnValue; } \ No newline at end of file From 90e1d77079b0b940434ea7854abce1f1e21a6d53 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 16:38:43 +0200 Subject: [PATCH 80/85] Memory leak fix --- src/JavaEnv.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index e20ae65..927328a 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -426,7 +426,7 @@ jobject JavaEnv::CallStatic(std::string className, std::string methodName, std:: break; } } - for (int i = 0; i < paramsLength; i++) { + for (size_t i = 0; i < paramsLength; i++) { this->env->DeleteGlobalRef(params[i]); } this->env->DeleteGlobalRef(clazz); From b2ae23953d3b2087ebf4c4ea86967a7c80d22fcc Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 16:52:31 +0200 Subject: [PATCH 81/85] Memory leak fix --- src/JavaEnv.cpp | 16 ++++++++++++---- src/Plugin.cpp | 9 +++++---- 2 files changed, 17 insertions(+), 8 deletions(-) diff --git a/src/JavaEnv.cpp b/src/JavaEnv.cpp index 927328a..7494488 100644 --- a/src/JavaEnv.cpp +++ b/src/JavaEnv.cpp @@ -101,6 +101,7 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jstring packageName = (jstring)this->env->GetObjectField(instance, pField); const char* packageNameStr = this->env->GetStringUTFChars(packageName, nullptr); lua_State* L = Plugin::Get()->GetPackageState(packageNameStr); + this->env->ReleaseStringUTFChars(packageName, packageNameStr); this->env->DeleteLocalRef(packageName); int argsLength = this->env->GetArrayLength(args); Lua::PushValueToLua(this->luaFunctions[id], L); @@ -116,8 +117,11 @@ jobjectArray JavaEnv::LuaFunctionCall(jobject instance, jobjectArray args) { jclass objectCls = this->env->FindClass("Ljava/lang/Object;"); jobjectArray returns = this->env->NewObjectArray((jsize)returnCount, objectCls, NULL); for (jsize i = 0; i < (int)returnCount; i++) { - this->env->SetObjectArrayElement(returns, i, this->ToJavaObject(L, ReturnValues[i])); + jobject o = this->ToJavaObject(L, ReturnValues[i]); + this->env->SetObjectArrayElement(returns, i, o); + this->env->DeleteGlobalRef(o); } + this->env->DeleteGlobalRef(objectCls); return returns; } return NULL; @@ -155,8 +159,12 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) Lua::LuaTable_t table = value.GetValue(); table->ForEach([jenv, this, L, jmap, putMethod](Lua::LuaValue k, Lua::LuaValue v) { - jenv->CallObjectMethod(jmap, putMethod, this->ToJavaObject(L, k), this->ToJavaObject(L, v)); - }); + jobject jk = this->ToJavaObject(L, k); + jobject jv = this->ToJavaObject(L, v); + jenv->CallObjectMethod(jmap, putMethod, jk, jv); + jenv->DeleteGlobalRef(jk); + jenv->DeleteGlobalRef(jv); + }); return jmap; } break; @@ -176,7 +184,7 @@ jobject JavaEnv::ToJavaObject(lua_State* L, Lua::LuaValue value) this->env->SetIntField(javaLuaFunction, fField, id); jfieldID pField = this->env->GetFieldID(this->luaFunctionClass, "p", "Ljava/lang/String;"); this->env->SetObjectField(javaLuaFunction, pField, packageName); - this->env->DeleteLocalRef(packageName); + this->env->DeleteGlobalRef(packageName); return javaLuaFunction; } break; case Lua::LuaValue::Type::NIL: diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 2ef61e2..12b8c7a 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -93,7 +93,6 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { Onset::Plugin::Get()->CallEvent(eventStr, args); jenv->ReleaseStringUTFChars(event, eventStr); - jenv->DeleteLocalRef(event); } jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring functionName, jobjectArray args) { @@ -117,10 +116,12 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); for (jsize i = 0; i < (int)returnsLength; i++) { - jenv->SetObjectArrayElement(returns, i, env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i])); + jobject o = env->ToJavaObject(Plugin::Get()->GetPackageState(packageNameStr), luaReturns[i]); + jenv->SetObjectArrayElement(returns, i, o); + jenv->DeleteGlobalRef(o); } - jenv->DeleteLocalRef(packageName); - jenv->DeleteLocalRef(functionName); + jenv->ReleaseStringUTFChars(packageName, packageNameStr); + jenv->ReleaseStringUTFChars(functionName, functionNameStr); return returns; } From 507cebdb2573674987dcca1c8e57d18744170cd3 Mon Sep 17 00:00:00 2001 From: JanHolger Date: Sun, 16 Aug 2020 16:56:59 +0200 Subject: [PATCH 82/85] Memory leak fix --- src/Plugin.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 12b8c7a..1574753 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -219,6 +219,7 @@ LUA_DEFINE(CallJavaStaticMethod) params[i - 4] = env->ToJavaObject(L, value); } jobject returnValue = Plugin::Get()->GetJavaEnv(id)->CallStatic(className, methodName, signature, params, arg_size - 4); + delete[] params; if (returnValue != NULL) { Lua::LuaValue value = env->ToLuaValue(returnValue); if (!(value == NULL)) { From 0954f9ad7cf8cd4b13a60cff4d75ab616ae24f7c Mon Sep 17 00:00:00 2001 From: BlueMountainsIO Date: Fri, 13 Nov 2020 13:55:33 +0100 Subject: [PATCH 83/85] Fix memory leak in CallEvent and CallGlobal LuaArgs_t gets allocated but never freed. Use a normal object which gets destroyed when it goes out of scope. --- src/Plugin.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/Plugin.cpp b/src/Plugin.cpp index 1574753..89ff25a 100644 --- a/src/Plugin.cpp +++ b/src/Plugin.cpp @@ -81,16 +81,16 @@ void CallEvent(JNIEnv* jenv, jclass jcl, jstring event, jobjectArray argsList) { (void)jcl; const char* eventStr = jenv->GetStringUTFChars(event, nullptr); - auto args = new Lua::LuaArgs_t(); + Lua::LuaArgs_t args; int argsCount = jenv->GetArrayLength(argsList); for (jsize i = 0; i < argsCount; i++) { jobject arrayElement = jenv->GetObjectArrayElement(argsList, i); - args->push_back(env->ToLuaValue(arrayElement)); + args.push_back(env->ToLuaValue(arrayElement)); } - Onset::Plugin::Get()->CallEvent(eventStr, args); + Onset::Plugin::Get()->CallEvent(eventStr, &args); jenv->ReleaseStringUTFChars(event, eventStr); } @@ -106,12 +106,12 @@ jobjectArray CallGlobal(JNIEnv* jenv, jclass jcl, jstring packageName, jstring f const char* packageNameStr = jenv->GetStringUTFChars(packageName, nullptr); const char* functionNameStr = jenv->GetStringUTFChars(functionName, nullptr); int argsLength = jenv->GetArrayLength(args); - auto luaArgs = new Lua::LuaArgs_t(); + Lua::LuaArgs_t luaArgs; for (jsize i = 0; i < argsLength; i++) { - luaArgs->push_back(env->ToLuaValue(jenv->GetObjectArrayElement(args, i))); + luaArgs.push_back(env->ToLuaValue(jenv->GetObjectArrayElement(args, i))); } - auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, luaArgs); + auto luaReturns = CallLuaFunction(Plugin::Get()->GetPackageState(packageNameStr), functionNameStr, &luaArgs); size_t returnsLength = luaReturns.size(); jclass objectCls = jenv->FindClass("Ljava/lang/Object;"); jobjectArray returns = jenv->NewObjectArray((jsize)returnsLength, objectCls, NULL); From 3797d6d45da7581bd6220ecff2de7c525c375e60 Mon Sep 17 00:00:00 2001 From: BlueMountainsIO Date: Fri, 13 Nov 2020 14:02:09 +0100 Subject: [PATCH 84/85] Add compile instructions --- README.md | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/README.md b/README.md index 08ca266..af5e856 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,31 @@ You can use our [language framework](https://github.com/OnfireNetwork/OnsetJava) 2. Ensure Java 8 JDK/JRE 64bit is installed. 3. Enable "OnsetJavaPlugin" as a plugin inside server_config.json. +#### Compiling from source +##### Ubuntu 18.04 +``` +# Compiling the plugin requires GCC8 because of usage. + +apt install openjdk-8-jdk openjdk-8-jre maven gcc-8 g++-8 + +export CC=/usr/bin/gcc-8 +export CXX=/usr/bin/g++-8 + +git clone --recurse-submodules https://github.com/OnfireNetwork/OnsetJavaPlugin +cd OnsetJavaPlugin +cmake . +make + +# Copy src/OnsetJavaPlugin.so to your OnsetServer/plugins folder. +``` +##### Compiling OnsetJavaPluginSupport +``` +cd OnsetJavaPluginSupport +mvn package + +# Copy OnsetJavaPluginSupport/target/OnsetJavaPluginSupport-1.0.jar to your OnsetServer/java folder. +``` + ### Data Types we support #### Method Parameters * Lua String -> String (java.lang.String) From 55bb111fa51ba246a3d87152301dd650df06478f Mon Sep 17 00:00:00 2001 From: Blue Mountains <39657423+BlueMountainsIO@users.noreply.github.com> Date: Sun, 20 Dec 2020 12:48:50 +0100 Subject: [PATCH 85/85] Update OnsetSDK submodule --- libs/sdk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/sdk b/libs/sdk index e44cc88..0d06e03 160000 --- a/libs/sdk +++ b/libs/sdk @@ -1 +1 @@ -Subproject commit e44cc88a1aa0a313dcadba74b08912e2b7fe02d3 +Subproject commit 0d06e0313d1984c24ab527b7424f80c652eec58c