@capgo/capacitor-webview-crash 8.0.3 → 8.1.0

package/README.md

@@ -18,12 +18,15 @@
   </h2>
 </div>
 
-Detect a recovered Capacitor WebView crash and give the next JavaScript runtime the native crash marker it needs to recover application state.
+Detect recovered Capacitor WebView crashes, restart dead WebViews natively, and optionally recycle long-running WebViews on a fixed interval before memory pressure turns into an OOM.
 
 ## What It Does
 
 - Stores a native crash marker when Android reports `onRenderProcessGone`.
 - Hooks the iOS WebView termination callback and persists equivalent crash metadata.
+- Restarts the WebView natively after crashes so recovery does not depend on a still-running JavaScript runtime.
+- Can restart the WebView on a fixed native interval for kiosk, POS, signage, telemetry, and other always-on apps.
+- Lets JavaScript request a native WebView restart with `restartWebView()` when the app wants to proactively recycle memory.
 - Exposes the marker through an event, a polling method, and a simulation helper for testing recovery flows.
 - Ships a web implementation that simulates the same recovery flow with local storage.
 
@@ -31,6 +34,7 @@ Detect a recovered Capacitor WebView crash and give the next JavaScript runtime
 
 - Prevent the underlying WebView crash from happening.
 - Restore lost in-memory JavaScript state automatically.
+- Replace application-level state persistence. Persist critical state before enabling scheduled restarts.
 
 ## Compatibility
 
@@ -62,18 +66,75 @@ await WebViewCrash.addListener('webViewRestoredAfterCrash', async (info) => {
   await WebViewCrash.clearPendingCrashInfo();
 });
 
