NativeScript · NathanWalker · Jun 7, 2026 · Jun 25, 2026 · Jun 25, 2026 · Jun 25, 2026
diff --git a/test-app/app/src/main/java/com/tns/NativeScriptRuntime.java b/test-app/app/src/main/java/com/tns/NativeScriptRuntime.java
@@ -0,0 +1,14 @@
+package com.tns;
+
+public final class NativeScriptRuntime {
+    private NativeScriptRuntime() {
+    }
+
+    public static boolean reloadApplication() {
+        return RuntimeHelper.reloadApplication();
+    }
+
+    public static boolean reloadApplication(String baseDir) {
+        return RuntimeHelper.reloadApplication(baseDir);
+    }
+}
diff --git a/test-app/app/src/main/java/com/tns/RuntimeHelper.java b/test-app/app/src/main/java/com/tns/RuntimeHelper.java
@@ -8,6 +8,8 @@
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.preference.PreferenceManager;
 import android.util.Log;
 
@@ -24,6 +26,9 @@ private RuntimeHelper() {
     }
 
     private static AndroidJsV8Inspector v8Inspector;
+    private static Context applicationContext;
+    private static BroadcastReceiver timezoneChangedReceiver;
+    private static boolean reloadScheduled;
 
     // hasErrorIntent tells you if there was an event (with an uncaught
     // exception) raised from ErrorReport
@@ -59,6 +64,9 @@ private static boolean hasErrorIntent(Context context) {
     }
 
     public static Runtime initRuntime(Context context) {
+        Context appContext = context.getApplicationContext();
+        applicationContext = appContext != null ? appContext : context;
+
         if (Runtime.isInitialized()) {
             return Runtime.getCurrentRuntime();
         }
@@ -237,6 +245,45 @@ public static Runtime initRuntime(Context context) {
         }
     }
 
