Fixed loading classes from native threads with detached class-loaders #49

Author: devopvoid

webrtc-jni/src/main/cpp/dependencies/jni-voithos/CMakeLists.txt

@@ -12,6 +12,7 @@ target_sources(${PROJECT_NAME}
 		include/JavaBigInteger.h
 		include/JavaClasses.h
 		include/JavaClass.h
+		include/JavaClassLoader.h
 		include/JavaClassUtils.h
 		include/JavaContext.h
 		include/JavaDimension.h
@@ -40,6 +41,7 @@ target_sources(${PROJECT_NAME}
 		src/Exception.cpp
 		src/JavaArrayList.cpp
 		src/JavaBigInteger.cpp
+		src/JavaClassLoader.cpp
 		src/JavaClassUtils.cpp
 		src/JavaContext.cpp
 		src/JavaDimension.cpp

webrtc-jni/src/main/cpp/dependencies/jni-voithos/include/JavaClassLoader.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2021, Alex Andres. All rights reserved.
+ *
+ * Use of this source code is governed by the 3-Clause BSD license that can be
+ * found in the LICENSE file in the root of the source tree.
+ */
+
+#ifndef JNI_JAVA_CLASSLOADER_H_
+#define JNI_JAVA_CLASSLOADER_H_
+
+#include "JavaRef.h"
+
+#include <jni.h>
+
+namespace jni
+{
+	void InitClassLoader(JNIEnv * env, const JavaGlobalRef<jobject> & classLoader);
+
+	JavaLocalRef<jclass> ClassLoaderGetClass(JNIEnv * env, const char * name);
+}
+
+#endif

webrtc-jni/src/main/cpp/dependencies/jni-voithos/include/JavaContext.h

@@ -33,8 +33,9 @@ namespace jni
 			void operator=(const JavaContext &) = delete;
 			JavaContext & operator=(JavaContext &&) = delete;
 
-			virtual void initialize(JNIEnv * env);
-			virtual void destroy(JNIEnv * env);
+			virtual void initialize(JNIEnv * env) = 0;
+			virtual void initializeClassLoader(JNIEnv * env, const char * loaderName) = 0;
+			virtual void destroy(JNIEnv * env) = 0;
 
 			JavaVM * getVM();
 

webrtc-jni/src/main/cpp/dependencies/jni-voithos/src/JavaClassLoader.cpp

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2021, Alex Andres. All rights reserved.
+ *
+ * Use of this source code is governed by the 3-Clause BSD license that can be
+ * found in the LICENSE file in the root of the source tree.
+ */
+
+#include "JavaClassLoader.h"
+#include "JavaString.h"
+#include "JavaUtils.h"
+
+#include <algorithm>
+#include <string>
+
+namespace jni
+{
+	class JavaClassLoader {
+		public:
+			explicit JavaClassLoader(JNIEnv * env, const JavaGlobalRef<jobject> & classLoader) :
+				classLoader(classLoader)
+			{
+				classLoaderClass_ = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass("java/lang/ClassLoader")));
+
+				if (ExceptionCheck(env)) {
+					return;
+				}
+
+				loadClass = env->GetMethodID(classLoaderClass_, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+
+				ExceptionCheck(env);
+			}
+
+			JavaLocalRef<jclass> FindClass(JNIEnv * env, const char * c_name)
+			{
+				std::string name(c_name);
+				std::replace(name.begin(), name.end(), '/', '.');
+
+				JavaLocalRef<jstring> j_name = JavaString::toJava(env, name);
+
+				const jclass cls = static_cast<jclass>(env->CallObjectMethod(classLoader.get(), loadClass, j_name.get()));
+
+				if (ExceptionCheck(env)) {
+					return nullptr;
+				}
+
+				return JavaLocalRef<jclass>(env, cls);
+			}
+
+		private:
+			JavaGlobalRef<jobject> classLoader;
+			jclass classLoaderClass_;
+			jmethodID loadClass;
+	};
+
+
+	static JavaClassLoader * javaClassLoader = nullptr;
+
+
+	void InitClassLoader(JNIEnv * env, const JavaGlobalRef<jobject> & classLoader) {
+		if (javaClassLoader == nullptr) {
+			javaClassLoader = new JavaClassLoader(env, classLoader);
+		}
+	}
+
+	JavaLocalRef<jclass> ClassLoaderGetClass(JNIEnv * env, const char * name) {
+		return (javaClassLoader == nullptr)
+					? JavaLocalRef<jclass>(env, env->FindClass(name))
+					: javaClassLoader->FindClass(env, name);
+	}
+}

webrtc-jni/src/main/cpp/dependencies/jni-voithos/src/JavaContext.cpp

@@ -14,14 +14,6 @@ namespace jni
 	{
 	}
 
-	void JavaContext::initialize(JNIEnv * env)
-	{
-	}
-
-	void JavaContext::destroy(JNIEnv * env)
-	{
-	}
-
 	JavaVM * JavaContext::getVM()
 	{
 		return vm;

webrtc-jni/src/main/cpp/dependencies/jni-voithos/src/JavaUtils.cpp

@@ -7,6 +7,7 @@
 
 #include "Exception.h"
 #include "JavaUtils.h"
+#include "JavaClassLoader.h"
 #include "JavaContext.h"
 #include "JavaError.h"
 #include "JavaIterable.h"
@@ -60,7 +61,7 @@ void ThrowCxxJavaException(JNIEnv * env)
 
 jclass FindClass(JNIEnv * env, const char * name)
 {
-	jclass cls = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(name)));
+	jclass cls = reinterpret_cast<jclass>(env->NewGlobalRef(jni::ClassLoaderGetClass(env, name)));
 
 	if (cls == nullptr) {
 		ExceptionCheck(env);

webrtc-jni/src/main/cpp/include/JNI_WebRTC.h

@@ -17,12 +17,13 @@
 #ifndef JNI_WEBRTC_H_
 #define JNI_WEBRTC_H_
 
-#define PKG         "dev/onvoid/webrtc/"
-#define PKG_LOG     "dev/onvoid/webrtc/logging/"
-#define PKG_MEDIA   "dev/onvoid/webrtc/media/"
-#define PKG_AUDIO   "dev/onvoid/webrtc/media/audio/"
-#define PKG_VIDEO   "dev/onvoid/webrtc/media/video/"
-#define PKG_DESKTOP "dev/onvoid/webrtc/media/video/desktop/"
+#define PKG          "dev/onvoid/webrtc/"
+#define PKG_INTERNAL "dev/onvoid/webrtc/internal/"
+#define PKG_LOG      "dev/onvoid/webrtc/logging/"
+#define PKG_MEDIA    "dev/onvoid/webrtc/media/"
+#define PKG_AUDIO    "dev/onvoid/webrtc/media/audio/"
+#define PKG_VIDEO    "dev/onvoid/webrtc/media/video/"
+#define PKG_DESKTOP  "dev/onvoid/webrtc/media/video/desktop/"
 
 #define BOOLEAN_SIG     "Ljava/lang/Boolean;"
 #define DOUBLE_SIG      "Ljava/lang/Double;"

webrtc-jni/src/main/cpp/include/WebRTCContext.h

@@ -33,13 +33,14 @@ namespace jni
 			~WebRTCContext() = default;
 
 			void initialize(JNIEnv * env) override;
+			void initializeClassLoader(JNIEnv* env, const char * loaderName) override;
 			void destroy(JNIEnv * env) override;
 
 			avdev::AudioDeviceManager * getAudioDeviceManager();
 			avdev::VideoDeviceManager * getVideoDeviceManager();
 
 		private:
-			void initDeviceManagers();
+			void initializeDeviceManagers();
 
 		private:
 			std::unique_ptr<avdev::AudioDeviceManager> audioDevManager;

webrtc-jni/src/main/cpp/src/WebRTCContext.cpp

@@ -18,6 +18,7 @@
 #include "api/DataBufferFactory.h"
 #include "api/RTCStats.h"
 #include "Exception.h"
+#include "JavaClassLoader.h"
 #include "JavaError.h"
 #include "JavaEnums.h"
 #include "JavaFactories.h"
@@ -55,8 +56,6 @@ namespace jni
 
 	void WebRTCContext::initialize(JNIEnv * env)
 	{
-		JavaContext::initialize(env);
-
 		if (!rtc::InitializeSSL()) {
 			throw Exception("Initialize SSL failed");
 		}
@@ -96,7 +95,23 @@ namespace jni
 		JavaFactories::add<webrtc::RtpTransceiverInterface>(env, PKG"RTCRtpTransceiver");
 		JavaFactories::add<webrtc::DataBuffer>(std::make_unique<DataBufferFactory>(env, PKG"RTCDataChannelBuffer"));
 
-		initDeviceManagers();
+		initializeClassLoader(env, PKG_INTERNAL"NativeClassLoader");
+		initializeDeviceManagers();
+	}
+
+	void WebRTCContext::initializeClassLoader(JNIEnv* env, const char * loaderName)
+	{
+		auto javaClass = JavaLocalRef<jclass>(env, FindClass(env, loaderName));
+
+		if (ExceptionCheck(env)) {
+			return;
+		}
+
+		auto javaGet = GetStaticMethod(env, javaClass, "getClassLoader", "()Ljava/lang/ClassLoader;");
+
+		auto loaderRef = jni::JavaGlobalRef<jobject>(env, env->CallStaticObjectMethod(javaClass, javaGet));
+
+		InitClassLoader(env, loaderRef);
 	}
 
 	void WebRTCContext::destroy(JNIEnv * env)
@@ -107,8 +122,6 @@ namespace jni
 
 		audioDevManager = nullptr;
 		videoDevManager = nullptr;
-
-		JavaContext::destroy(env);
 	}
 
 	avdev::AudioDeviceManager * WebRTCContext::getAudioDeviceManager()
@@ -121,7 +134,7 @@ namespace jni
 		return videoDevManager.get();
 	}
 
-	void WebRTCContext::initDeviceManagers()
+	void WebRTCContext::initializeDeviceManagers()
 	{
 #ifdef _WIN32
 		audioDevManager = std::make_unique<avdev::WindowsAudioDeviceManager>();

webrtc/src/main/java/dev/onvoid/webrtc/internal/NativeClassLoader.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 Alex Andres
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dev.onvoid.webrtc.internal;
+
+/**
+ * This ClassLoader is capable of loading Java classes regardless of what thread
+ * classes should be loaded from. Such a ClassLoader is needed when a Java class
+ * lookup is performed from a native thread and there is no app-specific frame
+ * on the stack.
+ *
+ * @author Alex Andres
+ */
+class NativeClassLoader {
+
+	static ClassLoader getClassLoader() {
+		ClassLoader loader = NativeClassLoader.class.getClassLoader();
+
+		if (loader == null) {
+			throw new RuntimeException("Get NativeClassLoader failed");
+		}
+
+		return loader;
+	}
+
+}