Add a bit of logging

Author: mrousavy

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

@@ -20,6 +20,7 @@ struct MultithreadingModule : jni::JavaClass<MultithreadingModule> {
 public:
     __unused static constexpr auto kJavaDescriptor = "Lcom/reactnativemultithreading/MultithreadingModule;";
 
+    static constexpr auto TAG = "RNMultithreading";
 
     static void registerNatives() {
         javaClassStatic()->registerNatives({
@@ -32,10 +33,11 @@ struct MultithreadingModule : jni::JavaClass<MultithreadingModule> {
     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_DEBUG, "RNMultithreading", "Calling Java method MultithreadingModule.makeJSExecutor()...");
+        __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();
     }
 
@@ -57,16 +59,22 @@ struct MultithreadingModule : jni::JavaClass<MultithreadingModule> {
             return std::make_shared<reanimated::AndroidErrorHandler>(scheduler_);
         };
         auto makeJsExecutor = []() -> std::unique_ptr<jsi::Runtime> {
-            __android_log_write(ANDROID_LOG_DEBUG, "RNMultithreading", "Creating JSExecutor..");
-            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();
-            auto executor = jsExecutorFactory->createJSExecutor(delegate, jsQueue);
-            auto runtimePointer = static_cast<jsi::Runtime*>(executor->getJavaScriptContext());
-            __android_log_write(ANDROID_LOG_DEBUG, "RNMultithreading", "JSExecutor created!");
-            std::unique_ptr<jsi::Runtime> runtime;
-            runtime.reset(runtimePointer);
-            return runtime;
+            __android_log_write(ANDROID_LOG_DEBUG, TAG, "Creating JSExecutorFactory..");
+            try {
+                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();
+              __android_log_write(ANDROID_LOG_DEBUG, TAG, "Creating JSExecutor..");
+                auto executor = jsExecutorFactory->createJSExecutor(delegate,
+                                                                    jsQueue);
+                auto runtimePointer = static_cast<jsi::Runtime *>(executor->getJavaScriptContext());
+                __android_log_write(ANDROID_LOG_DEBUG, TAG, "JSExecutor created!");
+                return std::unique_ptr<jsi::Runtime>(runtimePointer);
+            } catch (std::exception& exc) {
+                __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.
+            }
         };
         mrousavy::multithreading::install(*runtime, makeJsExecutor, makeScheduler, makeErrorHandler);
 

android/src/main/java/com/reactnativemultithreading/MultithreadingModule.java

@@ -1,5 +1,7 @@
 package com.reactnativemultithreading;
 
+import android.util.Log;
+
 import androidx.annotation.Keep;
 import androidx.annotation.NonNull;
 
@@ -24,6 +26,8 @@ public class MultithreadingModule extends ReactContextBaseJavaModule {
     System.loadLibrary("rnmultithreading");
   }
 
+  static String TAG = "RNMultithreading";
+
   // Dummy so react native adds it to the Gradle Module System
   public MultithreadingModule(ReactApplicationContext context) {
     super(context);
@@ -32,7 +36,7 @@ public MultithreadingModule(ReactApplicationContext context) {
   @NonNull
   @Override
   public String getName() {
-    return "RNMultithreading";
+    return TAG;
   }
 
   private static native void installNative(long jsiRuntimePointer,
@@ -49,10 +53,13 @@ public static void install(ReactApplicationContext context, JavaScriptContextHol
   // Called from the C++ code
   @SuppressWarnings({"unused", "RedundantSuppression"})
   public static JavaScriptExecutor makeJSExecutor() {
+    Log.i(TAG, "Creating JavaScriptExecutorFactory...");
     JavaScriptExecutorFactory factory = makeJSExecutorFactory();
     try {
+      Log.i(TAG, "Factory created! Creating JavaScriptExecutor...");
       return factory.create();
     } catch (Exception e) {
+      Log.e(TAG, "Failed to create JavaScriptExecutor!");
       e.printStackTrace();
       return null;
     }
@@ -61,6 +68,7 @@ public static JavaScriptExecutor makeJSExecutor() {
   // method from React native
   public static JavaScriptExecutorFactory makeJSExecutorFactory() {
     try {
+      Log.i(TAG, "Trying to create JSC Factory...");
       SoLoader.loadLibrary("jscexecutor");
       return new JSCExecutorFactory("Multithreading", "Multithreading");
     } catch (UnsatisfiedLinkError jscE) {
@@ -79,6 +87,7 @@ public static JavaScriptExecutorFactory makeJSExecutorFactory() {
 
       // Otherwise use Hermes
       try {
+        Log.i(TAG, "Trying to create Hermes Factory...");
         return new HermesExecutorFactory();
       } catch (UnsatisfiedLinkError hermesE) {
         // If we get here, either this is a JSC build, and of course