+    // The overload is kept for API parity with ios, but not needed with android.
+    public static synchronized boolean reloadApplication(String baseDir) {
+        return reloadApplication();
+    }
+
+    public static synchronized boolean reloadApplication() {
+        final Context context = applicationContext;
+        if (context == null || reloadScheduled) {
+            return false;
+        }
+
+        reloadScheduled = true;
+
+        new Handler(Looper.getMainLooper()).post(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Runtime.destroyMainRuntime();
+
+                    Runtime runtime = initRuntime(context);
+                    if (runtime == null) {
+                        throw new IllegalStateException("NativeScript runtime reload failed to initialize a new runtime.");
+                    }
+
+                    runtime.run();
+                } catch (Throwable e) {
+                    Log.e(logTag, "NativeScript runtime reload failed.", e);
+                    throw new RuntimeException("NativeScript runtime reload failed.", e);
+                } finally {
+                    synchronized (RuntimeHelper.class) {
+                        reloadScheduled = false;
+                    }
+                }
+            }
+        });
+
+        return true;
+    }
+
     private static void waitForLiveSync(Context context) {
         boolean needToWait = false;
 
@@ -265,6 +312,12 @@ private static void waitForLiveSync(Context context) {
     }
 
     private static void registerTimezoneChangedListener(Context context, final Runtime runtime) {
+        // Register/unregister against the application context so the same Context
+        // instance is used across initial launch and reload. Using the passed-in
+        // context (which may be an Activity on first launch but applicationContext
+        // on reload) would make unregisterReceiver fail and leak the old receiver.
+        final Context receiverContext = applicationContext != null ? applicationContext : context;
+
         IntentFilter timezoneFilter = new IntentFilter(Intent.ACTION_TIMEZONE_CHANGED);
 
         BroadcastReceiver timezoneReceiver = new BroadcastReceiver() {
@@ -295,7 +348,16 @@ public void onReceive(Context context, Intent intent) {
             }
         };
 
-        context.registerReceiver(timezoneReceiver, timezoneFilter);
+        if (timezoneChangedReceiver != null) {
+            try {
+                receiverContext.unregisterReceiver(timezoneChangedReceiver);
+            } catch (IllegalArgumentException e) {
+                // Already unregistered.
+            }
+        }
+
+        timezoneChangedReceiver = timezoneReceiver;
+        receiverContext.registerReceiver(timezoneChangedReceiver, timezoneFilter);
     }
 
     public static void initLiveSync(Application app) {

diff --git a/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp b/test-app/runtime/src/main/cpp/com_tns_Runtime.cpp
@@ -2,6 +2,7 @@
 #include "Runtime.h"
 #include "NativeScriptException.h"
 #include "CallbackHandlers.h"
+#include "WorkerWrapper.h"
 #include <sstream>
 #include <android/log.h>
 
@@ -352,6 +353,33 @@ extern "C" JNIEXPORT jint Java_com_tns_Runtime_getCurrentRuntimeIdLegacy(JNIEnv*
     return getCurrentRuntimeIdCritical_impl();
 }
 
+extern "C" JNIEXPORT void Java_com_tns_Runtime_TerminateRuntimeCallback(JNIEnv* env, jobject obj, jint runtimeId) {
+    auto runtime = TryGetRuntime(runtimeId);
+    if (runtime == nullptr) {
+        // TODO: Pete: Log message informing the developer of the failure
+        return;
+    }
+
+    auto isolate = runtime->GetIsolate();
+
+    // Terminate this runtime's child workers before disposing the isolate. Their
+    // Worker object persistents live in this isolate, so they must be released
+    // first - mirrors WorkerWrapper::BackgroundLooper's nested-worker teardown.
+    WorkerWrapper::TerminateChildren(isolate);
+
+    {
+        v8::Locker locker(isolate);
+        v8::Isolate::Scope isolate_scope(isolate);
+        v8::HandleScope handleScope(isolate);
+
+        runtime->DestroyRuntime();
+    }
+
+    isolate->Dispose();
+
+    delete runtime;
+}
+
 extern "C" JNIEXPORT void Java_com_tns_Runtime_ResetDateTimeConfigurationCache(JNIEnv* _env, jobject obj, jint runtimeId) {
     auto runtime = TryGetRuntime(runtimeId);
     if (runtime == nullptr) {
@@ -360,4 +388,4 @@ extern "C" JNIEXPORT void Java_com_tns_Runtime_ResetDateTimeConfigurationCache(J
 
     auto isolate = runtime->GetIsolate();
     isolate->DateTimeConfigurationChangeNotification(Isolate::TimeZoneDetection::kRedetect);
-}
+}
diff --git a/test-app/runtime/src/main/java/com/tns/Runtime.java b/test-app/runtime/src/main/java/com/tns/Runtime.java
@@ -105,6 +105,8 @@ public static void SetManualInstrumentationMode(String mode) {
         }
     }
 
+    private static native void TerminateRuntimeCallback(int runtimeId);
+
     private static native void ResetDateTimeConfigurationCache(int runtimeId);
 
     void passUncaughtExceptionToJs(Throwable ex, String message, String fullStackTrace, String jsStackTrace) {
@@ -454,6 +456,26 @@ public static boolean isInitialized() {
         return (runtime != null) ? runtime.isInitializedImpl() : false;
     }
 
+    static void destroyMainRuntime() {
+        Runtime runtime = Runtime.getCurrentRuntime();
+        if (runtime == null) {
+            return;
+        }
+
+        if (runtime.workerId != 0) {
+            throw new NativeScriptException("Only the main NativeScript runtime can be destroyed with destroyMainRuntime().");
+        }
+
+        GcListener.unsubscribe(runtime);
+        runtimeCache.remove(runtime.runtimeId);
+        currentRuntime.remove();
+
+        // Worker teardown happens natively in TerminateRuntimeCallback, which
+        // terminates this runtime's child workers (WorkerWrapper registry) before
+        // destroying the main isolate.
+        TerminateRuntimeCallback(runtime.runtimeId);
+    }
+
     public int getWorkerId() {
         return workerId;
     }