+await WebViewCrash.addListener('webViewRestoredAfterRestart', async (info) => {
+  console.log('Recovered after a native WebView restart', info);
+  await WebViewCrash.clearPendingCrashInfo();
+});
+
 const pending = await WebViewCrash.getPendingCrashInfo();
 if (pending.value) {
-  console.log('Pending crash marker', pending.value);
+  console.log('Pending crash or restart marker', pending.value);
 }
 ```
 
 Use `simulateCrashRecovery()` in development or automated tests to exercise your recovery UI without forcing a real native WebView crash.
 
+Call `restartWebView()` when the current JavaScript runtime decides the native WebView should be replaced:
+
+```typescript
+await WebViewCrash.restartWebView();
+```
+
+The call writes a pending marker with `reason: 'manualRestart'`, then native code restarts the WebView. Android recreates the host Activity. iOS rebuilds the Capacitor bridge view so a new `WKWebView` is created instead of reloading the current page.
+
+## Native Auto Restart
+
+Configure the plugin in `capacitor.config.ts` so restart decisions happen in native code, even when the JavaScript runtime is unavailable:
+
+```typescript
+import type { CapacitorConfig } from '@capacitor/cli';
+import type { WebViewCrashPluginConfig } from '@capgo/capacitor-webview-crash';
+
+const webViewCrash: WebViewCrashPluginConfig = {
+  // Keep native crash recovery enabled. This is the default.
+  restartOnCrash: true,
+
+  // Use a 5-field cron schedule in the device local timezone.
+  // Do not combine restartCron with an active restartIntervalMs.
+  restartCron: '0 3 * * *',
+
+  // Optional delay before restarting after a crash.
+  restartAfterCrashDelayMs: 0,
+};
+
+const config: CapacitorConfig = {
+  plugins: {
+    WebViewCrash: webViewCrash,
+  },
+};
+
+export default config;
+```
+
+Use scheduled restarts for apps that stay open for days: kiosk screens, control-room dashboards, point-of-sale terminals, warehouse scanners, vehicle tablets, or any Capacitor app that cannot rely on users force-closing it. The restart is native, writes a pending marker with `reason: 'periodicRestart'`, and then creates a fresh WebView.
+
+Set `restartIntervalMs` to a maintenance window that your product can tolerate, or set `restartCron` for a wall-clock schedule such as `0 3 * * *` for a daily 03:00 restart. `restartCron` uses 5-field cron syntax in the device local timezone and supports `*`, lists, ranges, and steps. Do not configure both schedules at once: native initialization throws a fatal config error when `restartCron` is set and `restartIntervalMs` is greater than `0`. The user will get a fresh JavaScript runtime, so persist unsaved form state, queued events, and in-progress work before enabling a short interval or cron schedule.
+
+## Config Type
+
+```typescript
+export interface WebViewCrashPluginConfig {
+  restartOnCrash?: boolean;
+  restartIntervalMs?: number;
+  restartCron?: string;
+  restartAfterCrashDelayMs?: number;
+}
+```
+
 ## Platform Notes
 
-- **iOS:** Uses method swizzling on Capacitor's `WebViewDelegationHandler` to persist crash metadata before Capacitor reloads the WebView. No extra permissions are required.
-- **Android:** Registers a Capacitor `WebViewListener` and persists crash metadata from `onRenderProcessGone`. No extra permissions are required.
+- **iOS:** Uses method swizzling on Capacitor's `WebViewDelegationHandler` to persist crash metadata before Capacitor reloads the WebView. Manual and scheduled restarts rebuild the Capacitor bridge view so a new `WKWebView` instance is created. No extra permissions are required.
+- **Android:** Registers a Capacitor `WebViewListener` and persists crash metadata from `onRenderProcessGone`. Crash and scheduled restarts reset the bridge and recreate the host activity, giving the app a fresh WebView. No extra permissions are required.
 - **Web:** There is no real browser crash detection. The web implementation only simulates the recovery flow with local storage.
 
 ## Documentation
@@ -89,7 +150,8 @@ Use `simulateCrashRecovery()` in development or automated tests to exercise your
 - [`getPendingCrashInfo()`](#getpendingcrashinfo)
 - [`clearPendingCrashInfo()`](#clearpendingcrashinfo)
 - [`simulateCrashRecovery()`](#simulatecrashrecovery)
-- [`addListener('webViewRestoredAfterCrash', ...)`](#addlistenerwebviewrestoredaftercrash-)
+- [`restartWebView()`](#restartwebview)
+- [`addListener('webViewRestoredAfterCrash' | 'webViewRestoredAfterRestart', ...)`](#addlistenerwebviewrestoredaftercrash--webviewrestoredafterrestart-)
 - [`removeAllListeners()`](#removealllisteners)
 - [Interfaces](#interfaces)
 - [Type Aliases](#type-aliases)
@@ -99,7 +161,7 @@ Use `simulateCrashRecovery()` in development or automated tests to exercise your
 <docgen-api>
 <!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
 
-Capacitor API for recovered WebView crash detection.
+Capacitor API for recovered WebView crash and restart detection.
 
 ### getPendingCrashInfo()
 
@@ -107,7 +169,7 @@ Capacitor API for recovered WebView crash detection.
 getPendingCrashInfo() => Promise<PendingCrashInfoResult>
 ```
 
-Returns the pending native crash marker, if one exists.
+Returns the pending native crash or restart marker, if one exists.
 
 **Returns:** <code>Promise&lt;<a href="#pendingcrashinforesult">PendingCrashInfoResult</a>&gt;</code>
 
@@ -119,7 +181,7 @@ Returns the pending native crash marker, if one exists.
 clearPendingCrashInfo() => Promise<void>
 ```
 
-Clears the stored crash marker after the app has handled recovery.
+Clears the stored marker after the app has handled recovery.
 
 ---
 
@@ -135,17 +197,32 @@ Creates a fake crash marker so recovery flows can be tested locally.
 
 ---
 
-### addListener('webViewRestoredAfterCrash', ...)
+### restartWebView()
+
+```typescript
+restartWebView() => Promise<PendingCrashInfoResult>
+```
+
+Stores a manual restart marker and asks native code to create a fresh WebView.
+
+On Android this recreates the host Activity. On iOS this rebuilds the Capacitor bridge view so a new `WKWebView`
+instance is created instead of reloading the current page.
+
+**Returns:** <code>Promise&lt;<a href="#pendingcrashinforesult">PendingCrashInfoResult</a>&gt;</code>
+
+---
+
+### addListener('webViewRestoredAfterCrash' | 'webViewRestoredAfterRestart', ...)
 
 ```typescript
