Use ThreadScope::WithClassLoader to use app's JNI class_loader

Author: mrousavy

android/src/main/cpp/cpp-adapter.cpp

@@ -31,14 +31,22 @@ struct MultithreadingModule : jni::JavaClass<MultithreadingModule> {
 
 private:
   static std::shared_ptr<react::JSExecutorFactory> makeJSExecutorFactory() {
-    ThreadScope scope; // JNI needs to attach this thread because this function is being called from a different Thread
-
-    __android_log_write(ANDROID_LOG_INFO, TAG, "Calling Java method MultithreadingModule.makeJSExecutor()...");
-    static const auto cls = javaClassStatic();
-    static const auto method = cls->getStaticMethod<react::JavaScriptExecutorHolder()>("makeJSExecutor");
-    auto result = method(cls);
-    __android_log_write(ANDROID_LOG_INFO, TAG, "JavaScriptExecutor created! Getting factory...");
-    return result->cthis()->getExecutorFactory();
+    std::shared_ptr<react::JSExecutorFactory> factory;
+
+    ThreadScope::WithClassLoader([&factory]() {
+      __android_log_write(ANDROID_LOG_INFO, TAG, "Calling Java method MultithreadingModule.makeJSExecutor()...");
+      static const auto cls = javaClassStatic();
+      static const auto method = cls->getStaticMethod<react::JavaScriptExecutorHolder()>("makeJSExecutor");
+      auto result = method(cls);
+      __android_log_write(ANDROID_LOG_INFO, TAG, "JavaScriptExecutor created! Getting factory...");
+      auto cxxInstance = result->cthis()->getExecutorFactory();
+      factory = cxxInstance;
+    });
+    if (factory == nullptr) {
+      throw std::runtime_error("Failed to create the JSExecutorFactory! shared_ptr was null.");
+    }
+
+    return factory;
   }
 
   static void installNative(jni::alias_ref<JClass>,
@@ -61,6 +69,9 @@ struct MultithreadingModule : jni::JavaClass<MultithreadingModule> {
     auto makeJsExecutor = []() -> std::unique_ptr<jsi::Runtime> {
       __android_log_write(ANDROID_LOG_DEBUG, TAG, "Creating JSExecutorFactory..");
       try {
+        // JNI needs to attach this thread because this function is being called from a different Thread
+        ThreadScope scope;
+
         std::shared_ptr<react::ExecutorDelegate> delegate = std::shared_ptr<react::ExecutorDelegate>();
         std::shared_ptr<react::MessageQueueThread> jsQueue = std::shared_ptr<react::MessageQueueThread>();
         auto jsExecutorFactory = makeJSExecutorFactory();
@@ -69,11 +80,16 @@ struct MultithreadingModule : jni::JavaClass<MultithreadingModule> {
                                                             jsQueue);
         auto runtimePointer = static_cast<jsi::Runtime *>(executor->getJavaScriptContext());
         __android_log_write(ANDROID_LOG_DEBUG, TAG, "JSExecutor created!");
+
+        // the returned value is now responsible for releasing the runtime.
+        auto _ = executor.release();
         return std::unique_ptr<jsi::Runtime>(runtimePointer);
+
       } catch (std::exception& exc) {
+        // Fatal error - the runtime can't be created at all.
         __android_log_write(ANDROID_LOG_ERROR, TAG, "Failed to create JSExecutor!");
         __android_log_write(ANDROID_LOG_ERROR, TAG, exc.what());
-        return std::unique_ptr<jsi::Runtime>(); // TODO: Remove this and let the caller handle the exception.
+        abort();
       }
     };
     mrousavy::multithreading::install(*runtime, makeJsExecutor, makeScheduler, makeErrorHandler);

cpp/RNMultithreadingInstaller.cpp

@@ -73,20 +73,12 @@ namespace mrousavy {
 
                                                                                                                                               pool->enqueue([resolver, rejecter, worklet]() {
                                                                                                                                                   try {
-                                                                                                                                                      auto m = manager.get();
-                                                                                                                                                      if (!m) throw std::runtime_error("RuntimeManager was not initialized!");
-                                                                                                                                                      auto r = m->runtime.get();
-                                                                                                                                                      if (!r) throw std::runtime_error("Runtime was not initialized!");
-                                                                                                                                                      auto& runtime = *r;
-                                                                                                                                                      throw std::runtime_error("1");
+                                                                                                                                                      auto& runtime = *manager->runtime;
 
                                                                                                                                                       auto function = worklet->getValue(runtime).asObject(runtime).asFunction(runtime);
-                                                                                                                                                      throw std::runtime_error("2");
                                                                                                                                                       auto result = function.getFunction(runtime).callWithThis(runtime, function);
-                                                                                                                                                      throw std::runtime_error("3");
 
                                                                                                                                                       auto shareableResult = reanimated::ShareableValue::adapt(runtime, result, manager.get());
-                                                                                                                                                      throw std::runtime_error("4");
                                                                                                                                                       resolver(shareableResult);
                                                                                                                                                   } catch (std::exception& exc) {
                                                                                                                                                       rejecter(exc.what());