feat: reloadApplication for JS bundle restart without restarting app process

Helpful for programmatic reset of JS isolate for clean restart of JS application as well as OTA (over-the-air) updates without restarting the entire app process.

Author: NathanWalker

NativeScript/NativeScript.h

@@ -26,3 +26,10 @@
 - (bool)liveSync;
 
 @end
+
+@interface NativeScriptRuntime : NSObject
+
++ (BOOL)reloadApplication;
++ (BOOL)reloadApplication:(NSString*)baseDir;
+
+@end

NativeScript/NativeScript.mm

@@ -21,6 +21,21 @@ @implementation Config
 
 @end
 
+static Config* CopyConfig(Config* config) {
+  Config* copy = [[Config alloc] init];
+  copy.BaseDir = config.BaseDir;
+  copy.ApplicationPath = config.ApplicationPath;
+  copy.MetadataPtr = config.MetadataPtr;
+  copy.IsDebug = config.IsDebug;
+  copy.LogToSystemConsole = config.LogToSystemConsole;
+  copy.ArgumentsCount = config.ArgumentsCount;
+  copy.Arguments = config.Arguments;
+  return copy;
+}
+
+static NativeScript* currentNativeScript;
+static Config* currentConfig;
+
 @implementation NativeScript
 
 extern char defaultStartOfMetadataSection __asm("section$start$__DATA$__TNSMetadata");
@@ -66,6 +81,9 @@ - (void)shutdownRuntime {
 
 - (instancetype)initializeWithConfig:(Config*)config {
   if (self = [super init]) {
+    currentNativeScript = self;
+    currentConfig = CopyConfig(config);
+
     RuntimeConfig.BaseDir = [config.BaseDir UTF8String];
     if (config.ApplicationPath != nil) {
       RuntimeConfig.ApplicationPath =
@@ -82,6 +100,15 @@ - (instancetype)initializeWithConfig:(Config*)config {
     RuntimeConfig.IsDebug = [config IsDebug];
     RuntimeConfig.LogToSystemConsole = [config LogToSystemConsole];
 
+    // Connect the JS-exposed `NativeScriptRuntime.reloadApplication(baseDir?)`
+    // global (registered by the runtime) to the Objective-C implementation below.
+    tns::SetReloadApplicationHook([](const std::string& baseDir) -> bool {
+      NSString* dir = baseDir.empty()
+                          ? nil
+                          : [NSString stringWithUTF8String:baseDir.c_str()];
+      return [NativeScriptRuntime reloadApplication:dir] == YES;
+    });
+
     Runtime::Initialize();
     runtime_ = nullptr;
     runtime_ = std::make_unique<Runtime>();
@@ -119,3 +146,29 @@ - (void)restartWithConfig:(Config*)config {
 }
 
 @end
+
+@implementation NativeScriptRuntime
+
++ (BOOL)reloadApplication {
+  return [self reloadApplication:nil];
+}
+
++ (BOOL)reloadApplication:(NSString*)baseDir {
+  if (currentNativeScript == nil || currentConfig == nil) {
+    return NO;
+  }
+
+  Config* config = CopyConfig(currentConfig);
+  if (baseDir != nil && [baseDir length] > 0) {
+    config.BaseDir = baseDir;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [currentNativeScript restartWithConfig:config];
+    [currentNativeScript runMainApplication];
+  });
+
+  return YES;
+}
+
+@end

NativeScript/runtime/Runtime.h

@@ -9,12 +9,19 @@
 #include "SpinLock.h"
 #include "libplatform/libplatform.h"
 
+#include <functional>
+#include <string>
+
 // Declared rather than included: js_native_api_types.h pins NAPI_VERSION for
 // the whole translation unit, and Runtime.h reaches nearly all of them.
 typedef struct napi_env__* napi_env;
 
 namespace tns {
 
+using ReloadApplicationHook = std::function<bool(const std::string& baseDir)>;
+void SetReloadApplicationHook(ReloadApplicationHook hook);
+bool InvokeReloadApplicationHook(const std::string& baseDir);
+
 class Runtime {
  public:
   Runtime();
@@ -107,6 +114,8 @@ class Runtime {
   void DefineCollectFunction(v8::Local<v8::Context> context);
   void DefineNativeScriptVersion(v8::Isolate* isolate,
                                  v8::Local<v8::ObjectTemplate> globalTemplate);
+  void DefineNativeScriptRuntime(v8::Isolate* isolate,
+                                 v8::Local<v8::ObjectTemplate> globalTemplate);
   void DefineTimeMethod(v8::Isolate* isolate,
                         v8::Local<v8::ObjectTemplate> globalTemplate);
   void DefineDrainMicrotaskMethod(v8::Isolate* isolate,

NativeScript/runtime/Runtime.mm

@@ -343,6 +343,7 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
   tns::binding::CreateInternalBindingTemplates(isolate, globalTemplateFunction);
   Local<ObjectTemplate> globalTemplate = ObjectTemplate::New(isolate, globalTemplateFunction);
   DefineNativeScriptVersion(isolate, globalTemplate);
+  DefineNativeScriptRuntime(isolate, globalTemplate);
 
   // Worker::Init(isolate, globalTemplate, isWorker);
   DefineTimeMethod(isolate, globalTemplate);
@@ -562,6 +563,41 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
                       ToV8String(isolate, STRINGIZE_VALUE_OF(NATIVESCRIPT_VERSION)), readOnlyFlags);
 }
 
+static ReloadApplicationHook reloadApplicationHook_;
+
+void SetReloadApplicationHook(ReloadApplicationHook hook) {
+  reloadApplicationHook_ = std::move(hook);
+}
+
+bool InvokeReloadApplicationHook(const std::string& baseDir) {
+  if (!reloadApplicationHook_) {
+    return false;
+  }
+  return reloadApplicationHook_(baseDir);
+}
+
+// API to trigger application reload from JS without restarting the application process.
+// Exposes `global.NativeScriptRuntime.reloadApplication(baseDir?)` to JS.
+// `NativeScriptRuntime` class is part of the runtime framework and
+// is intentionally excluded from metadata generation, so it is not reachable
+// from JS on its own.
+void Runtime::DefineNativeScriptRuntime(Isolate* isolate, Local<ObjectTemplate> globalTemplate) {
+  Local<ObjectTemplate> runtimeTemplate = ObjectTemplate::New(isolate);
+
+  Local<FunctionTemplate> reloadTemplate =
+      FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {
+        Isolate* isolate = info.GetIsolate();
+        std::string baseDir;
+        if (info.Length() > 0 && info[0]->IsString()) {
+          baseDir = tns::ToString(isolate, info[0]);
+        }
+        info.GetReturnValue().Set(tns::InvokeReloadApplicationHook(baseDir));
+      });
+  runtimeTemplate->Set(ToV8String(isolate, "reloadApplication"), reloadTemplate);
+
+  globalTemplate->Set(ToV8String(isolate, "NativeScriptRuntime"), runtimeTemplate);
+}
+
 void Runtime::DefineTimeMethod(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> globalTemplate) {
   Local<FunctionTemplate> timeFunctionTemplate =
       FunctionTemplate::New(isolate, [](const FunctionCallbackInfo<Value>& info) {