-addListener(eventName: 'webViewRestoredAfterCrash', listenerFunc: (info: WebViewCrashInfo) => void) => Promise<PluginListenerHandle>
+addListener(eventName: 'webViewRestoredAfterCrash' | 'webViewRestoredAfterRestart', listenerFunc: (info: WebViewCrashInfo) => void) => Promise<PluginListenerHandle>
 ```
 
-Fires after a new JavaScript runtime attaches a listener and a crash marker is still pending.
+Fires after a new JavaScript runtime attaches a listener and a matching marker is still pending.
 
 | Param              | Type                                                                             |
 | ------------------ | -------------------------------------------------------------------------------- |
-| **`eventName`**    | <code>'webViewRestoredAfterCrash'</code>                                         |
+| **`eventName`**    | <code>'webViewRestoredAfterCrash' \| 'webViewRestoredAfterRestart'</code>        |
 | **`listenerFunc`** | <code>(info: <a href="#webviewcrashinfo">WebViewCrashInfo</a>) =&gt; void</code> |
 
 **Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
@@ -166,26 +243,26 @@ Removes all plugin listeners.
 
 #### PendingCrashInfoResult
 
-Pending crash marker returned to JavaScript.
+Pending crash or restart marker returned to JavaScript.
 
-| Prop        | Type                                                                  | Description                                                 |
-| ----------- | --------------------------------------------------------------------- | ----------------------------------------------------------- |
-| **`value`** | <code><a href="#webviewcrashinfo">WebViewCrashInfo</a> \| null</code> | Stored crash metadata, or `null` when no marker is pending. |
+| Prop        | Type                                                                  | Description                                                            |
+| ----------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| **`value`** | <code><a href="#webviewcrashinfo">WebViewCrashInfo</a> \| null</code> | Stored crash or restart metadata, or `null` when no marker is pending. |
 
 #### WebViewCrashInfo
 
-Metadata captured natively after the previous WebView process died.
+Metadata captured natively after the previous WebView process died or was restarted.
 
-| Prop                         | Type                                                                  | Description                                                            |
-| ---------------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| **`platform`**               | <code><a href="#webviewcrashplatform">WebViewCrashPlatform</a></code> | Platform that detected and stored the crash marker.                    |
-| **`timestamp`**              | <code>number</code>                                                   | Unix timestamp in milliseconds for when the crash marker was written.  |
-| **`timestampISO`**           | <code>string</code>                                                   | ISO-8601 version of `timestamp`.                                       |
-| **`reason`**                 | <code><a href="#webviewcrashreason">WebViewCrashReason</a></code>     | Platform-specific reason for the crash marker.                         |
-| **`url`**                    | <code>string</code>                                                   | Last known WebView URL when the crash marker was written.              |
-| **`didCrash`**               | <code>boolean</code>                                                  | Android-only hint from `RenderProcessGoneDetail.didCrash()`.           |
-| **`rendererPriorityAtExit`** | <code>number</code>                                                   | Android-only renderer priority reported at exit.                       |
-| **`appState`**               | <code><a href="#webviewcrashappstate">WebViewCrashAppState</a></code> | iOS-only application state captured when the crash marker was written. |
+| Prop                         | Type                                                                  | Description                                                      |
+| ---------------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------- |
+| **`platform`**               | <code><a href="#webviewcrashplatform">WebViewCrashPlatform</a></code> | Platform that detected and stored the marker.                    |
+| **`timestamp`**              | <code>number</code>                                                   | Unix timestamp in milliseconds for when the marker was written.  |
+| **`timestampISO`**           | <code>string</code>                                                   | ISO-8601 version of `timestamp`.                                 |
+| **`reason`**                 | <code><a href="#webviewcrashreason">WebViewCrashReason</a></code>     | Platform-specific reason for the crash or restart marker.        |
+| **`url`**                    | <code>string</code>                                                   | Last known WebView URL when the marker was written.              |
+| **`didCrash`**               | <code>boolean</code>                                                  | Android-only hint from `RenderProcessGoneDetail.didCrash()`.     |
+| **`rendererPriorityAtExit`** | <code>number</code>                                                   | Android-only renderer priority reported at exit.                 |
+| **`appState`**               | <code><a href="#webviewcrashappstate">WebViewCrashAppState</a></code> | iOS-only application state captured when the marker was written. |
 
 #### PluginListenerHandle
 
@@ -197,15 +274,15 @@ Metadata captured natively after the previous WebView process died.
 
 #### WebViewCrashPlatform
 
-Platform that produced the stored crash marker.
+Platform that produced the stored marker.
 
 <code>'android' | 'ios' | 'web'</code>
 
 #### WebViewCrashReason
 
-Native reason reported for the previous WebView failure.
+Native reason reported for the previous WebView failure or restart.
 
-<code>'renderProcessGone' | 'webContentProcessDidTerminate' | 'simulated'</code>
+<code>'renderProcessGone' | 'webContentProcessDidTerminate' | 'periodicRestart' | 'manualRestart' | 'simulated'</code>
 
 #### WebViewCrashAppState
 

package/android/src/main/java/app/capgo/webviewcrash/WebViewCrash.java

@@ -2,12 +2,20 @@ package app.capgo.webviewcrash;
 
 import android.content.Context;
 import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginConfig;
+import java.time.Duration;
 import java.time.Instant;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoUnit;
 import org.json.JSONException;
 
 final class WebViewCrash {
 
-    static final String EVENT_NAME = "webViewRestoredAfterCrash";
+    static final String CRASH_EVENT_NAME = "webViewRestoredAfterCrash";
+    static final String RESTART_EVENT_NAME = "webViewRestoredAfterRestart";
+    static final String PERIODIC_RESTART_REASON = "periodicRestart";
+    static final String MANUAL_RESTART_REASON = "manualRestart";
 
     private static final String PREFERENCES_NAME = "CapgoWebViewCrash";
     private static final String PENDING_CRASH_KEY = "pendingCrashInfo";
@@ -55,4 +63,226 @@ final class WebViewCrash {
     void clearPendingCrashInfo(Context context) {
         context.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE).edit().remove(PENDING_CRASH_KEY).apply();
     }
+
+    boolean shouldDispatchEvent(String eventName, JSObject crashInfo) {
+        if (RESTART_EVENT_NAME.equals(eventName)) {
+            return true;
+        }
+
+        if (!CRASH_EVENT_NAME.equals(eventName)) {
+            return false;
+        }
+
+        String reason = crashInfo.optString("reason", "");
+        return !PERIODIC_RESTART_REASON.equals(reason) && !MANUAL_RESTART_REASON.equals(reason);
+    }
+
+    RestartOptions readRestartOptions(PluginConfig config) {
+        int restartIntervalMs = Math.max(0, config.getInt("restartIntervalMs", 0));
+        String restartCronExpression = config.getString("restartCron", null);
+
+        validateRestartScheduleConfig(restartIntervalMs, restartCronExpression);
+
+        return new RestartOptions(
+            config.getBoolean("restartOnCrash", true),
+            restartIntervalMs,
+            CronSchedule.parse(restartCronExpression),
+            Math.max(0, config.getInt("restartAfterCrashDelayMs", 0))
+        );
+    }
+
+    static void validateRestartScheduleConfig(int restartIntervalMs, String restartCronExpression) {
+        if (restartIntervalMs > 0 && restartCronExpression != null && !restartCronExpression.isBlank()) {
+            throw new IllegalStateException("Invalid WebViewCrash config: set either restartIntervalMs or restartCron, not both.");
+        }
+    }
+
+    static final class RestartOptions {
+
+        final boolean restartOnCrash;
+        final int restartIntervalMs;
+        final CronSchedule restartCron;
+        final int restartAfterCrashDelayMs;
+
+        RestartOptions(boolean restartOnCrash, int restartIntervalMs, CronSchedule restartCron, int restartAfterCrashDelayMs) {
+            this.restartOnCrash = restartOnCrash;
+            this.restartIntervalMs = restartIntervalMs;
+            this.restartCron = restartCron;
+            this.restartAfterCrashDelayMs = restartAfterCrashDelayMs;
+        }
+
+        Long nextRestartDelayMs() {
+            if (restartCron != null) {
+                return restartCron.nextDelayMs();
+            }
+
+            return restartIntervalMs > 0 ? (long) restartIntervalMs : null;
+        }
+    }
+
+    static final class CronSchedule {
+
+        private static final int SEARCH_LIMIT_MINUTES = 366 * 24 * 60 * 5;
+
+        private final CronField minutes;
+        private final CronField hours;
+        private final CronField daysOfMonth;
+        private final CronField months;
+        private final CronField daysOfWeek;
+
+        private CronSchedule(CronField minutes, CronField hours, CronField daysOfMonth, CronField months, CronField daysOfWeek) {
+            this.minutes = minutes;
+            this.hours = hours;
+            this.daysOfMonth = daysOfMonth;
+            this.months = months;
+            this.daysOfWeek = daysOfWeek;
+        }
+
+        static CronSchedule parse(String expression) {
+            if (expression == null || expression.isBlank()) {
+                return null;
+            }
+
+            String[] parts = expression.trim().split("\\s+");
+            if (parts.length != 5) {
+                return null;
+            }
+
+            CronField minutes = CronField.parse(parts[0], 0, 59, false);
+            CronField hours = CronField.parse(parts[1], 0, 23, false);
+            CronField daysOfMonth = CronField.parse(parts[2], 1, 31, false);
+            CronField months = CronField.parse(parts[3], 1, 12, false);
+            CronField daysOfWeek = CronField.parse(parts[4], 0, 7, true);
+
+            if (minutes == null || hours == null || daysOfMonth == null || months == null || daysOfWeek == null) {
+                return null;
+            }
+
+            return new CronSchedule(minutes, hours, daysOfMonth, months, daysOfWeek);
+        }
+
+        Long nextDelayMs() {
+            ZonedDateTime now = ZonedDateTime.now(ZoneId.systemDefault());
+            ZonedDateTime candidate = now.truncatedTo(ChronoUnit.MINUTES).plusMinutes(1);
+
+            for (int index = 0; index < SEARCH_LIMIT_MINUTES; index++) {
+                if (matches(candidate)) {
+                    return Math.max(0, Duration.between(now, candidate).toMillis());
+                }
+
+                candidate = candidate.plusMinutes(1);
+            }
+
+            return null;
+        }
+
+        private boolean matches(ZonedDateTime value) {
+            if (!minutes.matches(value.getMinute()) || !hours.matches(value.getHour()) || !months.matches(value.getMonthValue())) {
+                return false;
+            }
+
+            boolean dayOfMonthMatches = daysOfMonth.matches(value.getDayOfMonth());
+            boolean dayOfWeekMatches = daysOfWeek.matches(value.getDayOfWeek().getValue() % 7);
+
+            if (daysOfMonth.restricted && daysOfWeek.restricted) {
+                return dayOfMonthMatches || dayOfWeekMatches;
+            }
+
+            return dayOfMonthMatches && dayOfWeekMatches;
+        }
+    }
+
+    private static final class CronField {
+
+        private final boolean[] values;
+        private final boolean restricted;
+
+        private CronField(boolean[] values, boolean restricted) {
+            this.values = values;
+            this.restricted = restricted;
+        }
+
+        static CronField parse(String expression, int min, int max, boolean normalizeSunday) {
+            boolean[] values = new boolean[normalizeSunday ? 7 : max + 1];
+
+            for (String part : expression.split(",", -1)) {
+                if (part.isBlank() || !applyPart(values, part, min, max, normalizeSunday)) {
+                    return null;
+                }
+            }
+
+            int selectedCount = 0;
+            for (boolean selected : values) {
+                if (selected) {
+                    selectedCount++;
+                }
+            }
+
+            if (selectedCount == 0) {
+                return null;
+            }
+
+            int allValueCount = normalizeSunday ? 7 : max - min + 1;
+            return new CronField(values, selectedCount != allValueCount);
+        }
+
+        boolean matches(int value) {
+            return value >= 0 && value < values.length && values[value];
+        }
+
+        private static boolean applyPart(boolean[] values, String part, int min, int max, boolean normalizeSunday) {
+            String[] stepParts = part.split("/", -1);
+            if (stepParts.length > 2) {
+                return false;
+            }
+
+            int step = 1;
+            if (stepParts.length == 2) {
+                step = parseNumber(stepParts[1]);
+                if (step <= 0) {
+                    return false;
+                }
+            }
+
+            String rangePart = stepParts[0];
+            int start;
+            int end;
+            if ("*".equals(rangePart)) {
+                start = min;
+                end = max;
+            } else if (rangePart.contains("-")) {
+                String[] range = rangePart.split("-", -1);
+                if (range.length != 2) {
+                    return false;
+                }
+                start = parseNumber(range[0]);
+                end = parseNumber(range[1]);
+            } else {
+                start = parseNumber(rangePart);
+                end = start;
+            }
+
+            if (start < min || end > max || start > end) {
+                return false;
+            }
+
+            for (int value = start; value <= end; value += step) {
+                values[normalizeValue(value, normalizeSunday)] = true;
+            }
+
+            return true;
+        }
+
+        private static int parseNumber(String value) {
+            try {
+                return Integer.parseInt(value);
+            } catch (NumberFormatException ignored) {
+                return -1;
+            }
+        }
+
+        private static int normalizeValue(int value, boolean normalizeSunday) {
+            return normalizeSunday && value == 7 ? 0 : value;
+        }
+    }
 }

package/android/src/main/java/app/capgo/webviewcrash/WebViewCrashPlugin.java

@@ -1,5 +1,7 @@
 package app.capgo.webviewcrash;
 
+import android.os.Handler;
+import android.os.Looper;
 import android.webkit.RenderProcessGoneDetail;
 import android.webkit.WebView;
 import androidx.appcompat.app.AppCompatActivity;
@@ -9,12 +11,26 @@ import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.WebViewListener;
 import com.getcapacitor.annotation.CapacitorPlugin;
+import java.util.HashSet;
+import java.util.Set;
 
 @CapacitorPlugin(name = "WebViewCrash")
 public class WebViewCrashPlugin extends Plugin {
 
     private final WebViewCrash implementation = new WebViewCrash();
-    private boolean didDispatchPendingEvent = false;
+    private final Set<String> dispatchedPendingEvents = new HashSet<>();
+    private WebViewCrash.RestartOptions restartOptions = new WebViewCrash.RestartOptions(true, 0, null, 0);
+    private Handler mainHandler;
+
+    private final Runnable periodicRestartRunnable = () -> {
+        WebView webView = bridge != null ? bridge.getWebView() : null;
+        String url = webView != null ? webView.getUrl() : null;
+        JSObject restartInfo = implementation.buildCrashInfo(WebViewCrash.PERIODIC_RESTART_REASON, url, null, null);
+
+        implementation.writePendingCrashInfo(getContext(), restartInfo);
+        dispatchedPendingEvents.clear();
+        restartWebView(0);
+    };
 
     private final WebViewListener webViewListener = new WebViewListener() {
         @Override
@@ -27,36 +43,37 @@ public class WebViewCrashPlugin extends Plugin {
             );
 
             implementation.writePendingCrashInfo(getContext(), crashInfo);
-            didDispatchPendingEvent = false;
+            dispatchedPendingEvents.clear();
 
-            AppCompatActivity currentActivity = getActivity();
-            if (currentActivity != null) {
-                currentActivity.runOnUiThread(() -> {
-                    bridge.reset();
-                    currentActivity.recreate();
-                });
+            if (!restartOptions.restartOnCrash) {
+                return false;
             }
 
+            restartWebView(restartOptions.restartAfterCrashDelayMs);
             return true;
         }
     };
 
     @Override
     public void load() {
+        restartOptions = implementation.readRestartOptions(getConfig());
         bridge.addWebViewListener(webViewListener);
+        schedulePeriodicRestart();
     }
 
     @Override
     protected void handleOnDestroy() {
         bridge.removeWebViewListener(webViewListener);
+        cancelPeriodicRestart();
     }
 
     @Override
     public void addListener(PluginCall call) {
         super.addListener(call);
 
-        if (WebViewCrash.EVENT_NAME.equals(call.getString("eventName"))) {
-            dispatchPendingCrashIfNeeded();
+        String eventName = call.getString("eventName");
+        if (WebViewCrash.CRASH_EVENT_NAME.equals(eventName) || WebViewCrash.RESTART_EVENT_NAME.equals(eventName)) {
+            dispatchPendingCrashIfNeeded(eventName);
         }
     }
 
@@ -70,7 +87,7 @@ public class WebViewCrashPlugin extends Plugin {
     @PluginMethod
     public void clearPendingCrashInfo(PluginCall call) {
         implementation.clearPendingCrashInfo(getContext());
-        didDispatchPendingEvent = false;
+        dispatchedPendingEvents.clear();
         call.resolve();
     }
 
@@ -80,25 +97,89 @@ public class WebViewCrashPlugin extends Plugin {
         JSObject crashInfo = implementation.buildCrashInfo("simulated", url, null, null);
 
         implementation.writePendingCrashInfo(getContext(), crashInfo);
-        didDispatchPendingEvent = false;
-        dispatchPendingCrashIfNeeded();
+        dispatchedPendingEvents.clear();
+        dispatchPendingCrashIfNeeded(WebViewCrash.CRASH_EVENT_NAME);
+        dispatchPendingCrashIfNeeded(WebViewCrash.RESTART_EVENT_NAME);
 
         JSObject result = new JSObject();
         result.put("value", crashInfo);
         call.resolve(result);
     }
 
-    private void dispatchPendingCrashIfNeeded() {
-        if (didDispatchPendingEvent) {
+    @PluginMethod
+    public void restartWebView(PluginCall call) {
+        WebView webView = bridge != null ? bridge.getWebView() : null;
+        String url = webView != null ? webView.getUrl() : null;
+        JSObject restartInfo = implementation.buildCrashInfo(WebViewCrash.MANUAL_RESTART_REASON, url, null, null);
+
+        implementation.writePendingCrashInfo(getContext(), restartInfo);
+        dispatchedPendingEvents.clear();
+
+        JSObject result = new JSObject();
+        result.put("value", restartInfo);
+        call.resolve(result);
+
+        restartWebView(0);
+    }
+
+    private void dispatchPendingCrashIfNeeded(String eventName) {
+        if (dispatchedPendingEvents.contains(eventName)) {
             return;
         }
 
         JSObject crashInfo = implementation.readPendingCrashInfo(getContext());
-        if (crashInfo == null) {
+        if (crashInfo == null || !implementation.shouldDispatchEvent(eventName, crashInfo)) {
+            return;
+        }
+
+        dispatchedPendingEvents.add(eventName);
+        notifyListeners(eventName, crashInfo);
+    }
+
+    private void schedulePeriodicRestart() {
+        cancelPeriodicRestart();
+        Long delayMs = restartOptions.nextRestartDelayMs();
+        if (delayMs == null || delayMs <= 0) {
             return;
         }
 
-        didDispatchPendingEvent = true;
-        notifyListeners(WebViewCrash.EVENT_NAME, crashInfo);
+        getMainHandler().postDelayed(periodicRestartRunnable, delayMs);
+    }
+
+    private void cancelPeriodicRestart() {
+        if (mainHandler != null) {
+            mainHandler.removeCallbacks(periodicRestartRunnable);
+        }
+    }
+
+    private void restartWebView(int delayMs) {
+        Runnable restart = () -> {
+            AppCompatActivity currentActivity = getActivity();
+            if (currentActivity == null) {
+                schedulePeriodicRestart();
+                return;
+            }
+
+            currentActivity.runOnUiThread(() -> {
+                if (bridge != null) {
+                    bridge.reset();
+                }
+                currentActivity.recreate();
+            });
+        };
+
+        if (delayMs > 0) {
+            getMainHandler().postDelayed(restart, delayMs);
+        } else {
+            getMainHandler().post(restart);
+        }
+    }
+
+    private Handler getMainHandler() {
+        if (mainHandler == null) {
+            mainHandler = new Handler(Looper.getMainLooper());
+        }
+
+        return mainHandler;
     }
 }