fix(android): preserve unified runtime behavior

Author: DjDeveloperr

NativeScript/napi/android/quickjs/quickjs-api.c

@@ -4370,10 +4370,11 @@ napi_status qjs_execute_script(napi_env env,
     JS_FreeCString(env->context, cScript);
     js_exit(env);
     if (JS_IsException(eval_result)) {
-        const char *exceptionMessage = JS_ToCString(env->context, eval_result);
+        JSValue exceptionValue = JS_GetException(env->context);
+        const char *exceptionMessage = JS_ToCString(env->context, exceptionValue);
         napi_set_last_error(env, napi_cannot_run_js, exceptionMessage, 0, NULL);
         JS_FreeCString(env->context, exceptionMessage);
-        JS_Throw(env->context, eval_result);
+        JS_Throw(env->context, exceptionValue);
         return napi_cannot_run_js;
     }
 
@@ -4432,4 +4433,4 @@ napi_status qjs_update_stack_top(napi_env env) {
     CHECK_ARG(env)
     JS_UpdateStackTop(env->runtime->runtime);
     return napi_clear_last_error(env);
-}
+}

NativeScript/napi/common/native_api_util.h

@@ -341,6 +341,24 @@ inline napi_status define_property(
   return napi_define_properties(env, object, 1, &desc);
 }
 
+inline napi_status define_property_value(
+    napi_env env, napi_value object, const char* propertyName,
+    napi_value value = nullptr,
+    napi_property_attributes attributes = napi_default_jsproperty,
+    void* data = nullptr) {
+  return napi_util::define_property(env, object, propertyName, value, nullptr,
+                                    nullptr, data, attributes);
+}
+
+inline napi_status define_property_get_set(
+    napi_env env, napi_value object, const char* propertyName,
+    napi_callback getter, napi_callback setter,
+    napi_property_attributes attributes = napi_default_jsproperty,
+    void* data = nullptr) {
+  return napi_util::define_property(env, object, propertyName, nullptr, getter,
+                                    setter, data, attributes);
+}
+
 inline void setPrototypeOf(napi_env env, napi_value object,
                            napi_value prototype) {
   napi_value global, global_object, set_proto;

NativeScript/napi/quickjs/quickjs-api.c

@@ -4464,10 +4464,11 @@ napi_status qjs_execute_script(napi_env env, napi_value script,
   JS_FreeCString(env->context, cScript);
   js_exit(env);
   if (JS_IsException(eval_result)) {
-    const char* exceptionMessage = JS_ToCString(env->context, eval_result);
+    JSValue exceptionValue = JS_GetException(env->context);
+    const char* exceptionMessage = JS_ToCString(env->context, exceptionValue);
     napi_set_last_error(env, napi_cannot_run_js, exceptionMessage, 0, NULL);
     JS_FreeCString(env->context, exceptionMessage);
-    JS_Throw(env->context, eval_result);
+    JS_Throw(env->context, exceptionValue);
     return napi_cannot_run_js;
   }
 

NativeScript/runtime/android/Runtime.cpp

@@ -205,6 +205,33 @@ void Runtime::Init(JNIEnv *_env, jstring filesPath, jstring nativeLibsDir,
     js_get_runtime_version(env, &engine);
     napi_set_named_property(env, global, "__engine", engine);
 
+    const char* engineVariant = "UNKNOWN";
+#if defined(__SHERMES__)
+    engineVariant = "SHERMES";
+#elif defined(NS_HERMES_LEGACY_NAPI)
+    engineVariant = "HERMES";
+#elif defined(__HERMES__)
+    engineVariant = "HERMES";
+#elif defined(__JSC__)
+    engineVariant = "JSC";
+#elif defined(__V8_13__)
+    engineVariant = "V8-13";
+#elif defined(__V8_11__)
+    engineVariant = "V8-11";
+#elif defined(__V8_10__)
+    engineVariant = "V8-10";
+#elif defined(__V8__)
+    engineVariant = "V8";
+#elif defined(__PRIMJS__)
+    engineVariant = "PRIMJS";
+#elif defined(__QJS_NG__)
+    engineVariant = "QUICKJS_NG";
+#elif defined(__QJS__)
+    engineVariant = "QUICKJS";
+#endif
+    napi_value engineVariantValue;
+    napi_create_string_utf8(env, engineVariant, NAPI_AUTO_LENGTH, &engineVariantValue);
+    napi_set_named_property(env, global, "__engineVariant", engineVariantValue);
 
     napi_util::napi_set_function(env, global, "__time", CallbackHandlers::TimeCallback);
     napi_util::napi_set_function(env, global, "__releaseNativeCounterpart",

NativeScript/runtime/android/modules/module/ModuleInternal.cpp

@@ -22,6 +22,31 @@
 using namespace tns;
 using namespace std;
 
+namespace {
+void ThrowFallbackRequireError(napi_env env, const char* message) {
+    bool pendingException = false;
+    napi_is_exception_pending(env, &pendingException);
+    if (pendingException) {
+        napi_value ignored;
+        napi_get_and_clear_last_exception(env, &ignored);
+    }
+
+    napi_throw_error(env, nullptr, message);
+}
+
+void ReThrowRequireError(napi_env env, NativeScriptException& exception) {
+    try {
+        exception.ReThrowToNapi(env);
+    } catch (NativeScriptException&) {
+        ThrowFallbackRequireError(env, "Error rethrowing NativeScript require exception.");
+    } catch (std::exception& nestedException) {
+        ThrowFallbackRequireError(env, nestedException.what());
+    } catch (...) {
+        ThrowFallbackRequireError(env, "Error rethrowing NativeScript require exception.");
+    }
+}
+}
+
 ModuleInternal::ModuleInternal()
     : m_env(nullptr), m_requireFunction(nullptr), m_requireFactoryFunction(nullptr) {
 }
@@ -131,15 +156,15 @@ napi_value ModuleInternal::RequireCallback(napi_env env, napi_callback_info info
         auto thiz = static_cast<ModuleInternal*>(data);
         return thiz->RequireCallbackImpl(env, info);
     } catch (NativeScriptException& e) {
-        e.ReThrowToNapi(env);
+        ReThrowRequireError(env, e);
     } catch (std::exception& e) {
         stringstream ss;
         ss << "Error: c++ exception: " << e.what() << endl;
         NativeScriptException nsEx(ss.str());
-        nsEx.ReThrowToNapi(env);
+        ReThrowRequireError(env, nsEx);
     } catch (...) {
         NativeScriptException nsEx(std::string("Error: c++ exception!"));
-        nsEx.ReThrowToNapi(env);
+        ReThrowRequireError(env, nsEx);
     }
 
     return nullptr;
@@ -164,6 +189,9 @@ napi_value ModuleInternal::RequireCallbackImpl(napi_env env, napi_callback_info
     auto isData = false;
 
     auto moduleObj = LoadImpl(env, moduleName, callingModuleDirName, isData);
+    if (moduleObj == nullptr) {
+        return nullptr;
+    }
 
     if (isData) {
         assert(!napi_util::is_null_or_undefined(env, moduleObj));
@@ -346,10 +374,10 @@ napi_value ModuleInternal::LoadModule(napi_env env, const std::string& modulePat
         if (status != napi_ok) {
             bool pendingException;
             napi_is_exception_pending(env, &pendingException);
-            napi_value error = nullptr;
             if (pendingException) {
-                napi_get_and_clear_last_exception(env, &error);
+                return nullptr;
             }
+            napi_value error = nullptr;
             if (error) {
                 throw NativeScriptException(env, error, "Error running script " + modulePath);
             } else {
@@ -411,6 +439,9 @@ napi_value ModuleInternal::LoadModule(napi_env env, const std::string& modulePat
     bool pendingException;
     napi_is_exception_pending(env, &pendingException);
      if (status != napi_ok || pendingException) {
+         if (pendingException) {
+             return nullptr;
+         }
          napi_value exception;
          napi_get_and_clear_last_exception(env, &exception);
          if (exception) {
@@ -490,4 +521,3 @@ jmethodID ModuleInternal::RESOLVE_PATH_METHOD_ID = nullptr;
 const char* ModuleInternal::MODULE_PROLOGUE = "(function(module, exports, require, __filename, __dirname){ ";
 const char* ModuleInternal::MODULE_EPILOGUE = "\n})";
 int ModuleInternal::MODULE_PROLOGUE_LENGTH = std::string(ModuleInternal::MODULE_PROLOGUE).length();
-

platforms/android/test-app/runtime/src/main/java/com/tns/MessageType.java

@@ -11,4 +11,5 @@ public class MessageType {
     public static int CloseWorker = 6;
     public static int BubbleUpException = 7;
     public static int TerminateAndCloseThread = 8;
+    public static int WorkerReady = 9;
 }

platforms/android/test-app/runtime/src/main/java/com/tns/Runtime.java

@@ -481,24 +481,30 @@ public void run() {
                     }
 
                     /*
-                    	Send a message to the Main Thread to `shake hands`,
-                    	Main Thread will cache the Worker Handler for later use
+                        Send a message to the Main Thread to `shake hands`,
+                        Main Thread will verify the Worker runtime is still alive.
                      */
                     Message msg = Message.obtain();
                     msg.arg1 = MessageType.Handshake;
                     msg.arg2 = runtime.runtimeId;
 
                     runtime.mainThreadHandler.sendMessage(msg);
-                    runtime.runWorker(runtime.runtimeId, filePath);
 
+                    runtime.runWorker(runtime.runtimeId, filePath);
                     runtime.processPendingMessages();
+
+                    Message readyMsg = Message.obtain();
+                    readyMsg.arg1 = MessageType.WorkerReady;
+                    readyMsg.arg2 = runtime.runtimeId;
+
+                    runtime.mainThreadHandler.sendMessage(readyMsg);
                 }
             }));
         }
     }
 
     private void processPendingMessages() {
-        Queue<Message> messages = Runtime.pendingWorkerMessages.get(this.getWorkerId());
+        Queue<Message> messages = Runtime.pendingWorkerMessages.remove(this.getWorkerId());
         if (messages == null) {
             return;
         }
@@ -526,8 +532,8 @@ Calls the Worker (with id - workerId) object's onmessage implementation with arg
                 WorkerObjectOnMessageCallback(Runtime.getCurrentRuntime().runtimeId, msg.arg2, msg.obj.toString());
             }
             /*
-            	Handle a 'Handshake' message sent from a new Worker,
-            	so that the Main may cache it and send messages to it later
+                Handle a 'Handshake' message sent from a new Worker,
+                so that the Main may verify that the Worker has not already terminated
              */
             else if (msg.arg1 == MessageType.Handshake) {
                 int senderRuntimeId = msg.arg2;
@@ -542,12 +548,31 @@ else if (msg.arg1 == MessageType.Handshake) {
 
                     return;
                 }
+            }
+            /*
+                Handle a 'WorkerReady' message sent after a Worker script has loaded,
+                so that the Main may cache it and send messages to it later
+             */
+            else if (msg.arg1 == MessageType.WorkerReady) {
+                int senderRuntimeId = msg.arg2;
+                Runtime workerRuntime = runtimeCache.get(senderRuntimeId);
+                Runtime mainRuntime = Runtime.getCurrentRuntime();
+
+                // If worker has had its close/terminate called before the threads could shake hands
+                if (workerRuntime == null) {
+                    if (mainRuntime.logger.isEnabled()) {
+                        mainRuntime.logger.write("Main thread couldn't mark worker (runtimeId: " + workerRuntime + ") as ready because it has been terminated!");
+                    }
+
+                    return;
+                }
 
                 /*
                 	Main thread now has a reference to the Worker's handler,
                 	so messaging between the two threads can begin
                  */
                 mainRuntime.workerIdToHandler.put(workerRuntime.getWorkerId(), workerRuntime.getHandler());
+                workerRuntime.processPendingMessages();
 
                 if (mainRuntime.logger.isEnabled()) {
                     mainRuntime.logger.write("Worker thread (workerId:" + workerRuntime.getWorkerId() + ") shook hands with the main thread!");
@@ -1469,6 +1494,7 @@ public static void sendMessageFromMainToWorker(int workerId, String message) {
         Message msg = Message.obtain();
         msg.obj = message;
         msg.arg1 = MessageType.MainToWorker;
+        msg.arg2 = workerId;
 
         boolean hasKey = currentRuntime.workerIdToHandler.containsKey(workerId);
         Handler workerHandler = currentRuntime.workerIdToHandler.get(workerId);