@capgo/capacitor-updater 8.0.1 → 8.1.0

package/android/src/main/java/ee/forgr/capacitor_updater/CapacitorUpdaterPlugin.java

@@ -12,31 +12,36 @@ import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
+import android.graphics.Color;
 import android.os.Build;
+import android.os.Handler;
 import android.os.Looper;
-import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ProgressBar;
 import com.getcapacitor.CapConfig;
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginHandle;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
 import com.getcapacitor.plugin.WebView;
-import com.google.gson.Gson;
-import com.google.gson.reflect.TypeToken;
 import io.github.g00fy2.versioncompare.Version;
 import java.io.IOException;
-import java.lang.reflect.Type;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
-import java.util.Iterator;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.UUID;
@@ -45,36 +50,58 @@ import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicReference;
-import okhttp3.OkHttpClient;
-import okhttp3.Protocol;
+// Removed OkHttpClient and Protocol imports - using shared client in DownloadService instead
 import org.json.JSONArray;
 import org.json.JSONException;
+import org.json.JSONObject;
 
 @CapacitorPlugin(name = "CapacitorUpdater")
 public class CapacitorUpdaterPlugin extends Plugin {
 
+    private final Logger logger = new Logger("CapgoUpdater");
+
     private static final String updateUrlDefault = "https://plugin.capgo.app/updates";
     private static final String statsUrlDefault = "https://plugin.capgo.app/stats";
     private static final String channelUrlDefault = "https://plugin.capgo.app/channel_self";
-
-    private final String PLUGIN_VERSION = "8.0.1";
+    private static final String KEEP_URL_FLAG_KEY = "__capgo_keep_url_path_after_reload";
+    private static final String CUSTOM_ID_PREF_KEY = "CapacitorUpdater.customId";
+    private static final String UPDATE_URL_PREF_KEY = "CapacitorUpdater.updateUrl";
+    private static final String STATS_URL_PREF_KEY = "CapacitorUpdater.statsUrl";
+    private static final String CHANNEL_URL_PREF_KEY = "CapacitorUpdater.channelUrl";
+    private static final String DEFAULT_CHANNEL_PREF_KEY = "CapacitorUpdater.defaultChannel";
+    private static final String[] BREAKING_EVENT_NAMES = { "breakingAvailable", "majorAvailable" };
+    private static final String LAST_FAILED_BUNDLE_PREF_KEY = "CapacitorUpdater.lastFailedBundle";
+
+    private final String pluginVersion = "8.0.0";
     private static final String DELAY_CONDITION_PREFERENCES = "";
 
     private SharedPreferences.Editor editor;
     private SharedPreferences prefs;
-    protected CapacitorUpdater implementation;
+    protected CapgoUpdater implementation;
+    private Boolean persistCustomId = false;
+    private Boolean persistModifyUrl = false;
 
     private Integer appReadyTimeout = 10000;
-    private Integer counterActivityCreate = 0;
     private Integer periodCheckDelay = 0;
     private Boolean autoDeleteFailed = true;
     private Boolean autoDeletePrevious = true;
     private Boolean autoUpdate = false;
     private String updateUrl = "";
     private Version currentVersionNative;
+    private String currentBuildVersion;
     private Thread backgroundTask;
     private Boolean taskRunning = false;
     private Boolean keepUrlPathAfterReload = false;
+    private Boolean autoSplashscreen = false;
+    private Boolean autoSplashscreenLoader = false;
+    private Integer autoSplashscreenTimeout = 10000;
+    private Boolean autoSplashscreenTimedOut = false;
+    private String directUpdateMode = "false";
+    private Boolean wasRecentlyInstalledOrUpdated = false;
+    private Boolean onLaunchDirectUpdateUsed = false;
+    Boolean shakeMenuEnabled = false;
+    private Boolean allowManualBundleError = false;
+    private Boolean allowSetDefaultChannel = true;
 
     private Boolean isPreviousMainActivity = true;
 
@@ -86,6 +113,63 @@ public class CapacitorUpdaterPlugin extends Plugin {
 
     private int lastNotifiedStatPercent = 0;
 
+    private DelayUpdateUtils delayUpdateUtils;
+
+    private ShakeMenu shakeMenu;
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private FrameLayout splashscreenLoaderOverlay;
+    private Runnable splashscreenTimeoutRunnable;
+
+    private void notifyBreakingEvents(final String version) {
+        if (version == null || version.isEmpty()) {
+            return;
+        }
+        for (final String eventName : BREAKING_EVENT_NAMES) {
+            final JSObject payload = new JSObject();
+            payload.put("version", version);
+            CapacitorUpdaterPlugin.this.notifyListeners(eventName, payload);
+        }
+    }
+
+    private JSObject mapToJSObject(Map<String, Object> map) {
+        JSObject jsObject = new JSObject();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            jsObject.put(entry.getKey(), entry.getValue());
+        }
+        return jsObject;
+    }
+
+    private void persistLastFailedBundle(BundleInfo bundle) {
+        if (this.prefs == null) {
+            return;
+        }
+        final SharedPreferences.Editor localEditor = this.prefs.edit();
+        if (bundle == null) {
+            localEditor.remove(LAST_FAILED_BUNDLE_PREF_KEY);
+        } else {
+            final JSONObject json = new JSONObject(bundle.toJSONMap());
+            localEditor.putString(LAST_FAILED_BUNDLE_PREF_KEY, json.toString());
+        }
+        localEditor.apply();
+    }
+
+    private BundleInfo readLastFailedBundle() {
+        if (this.prefs == null) {
+            return null;
+        }
+        final String raw = this.prefs.getString(LAST_FAILED_BUNDLE_PREF_KEY, null);
+        if (raw == null || raw.trim().isEmpty()) {
+            return null;
+        }
+        try {
+            return BundleInfo.fromJSON(raw);
+        } catch (final JSONException e) {
+            logger.error("Failed to parse failed bundle info: " + e.getMessage());
+            this.persistLastFailedBundle(null);
+            return null;
+        }
+    }
+
     public Thread startNewThread(final Runnable function, Number waitTime) {
         Thread bgTask = new Thread(() -> {
             try {
@@ -108,64 +192,152 @@ public class CapacitorUpdaterPlugin extends Plugin {
     @Override
     public void load() {
         super.load();
-        this.counterActivityCreate++;
         this.prefs = this.getContext().getSharedPreferences(WebView.WEBVIEW_PREFS_NAME, Activity.MODE_PRIVATE);
         this.editor = this.prefs.edit();
 
         try {
-            this.implementation = new CapacitorUpdater() {
+            this.implementation = new CapgoUpdater(logger) {
                 @Override
                 public void notifyDownload(final String id, final int percent) {
-                    CapacitorUpdaterPlugin.this.notifyDownload(id, percent);
+                    activity.runOnUiThread(() -> {
+                        CapacitorUpdaterPlugin.this.notifyDownload(id, percent);
+                    });
                 }
 
                 @Override
                 public void directUpdateFinish(final BundleInfo latest) {
-                    CapacitorUpdaterPlugin.this.directUpdateFinish(latest);
+                    activity.runOnUiThread(() -> {
+                        CapacitorUpdaterPlugin.this.directUpdateFinish(latest);
+                    });
                 }
 
                 @Override
-                public void notifyListeners(final String id, final JSObject res) {
-                    CapacitorUpdaterPlugin.this.notifyListeners(id, res);
+                public void notifyListeners(final String id, final Map<String, Object> res) {
+                    activity.runOnUiThread(() -> {
+                        CapacitorUpdaterPlugin.this.notifyListeners(id, CapacitorUpdaterPlugin.this.mapToJSObject(res));
+                    });
                 }
             };
             final PackageInfo pInfo = this.getContext().getPackageManager().getPackageInfo(this.getContext().getPackageName(), 0);
             this.implementation.activity = this.getActivity();
             this.implementation.versionBuild = this.getConfig().getString("version", pInfo.versionName);
-            this.implementation.PLUGIN_VERSION = this.PLUGIN_VERSION;
+            this.implementation.CAP_SERVER_PATH = WebView.CAP_SERVER_PATH;
+            this.implementation.pluginVersion = this.pluginVersion;
             this.implementation.versionCode = Integer.toString(pInfo.versionCode);
-            this.implementation.client = new OkHttpClient.Builder()
-                .protocols(Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1))
-                .connectTimeout(this.implementation.timeout, TimeUnit.MILLISECONDS)
-                .readTimeout(this.implementation.timeout, TimeUnit.MILLISECONDS)
-                .writeTimeout(this.implementation.timeout, TimeUnit.MILLISECONDS)
-                .build();
-
-            this.implementation.directUpdate = this.getConfig().getBoolean("directUpdate", false);
+            // Removed unused OkHttpClient creation - using shared client in DownloadService instead
+            // Handle directUpdate configuration - support string values and backward compatibility
+            String directUpdateConfig = this.getConfig().getString("directUpdate", null);
+            if (directUpdateConfig != null) {
+                // Handle backward compatibility for boolean true
+                if (directUpdateConfig.equals("true")) {
+                    this.directUpdateMode = "always";
+                    this.implementation.directUpdate = true;
+                } else {
+                    this.directUpdateMode = directUpdateConfig;
+                    this.implementation.directUpdate =
+                        directUpdateConfig.equals("always") ||
+                        directUpdateConfig.equals("atInstall") ||
+                        directUpdateConfig.equals("onLaunch");
+                    // Validate directUpdate value
+                    if (
+                        !directUpdateConfig.equals("false") &&
+                        !directUpdateConfig.equals("always") &&
+                        !directUpdateConfig.equals("atInstall") &&
+                        !directUpdateConfig.equals("onLaunch")
+                    ) {
+                        logger.error(
+                            "Invalid directUpdate value: \"" +
+                                directUpdateConfig +
+                                "\". Supported values are: \"false\", \"true\", \"always\", \"atInstall\", \"onLaunch\". Defaulting to \"false\"."
+                        );
+                        this.directUpdateMode = "false";
+                        this.implementation.directUpdate = false;
+                    }
+                }
+            } else {
+                Boolean directUpdateBool = this.getConfig().getBoolean("directUpdate", false);
+                if (directUpdateBool) {
+                    this.directUpdateMode = "always"; // backward compatibility: true = always
+                    this.implementation.directUpdate = true;
+                } else {
+                    this.directUpdateMode = "false";
+                    this.implementation.directUpdate = false;
+                }
+            }
             this.currentVersionNative = new Version(this.getConfig().getString("version", pInfo.versionName));
+            this.currentBuildVersion = Integer.toString(pInfo.versionCode);
+            this.delayUpdateUtils = new DelayUpdateUtils(this.prefs, this.editor, this.currentVersionNative, logger);
         } catch (final PackageManager.NameNotFoundException e) {
-            Log.e(CapacitorUpdater.TAG, "Error instantiating implementation", e);
+            logger.error("Error instantiating implementation " + e.getMessage());
             return;
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Error getting current native app version", e);
+            logger.error("Error getting current native app version " + e.getMessage());
             return;
         }
+
+        boolean disableJSLogging = this.getConfig().getBoolean("disableJSLogging", false);
+        // Set the bridge in the Logger when webView is available
+        if (this.bridge != null && this.bridge.getWebView() != null && !disableJSLogging) {
+            logger.setBridge(this.bridge);
+            logger.info("WebView set successfully for logging");
+        } else {
+            logger.info("WebView not ready yet, will be set later");
+        }
+
+        // Set logger for shared classes
+        CryptoCipher.setLogger(logger);
+        DownloadService.setLogger(logger);
+        DownloadWorkerManager.setLogger(logger);
+
         final CapConfig config = CapConfig.loadDefault(this.getActivity());
         this.implementation.appId = InternalUtils.getPackageName(getContext().getPackageManager(), getContext().getPackageName());
         this.implementation.appId = config.getString("appId", this.implementation.appId);
         this.implementation.appId = this.getConfig().getString("appId", this.implementation.appId);
         if (this.implementation.appId == null || this.implementation.appId.isEmpty()) {
-            // crash the app
+            // crash the app on purpose it should not happen
             throw new RuntimeException(
                 "appId is missing in capacitor.config.json or plugin config, and cannot be retrieved from the native app, please add it globally or in the plugin config"
             );
         }
-        Log.i(CapacitorUpdater.TAG, "appId: " + implementation.appId);
+        logger.info("appId: " + implementation.appId);
+
+        this.persistCustomId = this.getConfig().getBoolean("persistCustomId", false);
+        this.persistModifyUrl = this.getConfig().getBoolean("persistModifyUrl", false);
+        this.allowSetDefaultChannel = this.getConfig().getBoolean("allowSetDefaultChannel", true);
         this.implementation.publicKey = this.getConfig().getString("publicKey", "");
         this.implementation.statsUrl = this.getConfig().getString("statsUrl", statsUrlDefault);
         this.implementation.channelUrl = this.getConfig().getString("channelUrl", channelUrlDefault);
+        if (Boolean.TRUE.equals(this.persistModifyUrl)) {
+            if (this.prefs.contains(STATS_URL_PREF_KEY)) {
+                final String storedStatsUrl = this.prefs.getString(STATS_URL_PREF_KEY, this.implementation.statsUrl);
+                if (storedStatsUrl != null) {
+                    this.implementation.statsUrl = storedStatsUrl;
+                    logger.info("Loaded persisted statsUrl");
+                }
+            }
+            if (this.prefs.contains(CHANNEL_URL_PREF_KEY)) {
+                final String storedChannelUrl = this.prefs.getString(CHANNEL_URL_PREF_KEY, this.implementation.channelUrl);
+                if (storedChannelUrl != null) {
+                    this.implementation.channelUrl = storedChannelUrl;
+                    logger.info("Loaded persisted channelUrl");
+                }
+            }
+        }
+
+        // Load defaultChannel: first try from persistent storage (set via setChannel), then fall back to config
+        if (this.prefs.contains(DEFAULT_CHANNEL_PREF_KEY)) {
+            final String storedDefaultChannel = this.prefs.getString(DEFAULT_CHANNEL_PREF_KEY, "");
+            if (storedDefaultChannel != null && !storedDefaultChannel.isEmpty()) {
+                this.implementation.defaultChannel = storedDefaultChannel;
+                logger.info("Loaded persisted defaultChannel from setChannel()");
+            } else {
+                this.implementation.defaultChannel = this.getConfig().getString("defaultChannel", "");
+            }
+        } else {
+            this.implementation.defaultChannel = this.getConfig().getString("defaultChannel", "");
+        }
+
         int userValue = this.getConfig().getInt("periodCheckDelay", 0);
-        this.implementation.defaultChannel = this.getConfig().getString("defaultChannel", "");
 
         if (userValue >= 0 && userValue <= 600) {
             this.periodCheckDelay = 600 * 1000;
@@ -177,100 +349,384 @@ public class CapacitorUpdaterPlugin extends Plugin {
         this.implementation.prefs = this.prefs;
         this.implementation.editor = this.editor;
         this.implementation.versionOs = Build.VERSION.RELEASE;
-        this.implementation.deviceID = this.prefs.getString("appUUID", UUID.randomUUID().toString()).toLowerCase();
-        this.editor.putString("appUUID", this.implementation.deviceID);
-        this.editor.commit();
-        Log.i(CapacitorUpdater.TAG, "init for device " + this.implementation.deviceID);
-        Log.i(CapacitorUpdater.TAG, "version native " + this.currentVersionNative.getOriginalString());
+        // Use DeviceIdHelper to get or create device ID that persists across reinstalls
+        this.implementation.deviceID = DeviceIdHelper.getOrCreateDeviceId(this.getContext(), this.prefs);
+
+        // Update User-Agent for shared OkHttpClient with OS version
+        DownloadService.updateUserAgent(this.implementation.appId, this.pluginVersion, this.implementation.versionOs);
+
+        if (Boolean.TRUE.equals(this.persistCustomId)) {
+            final String storedCustomId = this.prefs.getString(CUSTOM_ID_PREF_KEY, "");
+            if (storedCustomId != null && !storedCustomId.isEmpty()) {
+                this.implementation.customId = storedCustomId;
+                logger.info("Loaded persisted customId");
+            }
+        }
+        logger.info("init for device " + this.implementation.deviceID);
+        logger.info("version native " + this.currentVersionNative.getOriginalString());
         this.autoDeleteFailed = this.getConfig().getBoolean("autoDeleteFailed", true);
         this.autoDeletePrevious = this.getConfig().getBoolean("autoDeletePrevious", true);
         this.updateUrl = this.getConfig().getString("updateUrl", updateUrlDefault);
+        if (Boolean.TRUE.equals(this.persistModifyUrl)) {
+            if (this.prefs.contains(UPDATE_URL_PREF_KEY)) {
+                final String storedUpdateUrl = this.prefs.getString(UPDATE_URL_PREF_KEY, this.updateUrl);
+                if (storedUpdateUrl != null) {
+                    this.updateUrl = storedUpdateUrl;
+                    logger.info("Loaded persisted updateUrl");
+                }
+            }
+        }
         this.autoUpdate = this.getConfig().getBoolean("autoUpdate", true);
         this.appReadyTimeout = this.getConfig().getInt("appReadyTimeout", 10000);
         this.keepUrlPathAfterReload = this.getConfig().getBoolean("keepUrlPathAfterReload", false);
+        this.syncKeepUrlPathFlag(this.keepUrlPathAfterReload);
+        this.allowManualBundleError = this.getConfig().getBoolean("allowManualBundleError", false);
+        this.autoSplashscreen = this.getConfig().getBoolean("autoSplashscreen", false);
+        this.autoSplashscreenLoader = this.getConfig().getBoolean("autoSplashscreenLoader", false);
+        int splashscreenTimeoutValue = this.getConfig().getInt("autoSplashscreenTimeout", 10000);
+        this.autoSplashscreenTimeout = Math.max(0, splashscreenTimeoutValue);
         this.implementation.timeout = this.getConfig().getInt("responseTimeout", 20) * 1000;
+        this.shakeMenuEnabled = this.getConfig().getBoolean("shakeMenu", false);
         boolean resetWhenUpdate = this.getConfig().getBoolean("resetWhenUpdate", true);
 
+        // Check if app was recently installed/updated BEFORE cleanupObsoleteVersions updates LatestVersionNative
+        this.wasRecentlyInstalledOrUpdated = this.checkIfRecentlyInstalledOrUpdated();
+
         this.implementation.autoReset();
         if (resetWhenUpdate) {
             this.cleanupObsoleteVersions();
         }
+
+        // Check for 'kill' delay condition on app launch
+        // This handles cases where the app was killed by the system (onDestroy is not reliable)
+        this.delayUpdateUtils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.KILLED);
+
         this.checkForUpdateAfterDelay();
     }
 
     private void semaphoreWait(Number waitTime) {
-        Log.i(CapacitorUpdater.TAG, "semaphoreWait " + waitTime);
         try {
-            //        Log.i(CapacitorUpdater.TAG, "semaphoreReady count " + CapacitorUpdaterPlugin.this.semaphoreReady.getCount());
             semaphoreReady.awaitAdvanceInterruptibly(semaphoreReady.getPhase(), waitTime.longValue(), TimeUnit.SECONDS);
-            //        Log.i(CapacitorUpdater.TAG, "semaphoreReady await " + res);
-            Log.i(CapacitorUpdater.TAG, "semaphoreReady count " + semaphoreReady.getPhase());
+            logger.info("semaphoreReady count " + semaphoreReady.getPhase());
         } catch (InterruptedException e) {
-            Log.i(CapacitorUpdater.TAG, "semaphoreWait InterruptedException");
-            e.printStackTrace();
+            logger.info("semaphoreWait InterruptedException");
+            Thread.currentThread().interrupt(); // Restore interrupted status
         } catch (TimeoutException e) {
-            throw new RuntimeException(e);
+            logger.error("Semaphore timeout: " + e.getMessage());
+            // Don't throw runtime exception, just log and continue
         }
     }
 
     private void semaphoreUp() {
-        Log.i(CapacitorUpdater.TAG, "semaphoreUp");
+        logger.info("semaphoreUp");
         semaphoreReady.register();
     }
 
     private void semaphoreDown() {
-        Log.i(CapacitorUpdater.TAG, "semaphoreDown");
-        Log.i(CapacitorUpdater.TAG, "semaphoreDown count " + semaphoreReady.getPhase());
+        logger.info("semaphoreDown");
+        logger.info("semaphoreDown count " + semaphoreReady.getPhase());
         semaphoreReady.arriveAndDeregister();
     }
 
     private void sendReadyToJs(final BundleInfo current, final String msg) {
-        Log.i(CapacitorUpdater.TAG, "sendReadyToJs");
+        sendReadyToJs(current, msg, false);
+    }
+
+    private void sendReadyToJs(final BundleInfo current, final String msg, final boolean isDirectUpdate) {
+        logger.info("sendReadyToJs: " + msg);
         final JSObject ret = new JSObject();
-        ret.put("bundle", current.toJSON());
+        ret.put("bundle", mapToJSObject(current.toJSONMap()));
         ret.put("status", msg);
-        startNewThread(() -> {
-            Log.i(CapacitorUpdater.TAG, "semaphoreReady sendReadyToJs");
-            semaphoreWait(CapacitorUpdaterPlugin.this.appReadyTimeout);
-            Log.i(CapacitorUpdater.TAG, "semaphoreReady sendReadyToJs done");
-            CapacitorUpdaterPlugin.this.notifyListeners("appReady", ret);
-        });
+
+        // No need to wait for semaphore anymore since _reload() has already waited
+        this.notifyListeners("appReady", ret, true);
+
+        // Auto hide splashscreen if enabled
+        // We show it on background when conditions are met, so we should hide it on foreground regardless of update outcome
+        if (this.autoSplashscreen) {
+            this.hideSplashscreen();
+        }
+    }
+
+    private void hideSplashscreen() {
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            hideSplashscreenInternal();
+        } else {
+            this.mainHandler.post(this::hideSplashscreenInternal);
+        }
+    }
+
+    private void hideSplashscreenInternal() {
+        cancelSplashscreenTimeout();
+        removeSplashscreenLoader();
+
+        try {
+            if (getBridge() == null) {
+                logger.warn("Bridge not ready for hiding splashscreen with autoSplashscreen");
+                return;
+            }
+
+            // Try to call the SplashScreen plugin directly through the bridge
+            PluginHandle splashScreenPlugin = getBridge().getPlugin("SplashScreen");
+            if (splashScreenPlugin != null) {
+                try {
+                    // Create a plugin call for the hide method using reflection to access private msgHandler
+                    JSObject options = new JSObject();
+                    java.lang.reflect.Field msgHandlerField = getBridge().getClass().getDeclaredField("msgHandler");
+                    msgHandlerField.setAccessible(true);
+                    Object msgHandler = msgHandlerField.get(getBridge());
+
+                    PluginCall call = new PluginCall(
+                        (com.getcapacitor.MessageHandler) msgHandler,
+                        "SplashScreen",
+                        "FAKE_CALLBACK_ID_HIDE",
+                        "hide",
+                        options
+                    );
+
+                    // Call the hide method directly
+                    splashScreenPlugin.invoke("hide", call);
+                    logger.info("Splashscreen hidden automatically via direct plugin call");
+                } catch (Exception e) {
+                    logger.error("Failed to call SplashScreen hide method: " + e.getMessage());
+                }
+            } else {
+                logger.warn("autoSplashscreen: SplashScreen plugin not found. Install @capacitor/splash-screen plugin.");
+            }
+        } catch (Exception e) {
+            logger.error(
+                "Error hiding splashscreen with autoSplashscreen: " +
+                    e.getMessage() +
+                    ". Make sure @capacitor/splash-screen plugin is installed and configured."
+            );
+        }
+    }
+
+    private void showSplashscreen() {
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            showSplashscreenNow();
+        } else {
+            this.mainHandler.post(this::showSplashscreenNow);
+        }
+    }
+
+    private void showSplashscreenNow() {
+        cancelSplashscreenTimeout();
+        this.autoSplashscreenTimedOut = false;
+
+        try {
+            if (getBridge() == null) {
+                logger.warn("Bridge not ready for showing splashscreen with autoSplashscreen");
+            } else {
+                PluginHandle splashScreenPlugin = getBridge().getPlugin("SplashScreen");
+                if (splashScreenPlugin != null) {
+                    JSObject options = new JSObject();
+                    java.lang.reflect.Field msgHandlerField = getBridge().getClass().getDeclaredField("msgHandler");
+                    msgHandlerField.setAccessible(true);
+                    Object msgHandler = msgHandlerField.get(getBridge());
+
+                    PluginCall call = new PluginCall(
+                        (com.getcapacitor.MessageHandler) msgHandler,
+                        "SplashScreen",
+                        "FAKE_CALLBACK_ID_SHOW",
+                        "show",
+                        options
+                    );
+
+                    splashScreenPlugin.invoke("show", call);
+                    logger.info("Splashscreen shown synchronously to prevent flash");
+                } else {
+                    logger.warn("autoSplashscreen: SplashScreen plugin not found");
+                }
+            }
+        } catch (Exception e) {
+            logger.error("Failed to show splashscreen synchronously: " + e.getMessage());
+        }
+
+        addSplashscreenLoaderIfNeeded();
+        scheduleSplashscreenTimeout();
+    }
+
+    private void addSplashscreenLoaderIfNeeded() {
+        if (!Boolean.TRUE.equals(this.autoSplashscreenLoader)) {
+            return;
+        }
+
+        Runnable addLoader = () -> {
+            if (this.splashscreenLoaderOverlay != null) {
+                return;
+            }
+
+            Activity activity = getActivity();
+            if (activity == null) {
+                logger.warn("autoSplashscreen: Activity not available for loader overlay");
+                return;
+            }
+
+            ProgressBar progressBar = new ProgressBar(activity);
+            progressBar.setIndeterminate(true);
+
+            FrameLayout overlay = new FrameLayout(activity);
+            overlay.setLayoutParams(new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+            overlay.setClickable(false);
+            overlay.setFocusable(false);
+            overlay.setBackgroundColor(Color.TRANSPARENT);
+            overlay.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS);
+
+            FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            );
+            params.gravity = Gravity.CENTER;
+            overlay.addView(progressBar, params);
+
+            ViewGroup decorView = (ViewGroup) activity.getWindow().getDecorView();
+            decorView.addView(overlay);
+
+            this.splashscreenLoaderOverlay = overlay;
+        };
+
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            addLoader.run();
+        } else {
+            this.mainHandler.post(addLoader);
+        }
+    }
+
+    private void removeSplashscreenLoader() {
+        Runnable removeLoader = () -> {
+            if (this.splashscreenLoaderOverlay != null) {
+                ViewGroup parent = (ViewGroup) this.splashscreenLoaderOverlay.getParent();
+                if (parent != null) {
+                    parent.removeView(this.splashscreenLoaderOverlay);
+                }
+                this.splashscreenLoaderOverlay = null;
+            }
+        };
+
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            removeLoader.run();
+        } else {
+            this.mainHandler.post(removeLoader);
+        }
+    }
+
+    private void scheduleSplashscreenTimeout() {
+        if (this.autoSplashscreenTimeout == null || this.autoSplashscreenTimeout <= 0) {
+            return;
+        }
+
+        cancelSplashscreenTimeout();
+
+        this.splashscreenTimeoutRunnable = () -> {
+            logger.info("autoSplashscreen timeout reached, hiding splashscreen");
+            this.autoSplashscreenTimedOut = true;
+            this.implementation.directUpdate = false;
+            hideSplashscreen();
+        };
+
+        this.mainHandler.postDelayed(this.splashscreenTimeoutRunnable, this.autoSplashscreenTimeout);
+    }
+
+    private void cancelSplashscreenTimeout() {
+        if (this.splashscreenTimeoutRunnable != null) {
+            this.mainHandler.removeCallbacks(this.splashscreenTimeoutRunnable);
+            this.splashscreenTimeoutRunnable = null;
+        }
+    }
+
+    private boolean checkIfRecentlyInstalledOrUpdated() {
+        String currentVersion = this.currentBuildVersion;
+        String lastKnownVersion = this.prefs.getString("LatestNativeBuildVersion", "");
+
+        if (lastKnownVersion.isEmpty()) {
+            // First time running, consider it as recently installed
+            return true;
+        } else if (!lastKnownVersion.equals(currentVersion)) {
+            // Version changed, consider it as recently updated
+            return true;
+        }
+
+        return false;
+    }
+
+    private boolean shouldUseDirectUpdate() {
+        if (Boolean.TRUE.equals(this.autoSplashscreenTimedOut)) {
+            return false;
+        }
+        switch (this.directUpdateMode) {
+            case "false":
+                return false;
+            case "always":
+                return true;
+            case "atInstall":
+                if (this.wasRecentlyInstalledOrUpdated) {
+                    // Reset the flag after first use to prevent subsequent foreground events from using direct update
+                    this.wasRecentlyInstalledOrUpdated = false;
+                    return true;
+                }
+                return false;
+            case "onLaunch":
+                if (!this.onLaunchDirectUpdateUsed) {
+                    return true;
+                }
+                return false;
+            default:
+                logger.error(
+                    "Invalid directUpdateMode: \"" +
+                        this.directUpdateMode +
+                        "\". Supported values are: \"false\", \"always\", \"atInstall\", \"onLaunch\". Defaulting to \"false\" behavior."
+                );
+                return false;
+        }
+    }
+
+    private boolean isDirectUpdateCurrentlyAllowed(final boolean plannedDirectUpdate) {
+        return plannedDirectUpdate && !Boolean.TRUE.equals(this.autoSplashscreenTimedOut);
     }
 
     private void directUpdateFinish(final BundleInfo latest) {
+        if ("onLaunch".equals(this.directUpdateMode)) {
+            this.onLaunchDirectUpdateUsed = true;
+            this.implementation.directUpdate = false;
+        }
         CapacitorUpdaterPlugin.this.implementation.set(latest);
         CapacitorUpdaterPlugin.this._reload();
-        sendReadyToJs(latest, "update installed");
+        sendReadyToJs(latest, "update installed", true);
     }
 
     private void cleanupObsoleteVersions() {
-        try {
-            final Version previous = new Version(this.prefs.getString("LatestVersionNative", ""));
+        startNewThread(() -> {
             try {
-                if (
-                    !"".equals(previous.getOriginalString()) &&
-                    !Objects.equals(this.currentVersionNative.getOriginalString(), previous.getOriginalString())
-                ) {
-                    Log.i(CapacitorUpdater.TAG, "New native version detected: " + this.currentVersionNative);
+                final String previous = this.prefs.getString("LatestNativeBuildVersion", "");
+                if (!"".equals(previous) && !Objects.equals(this.currentBuildVersion, previous)) {
+                    logger.info("New native build version detected: " + this.currentBuildVersion);
                     this.implementation.reset(true);
                     final List<BundleInfo> installed = this.implementation.list(false);
                     for (final BundleInfo bundle : installed) {
                         try {
-                            Log.i(CapacitorUpdater.TAG, "Deleting obsolete bundle: " + bundle.getId());
+                            logger.info("Deleting obsolete bundle: " + bundle.getId());
                             this.implementation.delete(bundle.getId());
                         } catch (final Exception e) {
-                            Log.e(CapacitorUpdater.TAG, "Failed to delete: " + bundle.getId(), e);
+                            logger.error("Failed to delete: " + bundle.getId() + " " + e.getMessage());
                         }
                     }
+                    final List<BundleInfo> storedBundles = this.implementation.list(true);
+                    final Set<String> allowedIds = new HashSet<>();
+                    for (final BundleInfo info : storedBundles) {
+                        if (info != null && info.getId() != null && !info.getId().isEmpty()) {
+                            allowedIds.add(info.getId());
+                        }
+                    }
+                    this.implementation.cleanupDownloadDirectories(allowedIds);
+                    this.implementation.cleanupDeltaCache();
                 }
-            } catch (final Exception e) {
-                Log.e(CapacitorUpdater.TAG, "Could not determine the current version", e);
+                this.editor.putString("LatestNativeBuildVersion", this.currentBuildVersion);
+                this.editor.apply();
+            } catch (Exception e) {
+                logger.error("Error during cleanupObsoleteVersions: " + e.getMessage());
             }
-        } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Error calculating previous native version", e);
-        }
-        this.editor.putString("LatestVersionNative", this.currentVersionNative.toString());
-        this.editor.commit();
+        });
     }
 
     public void notifyDownload(final String id, final int percent) {
@@ -278,7 +734,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
             final JSObject ret = new JSObject();
             ret.put("percent", percent);
             final BundleInfo bundleInfo = this.implementation.getBundleInfo(id);
-            ret.put("bundle", bundleInfo.toJSON());
+            ret.put("bundle", mapToJSObject(bundleInfo.toJSONMap()));
             this.notifyListeners("download", ret);
 
             if (percent == 100) {
@@ -294,58 +750,70 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 }
             }
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not notify listeners", e);
+            logger.error("Could not notify listeners " + e.getMessage());
         }
     }
 
     @PluginMethod
     public void setUpdateUrl(final PluginCall call) {
         if (!this.getConfig().getBoolean("allowModifyUrl", false)) {
-            Log.e(CapacitorUpdater.TAG, "setUpdateUrl not allowed set allowModifyUrl in your config to true to allow it");
+            logger.error("setUpdateUrl not allowed set allowModifyUrl in your config to true to allow it");
             call.reject("setUpdateUrl not allowed");
             return;
         }
         final String url = call.getString("url");
         if (url == null) {
-            Log.e(CapacitorUpdater.TAG, "setUpdateUrl called without url");
+            logger.error("setUpdateUrl called without url");
             call.reject("setUpdateUrl called without url");
             return;
         }
         this.updateUrl = url;
+        if (Boolean.TRUE.equals(this.persistModifyUrl)) {
+            this.editor.putString(UPDATE_URL_PREF_KEY, url);
+            this.editor.apply();
+        }
         call.resolve();
     }
 
     @PluginMethod
     public void setStatsUrl(final PluginCall call) {
         if (!this.getConfig().getBoolean("allowModifyUrl", false)) {
-            Log.e(CapacitorUpdater.TAG, "setStatsUrl not allowed set allowModifyUrl in your config to true to allow it");
+            logger.error("setStatsUrl not allowed set allowModifyUrl in your config to true to allow it");
             call.reject("setStatsUrl not allowed");
             return;
         }
         final String url = call.getString("url");
         if (url == null) {
-            Log.e(CapacitorUpdater.TAG, "setStatsUrl called without url");
+            logger.error("setStatsUrl called without url");
             call.reject("setStatsUrl called without url");
             return;
         }
         this.implementation.statsUrl = url;
+        if (Boolean.TRUE.equals(this.persistModifyUrl)) {
+            this.editor.putString(STATS_URL_PREF_KEY, url);
+            this.editor.apply();
+        }
         call.resolve();
     }
 
     @PluginMethod
     public void setChannelUrl(final PluginCall call) {
         if (!this.getConfig().getBoolean("allowModifyUrl", false)) {
-            Log.e(CapacitorUpdater.TAG, "setChannelUrl not allowed set allowModifyUrl in your config to true to allow it");
+            logger.error("setChannelUrl not allowed set allowModifyUrl in your config to true to allow it");
             call.reject("setChannelUrl not allowed");
             return;
         }
         final String url = call.getString("url");
         if (url == null) {
-            Log.e(CapacitorUpdater.TAG, "setChannelUrl called without url");
+            logger.error("setChannelUrl called without url");
             call.reject("setChannelUrl called without url");
             return;
         }
         this.implementation.channelUrl = url;
+        if (Boolean.TRUE.equals(this.persistModifyUrl)) {
+            this.editor.putString(CHANNEL_URL_PREF_KEY, url);
+            this.editor.apply();
+        }
         call.resolve();
     }
 
@@ -356,7 +824,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
             ret.put("version", this.implementation.versionBuild);
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not get version", e);
+            logger.error("Could not get version " + e.getMessage());
             call.reject("Could not get version", e);
         }
     }
@@ -368,7 +836,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
             ret.put("deviceId", this.implementation.deviceID);
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not get device id", e);
+            logger.error("Could not get device id " + e.getMessage());
             call.reject("Could not get device id", e);
         }
     }
@@ -377,21 +845,30 @@ public class CapacitorUpdaterPlugin extends Plugin {
     public void setCustomId(final PluginCall call) {
         final String customId = call.getString("customId");
         if (customId == null) {
-            Log.e(CapacitorUpdater.TAG, "setCustomId called without customId");
+            logger.error("setCustomId called without customId");
             call.reject("setCustomId called without customId");
             return;
         }
         this.implementation.customId = customId;
+        if (Boolean.TRUE.equals(this.persistCustomId)) {
+            if (customId.isEmpty()) {
+                this.editor.remove(CUSTOM_ID_PREF_KEY);
+            } else {
+                this.editor.putString(CUSTOM_ID_PREF_KEY, customId);
+            }
+            this.editor.apply();
+        }
+        call.resolve();
     }
 
     @PluginMethod
     public void getPluginVersion(final PluginCall call) {
         try {
             final JSObject ret = new JSObject();
-            ret.put("version", this.PLUGIN_VERSION);
+            ret.put("version", this.pluginVersion);
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not get plugin version", e);
+            logger.error("Could not get plugin version " + e.getMessage());
             call.reject("Could not get plugin version", e);
         }
     }
@@ -401,22 +878,36 @@ public class CapacitorUpdaterPlugin extends Plugin {
         final Boolean triggerAutoUpdate = call.getBoolean("triggerAutoUpdate", false);
 
         try {
-            Log.i(CapacitorUpdater.TAG, "unsetChannel triggerAutoUpdate: " + triggerAutoUpdate);
-            startNewThread(() ->
-                CapacitorUpdaterPlugin.this.implementation.unsetChannel(res -> {
-                        if (res.has("error")) {
-                            call.reject(res.getString("error"));
+            logger.info("unsetChannel triggerAutoUpdate: " + triggerAutoUpdate);
+            startNewThread(() -> {
+                String configDefaultChannel = CapacitorUpdaterPlugin.this.getConfig().getString("defaultChannel", "");
+                CapacitorUpdaterPlugin.this.implementation.unsetChannel(
+                    CapacitorUpdaterPlugin.this.editor,
+                    DEFAULT_CHANNEL_PREF_KEY,
+                    configDefaultChannel,
+                    (res) -> {
+                        JSObject jsRes = mapToJSObject(res);
+                        if (jsRes.has("error")) {
+                            String errorMessage = jsRes.has("message") ? jsRes.getString("message") : jsRes.getString("error");
+                            String errorCode = jsRes.getString("error");
+
+                            JSObject errorObj = new JSObject();
+                            errorObj.put("message", errorMessage);
+                            errorObj.put("error", errorCode);
+
+                            call.reject(errorMessage, "UNSETCHANNEL_FAILED", null, errorObj);
                         } else {
                             if (CapacitorUpdaterPlugin.this._isAutoUpdateEnabled() && Boolean.TRUE.equals(triggerAutoUpdate)) {
-                                Log.i(CapacitorUpdater.TAG, "Calling autoupdater after channel change!");
+                                logger.info("Calling autoupdater after channel change!");
                                 backgroundDownload();
                             }
-                            call.resolve(res);
+                            call.resolve(jsRes);
                         }
-                    })
-            );
+                    }
+                );
+            });
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to unsetChannel: ", e);
+            logger.error("Failed to unsetChannel: " + e.getMessage());
             call.reject("Failed to unsetChannel: ", e);
         }
     }
@@ -427,27 +918,55 @@ public class CapacitorUpdaterPlugin extends Plugin {
         final Boolean triggerAutoUpdate = call.getBoolean("triggerAutoUpdate", false);
 
         if (channel == null) {
-            Log.e(CapacitorUpdater.TAG, "setChannel called without channel");
-            call.reject("setChannel called without channel");
+            logger.error("setChannel called without channel");
+            JSObject errorObj = new JSObject();
+            errorObj.put("message", "setChannel called without channel");
+            errorObj.put("error", "missing_parameter");
+            call.reject("setChannel called without channel", "SETCHANNEL_INVALID_PARAMS", null, errorObj);
             return;
         }
         try {
-            Log.i(CapacitorUpdater.TAG, "setChannel " + channel + " triggerAutoUpdate: " + triggerAutoUpdate);
+            logger.info("setChannel " + channel + " triggerAutoUpdate: " + triggerAutoUpdate);
             startNewThread(() ->
-                CapacitorUpdaterPlugin.this.implementation.setChannel(channel, res -> {
-                        if (res.has("error")) {
-                            call.reject(res.getString("error"));
+                CapacitorUpdaterPlugin.this.implementation.setChannel(
+                    channel,
+                    CapacitorUpdaterPlugin.this.editor,
+                    DEFAULT_CHANNEL_PREF_KEY,
+                    CapacitorUpdaterPlugin.this.allowSetDefaultChannel,
+                    (res) -> {
+                        JSObject jsRes = mapToJSObject(res);
+                        if (jsRes.has("error")) {
+                            String errorMessage = jsRes.has("message") ? jsRes.getString("message") : jsRes.getString("error");
+                            String errorCode = jsRes.getString("error");
+
+                            // Fire channelPrivate event if channel doesn't allow self-assignment
+                            if (
+                                errorCode.contains("cannot_update_via_private_channel") ||
+                                errorCode.contains("channel_self_set_not_allowed")
+                            ) {
+                                JSObject eventData = new JSObject();
+                                eventData.put("channel", channel);
+                                eventData.put("message", errorMessage);
+                                notifyListeners("channelPrivate", eventData);
+                            }
+
+                            JSObject errorObj = new JSObject();
+                            errorObj.put("message", errorMessage);
+                            errorObj.put("error", errorCode);
+
+                            call.reject(errorMessage, "SETCHANNEL_FAILED", null, errorObj);
                         } else {
                             if (CapacitorUpdaterPlugin.this._isAutoUpdateEnabled() && Boolean.TRUE.equals(triggerAutoUpdate)) {
-                                Log.i(CapacitorUpdater.TAG, "Calling autoupdater after channel change!");
+                                logger.info("Calling autoupdater after channel change!");
                                 backgroundDownload();
                             }
-                            call.resolve(res);
+                            call.resolve(jsRes);
                         }
-                    })
+                    }
+                )
             );
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to setChannel: " + channel, e);
+            logger.error("Failed to setChannel: " + channel + " " + e.getMessage());
             call.reject("Failed to setChannel: " + channel, e);
         }
     }
@@ -455,50 +974,98 @@ public class CapacitorUpdaterPlugin extends Plugin {
     @PluginMethod
     public void getChannel(final PluginCall call) {
         try {
-            Log.i(CapacitorUpdater.TAG, "getChannel");
+            logger.info("getChannel");
             startNewThread(() ->
-                CapacitorUpdaterPlugin.this.implementation.getChannel(res -> {
-                        if (res.has("error")) {
-                            call.reject(res.getString("error"));
-                        } else {
-                            call.resolve(res);
-                        }
-                    })
+                CapacitorUpdaterPlugin.this.implementation.getChannel((res) -> {
+                    JSObject jsRes = mapToJSObject(res);
+                    if (jsRes.has("error")) {
+                        String errorMessage = jsRes.has("message") ? jsRes.getString("message") : jsRes.getString("error");
+                        String errorCode = jsRes.getString("error");
+
+                        JSObject errorObj = new JSObject();
+                        errorObj.put("message", errorMessage);
+                        errorObj.put("error", errorCode);
+
+                        call.reject(errorMessage, "GETCHANNEL_FAILED", null, errorObj);
+                    } else {
+                        call.resolve(jsRes);
+                    }
+                })
             );
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to getChannel", e);
+            logger.error("Failed to getChannel " + e.getMessage());
             call.reject("Failed to getChannel", e);
         }
     }
 
+    @PluginMethod
+    public void listChannels(final PluginCall call) {
+        try {
+            logger.info("listChannels");
+            startNewThread(() ->
+                CapacitorUpdaterPlugin.this.implementation.listChannels((res) -> {
+                    JSObject jsRes = mapToJSObject(res);
+                    if (jsRes.has("error")) {
+                        String errorMessage = jsRes.has("message") ? jsRes.getString("message") : jsRes.getString("error");
+                        String errorCode = jsRes.getString("error");
+
+                        JSObject errorObj = new JSObject();
+                        errorObj.put("message", errorMessage);
+                        errorObj.put("error", errorCode);
+
+                        call.reject(errorMessage, "LISTCHANNELS_FAILED", null, errorObj);
+                    } else {
+                        call.resolve(jsRes);
+                    }
+                })
+            );
+        } catch (final Exception e) {
+            logger.error("Failed to listChannels: " + e.getMessage());
+            call.reject("Failed to listChannels", e);
+        }
+    }
+
     @PluginMethod
     public void download(final PluginCall call) {
         final String url = call.getString("url");
         final String version = call.getString("version");
         final String sessionKey = call.getString("sessionKey", "");
         final String checksum = call.getString("checksum", "");
+        final JSONArray manifest = call.getData().optJSONArray("manifest");
         if (url == null) {
-            Log.e(CapacitorUpdater.TAG, "Download called without url");
+            logger.error("Download called without url");
             call.reject("Download called without url");
             return;
         }
         if (version == null) {
-            Log.e(CapacitorUpdater.TAG, "Download called without version");
+            logger.error("Download called without version");
             call.reject("Download called without version");
             return;
         }
         try {
-            Log.i(CapacitorUpdater.TAG, "Downloading " + url);
+            logger.info("Downloading " + url);
             startNewThread(() -> {
                 try {
-                    final BundleInfo downloaded = CapacitorUpdaterPlugin.this.implementation.download(url, version, sessionKey, checksum);
+                    final BundleInfo downloaded;
+                    if (manifest != null) {
+                        // For manifest downloads, we need to handle this asynchronously
+                        // since there's no synchronous downloadManifest method in Java
+                        CapacitorUpdaterPlugin.this.implementation.downloadBackground(url, version, sessionKey, checksum, manifest);
+                        // Return immediately with a pending status - the actual result will come via listeners
+                        final String id = CapacitorUpdaterPlugin.this.implementation.randomString();
+                        downloaded = new BundleInfo(id, version, BundleStatus.DOWNLOADING, new Date(System.currentTimeMillis()), "");
+                        call.resolve(mapToJSObject(downloaded.toJSONMap()));
+                        return;
+                    } else {
+                        downloaded = CapacitorUpdaterPlugin.this.implementation.download(url, version, sessionKey, checksum);
+                    }
                     if (downloaded.isErrorStatus()) {
                         throw new RuntimeException("Download failed: " + downloaded.getStatus());
                     } else {
-                        call.resolve(downloaded.toJSON());
+                        call.resolve(mapToJSObject(downloaded.toJSONMap()));
                     }
                 } catch (final Exception e) {
-                    Log.e(CapacitorUpdater.TAG, "Failed to download from: " + url, e);
+                    logger.error("Failed to download from: " + url + " " + e.getMessage());
                     call.reject("Failed to download from: " + url, e);
                     final JSObject ret = new JSObject();
                     ret.put("version", version);
@@ -508,7 +1075,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 }
             });
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to download from: " + url, e);
+            logger.error("Failed to download from: " + url + " " + e.getMessage());
             call.reject("Failed to download from: " + url, e);
             final JSObject ret = new JSObject();
             ret.put("version", version);
@@ -518,10 +1085,27 @@ public class CapacitorUpdaterPlugin extends Plugin {
         }
     }
 
+    private void syncKeepUrlPathFlag(final boolean enabled) {
+        if (this.bridge == null || this.bridge.getWebView() == null) {
+            return;
+        }
+        final String script = enabled
+            ? "(function(){try{localStorage.setItem('" +
+              KEEP_URL_FLAG_KEY +
+              "','1');}catch(e){}window.__capgoKeepUrlPathAfterReload=true;var evt;try{evt=new CustomEvent('CapacitorUpdaterKeepUrlPathAfterReload',{detail:{enabled:true}});}catch(err){evt=document.createEvent('CustomEvent');evt.initCustomEvent('CapacitorUpdaterKeepUrlPathAfterReload',false,false,{enabled:true});}window.dispatchEvent(evt);})();"
+            : "(function(){try{localStorage.removeItem('" +
+              KEEP_URL_FLAG_KEY +
+              "');}catch(e){}delete window.__capgoKeepUrlPathAfterReload;var evt;try{evt=new CustomEvent('CapacitorUpdaterKeepUrlPathAfterReload',{detail:{enabled:false}});}catch(err){evt=document.createEvent('CustomEvent');evt.initCustomEvent('CapacitorUpdaterKeepUrlPathAfterReload',false,false,{enabled:false});}window.dispatchEvent(evt);})();";
+        this.bridge.getWebView().post(() -> this.bridge.getWebView().evaluateJavascript(script, null));
+    }
+
     protected boolean _reload() {
         final String path = this.implementation.getCurrentBundlePath();
+        if (this.keepUrlPathAfterReload) {
+            this.syncKeepUrlPathFlag(true);
+        }
         this.semaphoreUp();
-        Log.i(CapacitorUpdater.TAG, "Reloading: " + path);
+        logger.info("Reloading: " + path);
 
         AtomicReference<URL> url = new AtomicReference<>();
         if (this.keepUrlPathAfterReload) {
@@ -529,23 +1113,38 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 if (Looper.myLooper() != Looper.getMainLooper()) {
                     Semaphore mainThreadSemaphore = new Semaphore(0);
                     this.bridge.executeOnMainThread(() -> {
-                            try {
-                                url.set(new URL(this.bridge.getWebView().getUrl()));
-                            } catch (Exception e) {
-                                Log.e(CapacitorUpdater.TAG, "Error executing on main thread", e);
+                        try {
+                            if (this.bridge != null && this.bridge.getWebView() != null) {
+                                String currentUrl = this.bridge.getWebView().getUrl();
+                                if (currentUrl != null) {
+                                    url.set(new URL(currentUrl));
+                                }
                             }
-                            mainThreadSemaphore.release();
-                        });
-                    mainThreadSemaphore.acquire();
+                        } catch (Exception e) {
+                            logger.error("Error executing on main thread " + e.getMessage());
+                        }
+                        mainThreadSemaphore.release();
+                    });
+
+                    // Add timeout to prevent indefinite blocking
+                    if (!mainThreadSemaphore.tryAcquire(10, TimeUnit.SECONDS)) {
+                        logger.error("Timeout waiting for main thread operation");
+                    }
                 } else {
                     try {
-                        url.set(new URL(this.bridge.getWebView().getUrl()));
+                        if (this.bridge != null && this.bridge.getWebView() != null) {
+                            String currentUrl = this.bridge.getWebView().getUrl();
+                            if (currentUrl != null) {
+                                url.set(new URL(currentUrl));
+                            }
+                        }
                     } catch (Exception e) {
-                        Log.e(CapacitorUpdater.TAG, "Error executing on main thread", e);
+                        logger.error("Error executing on main thread " + e.getMessage());
                     }
                 }
             } catch (InterruptedException e) {
-                Log.e(CapacitorUpdater.TAG, "Error waiting for main thread or getting the current URL from webview", e);
+                logger.error("Error waiting for main thread or getting the current URL from webview " + e.getMessage());
+                Thread.currentThread().interrupt(); // Restore interrupted status
             }
         }
 
@@ -561,13 +1160,14 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 finalUrl = new URL(this.bridge.getAppUrl());
                 finalUrl = new URL(finalUrl.getProtocol(), finalUrl.getHost(), finalUrl.getPort(), url.get().getPath());
                 URL finalUrl1 = finalUrl;
-                this.bridge.getWebView()
-                    .post(() -> {
-                        this.bridge.getWebView().loadUrl(finalUrl1.toString());
+                this.bridge.getWebView().post(() -> {
+                    this.bridge.getWebView().loadUrl(finalUrl1.toString());
+                    if (!this.keepUrlPathAfterReload) {
                         this.bridge.getWebView().clearHistory();
-                    });
+                    }
+                });
             } catch (MalformedURLException e) {
-                Log.e(CapacitorUpdater.TAG, "Cannot get finalUrl from capacitor bridge", e);
+                logger.error("Cannot get finalUrl from capacitor bridge " + e.getMessage());
 
                 if (this.implementation.isUsingBuiltin()) {
                     this.bridge.setServerAssetPath(path);
@@ -581,10 +1181,29 @@ public class CapacitorUpdaterPlugin extends Plugin {
             } else {
                 this.bridge.setServerBasePath(path);
             }
+            if (this.bridge != null && this.bridge.getWebView() != null) {
+                this.bridge.getWebView().post(() -> {
+                    if (this.bridge.getWebView() != null) {
+                        this.bridge.getWebView().loadUrl(this.bridge.getAppUrl());
+                        if (!this.keepUrlPathAfterReload) {
+                            this.bridge.getWebView().clearHistory();
+                        }
+                    }
+                });
+            }
         }
 
         this.checkAppReady();
         this.notifyListeners("appReloaded", new JSObject());
+
+        // Wait for the reload to complete (until notifyAppReady is called)
+        try {
+            this.semaphoreWait(this.appReadyTimeout);
+        } catch (Exception e) {
+            logger.error("Error waiting for app ready: " + e.getMessage());
+            return false;
+        }
+
         return true;
     }
 
@@ -594,11 +1213,11 @@ public class CapacitorUpdaterPlugin extends Plugin {
             if (this._reload()) {
                 call.resolve();
             } else {
-                Log.e(CapacitorUpdater.TAG, "Reload failed");
+                logger.error("Reload failed");
                 call.reject("Reload failed");
             }
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not reload", e);
+            logger.error("Could not reload " + e.getMessage());
             call.reject("Could not reload", e);
         }
     }
@@ -607,20 +1226,20 @@ public class CapacitorUpdaterPlugin extends Plugin {
     public void next(final PluginCall call) {
         final String id = call.getString("id");
         if (id == null) {
-            Log.e(CapacitorUpdater.TAG, "Next called without id");
+            logger.error("Next called without id");
             call.reject("Next called without id");
             return;
         }
         try {
-            Log.i(CapacitorUpdater.TAG, "Setting next active id " + id);
+            logger.info("Setting next active id " + id);
             if (!this.implementation.setNextBundle(id)) {
-                Log.e(CapacitorUpdater.TAG, "Set next id failed. Bundle " + id + " does not exist.");
+                logger.error("Set next id failed. Bundle " + id + " does not exist.");
                 call.reject("Set next id failed. Bundle " + id + " does not exist.");
             } else {
-                call.resolve(this.implementation.getBundleInfo(id).toJSON());
+                call.resolve(mapToJSObject(this.implementation.getBundleInfo(id).toJSONMap()));
             }
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not set next id " + id, e);
+            logger.error("Could not set next id " + id + " " + e.getMessage());
             call.reject("Could not set next id: " + id, e);
         }
     }
@@ -629,21 +1248,21 @@ public class CapacitorUpdaterPlugin extends Plugin {
     public void set(final PluginCall call) {
         final String id = call.getString("id");
         if (id == null) {
-            Log.e(CapacitorUpdater.TAG, "Set called without id");
+            logger.error("Set called without id");
             call.reject("Set called without id");
             return;
         }
         try {
-            Log.i(CapacitorUpdater.TAG, "Setting active bundle " + id);
+            logger.info("Setting active bundle " + id);
             if (!this.implementation.set(id)) {
-                Log.i(CapacitorUpdater.TAG, "No such bundle " + id);
+                logger.info("No such bundle " + id);
                 call.reject("Update failed, id " + id + " does not exist.");
             } else {
-                Log.i(CapacitorUpdater.TAG, "Bundle successfully set to " + id);
+                logger.info("Bundle successfully set to " + id);
                 this.reload(call);
             }
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not set id " + id, e);
+            logger.error("Could not set id " + id + " " + e.getMessage());
             call.reject("Could not set id " + id, e);
         }
     }
@@ -652,25 +1271,63 @@ public class CapacitorUpdaterPlugin extends Plugin {
     public void delete(final PluginCall call) {
         final String id = call.getString("id");
         if (id == null) {
-            Log.e(CapacitorUpdater.TAG, "missing id");
+            logger.error("missing id");
             call.reject("missing id");
             return;
         }
-        Log.i(CapacitorUpdater.TAG, "Deleting id " + id);
+        logger.info("Deleting id " + id);
         try {
             final Boolean res = this.implementation.delete(id);
             if (res) {
                 call.resolve();
             } else {
-                Log.e(CapacitorUpdater.TAG, "Delete failed, id " + id + " does not exist");
+                logger.error("Delete failed, id " + id + " does not exist");
                 call.reject("Delete failed, id " + id + " does not exist or it cannot be deleted (perhaps it is the 'next' bundle)");
             }
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not delete id " + id, e);
+            logger.error("Could not delete id " + id + " " + e.getMessage());
             call.reject("Could not delete id " + id, e);
         }
     }
 
+    @PluginMethod
+    public void setBundleError(final PluginCall call) {
+        if (!Boolean.TRUE.equals(this.allowManualBundleError)) {
+            logger.error("setBundleError called without allowManualBundleError");
+            call.reject("setBundleError not allowed. Set allowManualBundleError to true in your config to enable it.");
+            return;
+        }
+        final String id = call.getString("id");
+        if (id == null) {
+            logger.error("setBundleError called without id");
+            call.reject("setBundleError called without id");
+            return;
+        }
+        try {
+            final BundleInfo bundle = this.implementation.getBundleInfo(id);
+            if (bundle == null || bundle.isUnknown()) {
+                logger.error("setBundleError called with unknown bundle " + id);
+                call.reject("Bundle " + id + " does not exist");
+                return;
+            }
+            if (bundle.isBuiltin()) {
+                logger.error("setBundleError called on builtin bundle");
+                call.reject("Cannot set builtin bundle to error state");
+                return;
+            }
+            if (Boolean.TRUE.equals(this.autoUpdate)) {
+                logger.warn("setBundleError used while autoUpdate is enabled; this method is intended for manual mode");
+            }
+            this.implementation.setError(bundle);
+            final JSObject ret = new JSObject();
+            ret.put("bundle", mapToJSObject(this.implementation.getBundleInfo(id).toJSONMap()));
+            call.resolve(ret);
+        } catch (final Exception e) {
+            logger.error("Could not set bundle error for id " + id + " " + e.getMessage());
+            call.reject("Could not set bundle error for id " + id, e);
+        }
+    }
+
     @PluginMethod
     public void list(final PluginCall call) {
         try {
@@ -678,12 +1335,12 @@ public class CapacitorUpdaterPlugin extends Plugin {
             final JSObject ret = new JSObject();
             final JSArray values = new JSArray();
             for (final BundleInfo bundle : res) {
-                values.put(bundle.toJSON());
+                values.put(mapToJSObject(bundle.toJSONMap()));
             }
             ret.put("bundles", values);
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not list bundles", e);
+            logger.error("Could not list bundles " + e.getMessage());
             call.reject("Could not list bundles", e);
         }
     }
@@ -692,30 +1349,21 @@ public class CapacitorUpdaterPlugin extends Plugin {
     public void getLatest(final PluginCall call) {
         final String channel = call.getString("channel");
         startNewThread(() ->
-            CapacitorUpdaterPlugin.this.implementation.getLatest(CapacitorUpdaterPlugin.this.updateUrl, channel, res -> {
-                    if (res.has("error")) {
-                        call.reject(res.getString("error"));
-                        return;
-                    } else if (res.has("message")) {
-                        call.reject(res.getString("message"));
-                        return;
-                    } else {
-                        call.resolve(res);
-                    }
-                    final JSObject ret = new JSObject();
-                    Iterator<String> keys = res.keys();
-                    while (keys.hasNext()) {
-                        String key = keys.next();
-                        if (res.has(key)) {
-                            try {
-                                ret.put(key, res.get(key));
-                            } catch (JSONException e) {
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                    call.resolve(ret);
-                })
+            CapacitorUpdaterPlugin.this.implementation.getLatest(CapacitorUpdaterPlugin.this.updateUrl, channel, (res) -> {
+                JSObject jsRes = mapToJSObject(res);
+                if (jsRes.has("error")) {
+                    String error = jsRes.getString("error");
+                    String errorMessage = jsRes.has("message") ? jsRes.getString("message") : "server did not provide a message";
+                    logger.error("getLatest failed with error: " + error + ", message: " + errorMessage);
+                    call.reject(jsRes.getString("error"));
+                    return;
+                } else if (jsRes.has("message")) {
+                    call.reject(jsRes.getString("message"));
+                    return;
+                } else {
+                    call.resolve(jsRes);
+                }
+            })
         );
     }
 
@@ -724,11 +1372,11 @@ public class CapacitorUpdaterPlugin extends Plugin {
         this.implementation.reset();
 
         if (toLastSuccessful && !fallback.isBuiltin()) {
-            Log.i(CapacitorUpdater.TAG, "Resetting to: " + fallback);
+            logger.info("Resetting to: " + fallback);
             return this.implementation.set(fallback) && this._reload();
         }
 
-        Log.i(CapacitorUpdater.TAG, "Resetting to native.");
+        logger.info("Resetting to native.");
         return this._reload();
     }
 
@@ -740,24 +1388,25 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 call.resolve();
                 return;
             }
-            Log.e(CapacitorUpdater.TAG, "Reset failed");
+            logger.error("Reset failed");
             call.reject("Reset failed");
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Reset failed", e);
+            logger.error("Reset failed " + e.getMessage());
             call.reject("Reset failed", e);
         }
     }
 
     @PluginMethod
     public void current(final PluginCall call) {
+        ensureBridgeSet();
         try {
             final JSObject ret = new JSObject();
             final BundleInfo bundle = this.implementation.getCurrentBundle();
-            ret.put("bundle", bundle.toJSON());
+            ret.put("bundle", mapToJSObject(bundle.toJSONMap()));
             ret.put("native", this.currentVersionNative);
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not get current bundle", e);
+            logger.error("Could not get current bundle " + e.getMessage());
             call.reject("Could not get current bundle", e);
         }
     }
@@ -771,13 +1420,33 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 return;
             }
 
-            call.resolve(bundle.toJSON());
+            call.resolve(mapToJSObject(bundle.toJSONMap()));
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not get next bundle", e);
+            logger.error("Could not get next bundle " + e.getMessage());
             call.reject("Could not get next bundle", e);
         }
     }
 
+    @PluginMethod
+    public void getFailedUpdate(final PluginCall call) {
+        try {
+            final BundleInfo bundle = this.readLastFailedBundle();
+            if (bundle == null || bundle.isUnknown()) {
+                call.resolve(null);
+                return;
+            }
+
+            this.persistLastFailedBundle(null);
+
+            final JSObject ret = new JSObject();
+            ret.put("bundle", mapToJSObject(bundle.toJSONMap()));
+            call.resolve(ret);
+        } catch (final Exception e) {
+            logger.error("Could not get failed update " + e.getMessage());
+            call.reject("Could not get failed update", e);
+        }
+    }
+
     public void checkForUpdateAfterDelay() {
         if (this.periodCheckDelay == 0 || !this._isAutoUpdateEnabled()) {
             return;
@@ -788,20 +1457,25 @@ public class CapacitorUpdaterPlugin extends Plugin {
                 @Override
                 public void run() {
                     try {
-                        CapacitorUpdaterPlugin.this.implementation.getLatest(CapacitorUpdaterPlugin.this.updateUrl, null, res -> {
-                                if (res.has("error")) {
-                                    Log.e(CapacitorUpdater.TAG, Objects.requireNonNull(res.getString("error")));
-                                } else if (res.has("version")) {
-                                    String newVersion = res.getString("version");
-                                    String currentVersion = String.valueOf(CapacitorUpdaterPlugin.this.implementation.getCurrentBundle());
-                                    if (!Objects.equals(newVersion, currentVersion)) {
-                                        Log.i(CapacitorUpdater.TAG, "New version found: " + newVersion);
-                                        CapacitorUpdaterPlugin.this.backgroundDownload();
-                                    }
+                        CapacitorUpdaterPlugin.this.implementation.getLatest(CapacitorUpdaterPlugin.this.updateUrl, null, (res) -> {
+                            JSObject jsRes = mapToJSObject(res);
+                            if (jsRes.has("error")) {
+                                String error = jsRes.getString("error");
+                                String errorMessage = jsRes.has("message")
+                                    ? jsRes.getString("message")
+                                    : "server did not provide a message";
+                                logger.error("getLatest failed with error: " + error + ", message: " + errorMessage);
+                            } else if (jsRes.has("version")) {
+                                String newVersion = jsRes.getString("version");
+                                String currentVersion = String.valueOf(CapacitorUpdaterPlugin.this.implementation.getCurrentBundle());
+                                if (!Objects.equals(newVersion, currentVersion)) {
+                                    logger.info("New version found: " + newVersion);
+                                    CapacitorUpdaterPlugin.this.backgroundDownload();
                                 }
-                            });
+                            }
+                        });
                     } catch (final Exception e) {
-                        Log.e(CapacitorUpdater.TAG, "Failed to check for update", e);
+                        logger.error("Failed to check for update " + e.getMessage());
                     }
                 }
             },
@@ -812,18 +1486,19 @@ public class CapacitorUpdaterPlugin extends Plugin {
 
     @PluginMethod
     public void notifyAppReady(final PluginCall call) {
+        ensureBridgeSet();
         try {
             final BundleInfo bundle = this.implementation.getCurrentBundle();
             this.implementation.setSuccess(bundle, this.autoDeletePrevious);
-            Log.i(CapacitorUpdater.TAG, "Current bundle loaded successfully. ['notifyAppReady()' was called] " + bundle);
-            Log.i(CapacitorUpdater.TAG, "semaphoreReady countDown");
+            logger.info("Current bundle loaded successfully. ['notifyAppReady()' was called] " + bundle);
+            logger.info("semaphoreReady countDown");
             this.semaphoreDown();
-            Log.i(CapacitorUpdater.TAG, "semaphoreReady countDown done");
+            logger.info("semaphoreReady countDown done");
             final JSObject ret = new JSObject();
-            ret.put("bundle", bundle.toJSON());
+            ret.put("bundle", mapToJSObject(bundle.toJSONMap()));
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to notify app ready state. [Error calling 'notifyAppReady()']", e);
+            logger.error("Failed to notify app ready state. [Error calling 'notifyAppReady()'] " + e.getMessage());
             call.reject("Failed to commit app ready state.", e);
         }
     }
@@ -831,118 +1506,46 @@ public class CapacitorUpdaterPlugin extends Plugin {
     @PluginMethod
     public void setMultiDelay(final PluginCall call) {
         try {
-            final Object delayConditions = call.getData().opt("delayConditions");
+            final JSONArray delayConditions = call.getData().optJSONArray("delayConditions");
             if (delayConditions == null) {
-                Log.e(CapacitorUpdater.TAG, "setMultiDelay called without delayCondition");
+                logger.error("setMultiDelay called without delayCondition");
                 call.reject("setMultiDelay called without delayCondition");
                 return;
             }
-            if (_setMultiDelay(delayConditions.toString())) {
+            for (int i = 0; i < delayConditions.length(); i++) {
+                final JSONObject object = delayConditions.optJSONObject(i);
+                if (object != null && object.optString("kind").equals("background") && object.optString("value").isEmpty()) {
+                    object.put("value", "0");
+                    delayConditions.put(i, object);
+                }
+            }
+
+            if (this.delayUpdateUtils.setMultiDelay(delayConditions.toString())) {
                 call.resolve();
             } else {
                 call.reject("Failed to delay update");
             }
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to delay update, [Error calling 'setMultiDelay()']", e);
+            logger.error("Failed to delay update, [Error calling 'setMultiDelay()'] " + e.getMessage());
             call.reject("Failed to delay update", e);
         }
     }
 
-    private Boolean _setMultiDelay(String delayConditions) {
-        try {
-            this.editor.putString(DELAY_CONDITION_PREFERENCES, delayConditions);
-            this.editor.commit();
-            Log.i(CapacitorUpdater.TAG, "Delay update saved");
-            return true;
-        } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to delay update, [Error calling '_setMultiDelay()']", e);
-            return false;
-        }
-    }
-
-    private boolean _cancelDelay(String source) {
-        try {
-            this.editor.remove(DELAY_CONDITION_PREFERENCES);
-            this.editor.commit();
-            Log.i(CapacitorUpdater.TAG, "All delays canceled from " + source);
-            return true;
-        } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to cancel update delay", e);
-            return false;
-        }
-    }
-
     @PluginMethod
     public void cancelDelay(final PluginCall call) {
-        if (this._cancelDelay("JS")) {
+        if (this.delayUpdateUtils.cancelDelay("JS")) {
             call.resolve();
         } else {
             call.reject("Failed to cancel delay");
         }
     }
 
-    private void _checkCancelDelay(Boolean killed) {
-        Gson gson = new Gson();
-        String delayUpdatePreferences = prefs.getString(DELAY_CONDITION_PREFERENCES, "[]");
-        Type type = new TypeToken<ArrayList<DelayCondition>>() {}.getType();
-        ArrayList<DelayCondition> delayConditionList = gson.fromJson(delayUpdatePreferences, type);
-        for (DelayCondition condition : delayConditionList) {
-            String kind = condition.getKind().toString();
-            String value = condition.getValue();
-            if (!kind.isEmpty()) {
-                switch (kind) {
-                    case "background":
-                        if (!killed) {
-                            this._cancelDelay("background check");
-                        }
-                        break;
-                    case "kill":
-                        if (killed) {
-                            this._cancelDelay("kill check");
-                            this.installNext();
-                        }
-                        break;
-                    case "date":
-                        if (!"".equals(value)) {
-                            try {
-                                final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");
-                                Date date = sdf.parse(value);
-                                assert date != null;
-                                if (new Date().compareTo(date) > 0) {
-                                    this._cancelDelay("date expired");
-                                }
-                            } catch (final Exception e) {
-                                this._cancelDelay("date parsing issue");
-                            }
-                        } else {
-                            this._cancelDelay("delayVal absent");
-                        }
-                        break;
-                    case "nativeVersion":
-                        if (!"".equals(value)) {
-                            try {
-                                final Version versionLimit = new Version(value);
-                                if (this.currentVersionNative.isAtLeast(versionLimit)) {
-                                    this._cancelDelay("nativeVersion above limit");
-                                }
-                            } catch (final Exception e) {
-                                this._cancelDelay("nativeVersion parsing issue");
-                            }
-                        } else {
-                            this._cancelDelay("delayVal absent");
-                        }
-                        break;
-                }
-            }
-        }
-    }
-
     private Boolean _isAutoUpdateEnabled() {
         final CapConfig config = CapConfig.loadDefault(this.getActivity());
         String serverUrl = config.getServerUrl();
         if (serverUrl != null && !serverUrl.isEmpty()) {
             // log warning autoupdate disabled when serverUrl is set
-            Log.w(CapacitorUpdater.TAG, "AutoUpdate is automatic disabled when serverUrl is set.");
+            logger.warn("AutoUpdate is automatic disabled when serverUrl is set.");
         }
         return (
             CapacitorUpdaterPlugin.this.autoUpdate &&
@@ -958,7 +1561,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
             ret.put("enabled", this._isAutoUpdateEnabled());
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not get autoUpdate status", e);
+            logger.error("Could not get autoUpdate status " + e.getMessage());
             call.reject("Could not get autoUpdate status", e);
         }
     }
@@ -972,7 +1575,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
             ret.put("available", serverUrl == null || serverUrl.isEmpty());
             call.resolve(ret);
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Could not get autoUpdate availability", e);
+            logger.error("Could not get autoUpdate availability " + e.getMessage());
             call.reject("Could not get autoUpdate availability", e);
         }
     }
@@ -984,7 +1587,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
             }
             this.appReadyCheck = startNewThread(new DeferredNotifyAppReadyCheck());
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Failed to start " + DeferredNotifyAppReadyCheck.class.getName(), e);
+            logger.error("Failed to start " + DeferredNotifyAppReadyCheck.class.getName() + " " + e.getMessage());
         }
     }
 
@@ -997,89 +1600,156 @@ public class CapacitorUpdaterPlugin extends Plugin {
         }
     }
 
+    private void ensureBridgeSet() {
+        if (this.bridge != null && this.bridge.getWebView() != null) {
+            logger.setBridge(this.bridge);
+        }
+    }
+
     private void endBackGroundTaskWithNotif(String msg, String latestVersionName, BundleInfo current, Boolean error) {
+        endBackGroundTaskWithNotif(msg, latestVersionName, current, error, false, "download_fail", "downloadFailed", true);
+    }
+
+    private void endBackGroundTaskWithNotif(
+        String msg,
+        String latestVersionName,
+        BundleInfo current,
+        Boolean error,
+        Boolean isDirectUpdate
+    ) {
+        endBackGroundTaskWithNotif(msg, latestVersionName, current, error, isDirectUpdate, "download_fail", "downloadFailed", true);
+    }
+
+    private void endBackGroundTaskWithNotif(
+        String msg,
+        String latestVersionName,
+        BundleInfo current,
+        Boolean error,
+        Boolean isDirectUpdate,
+        String failureAction,
+        String failureEvent
+    ) {
+        endBackGroundTaskWithNotif(msg, latestVersionName, current, error, isDirectUpdate, failureAction, failureEvent, true);
+    }
+
+    private void endBackGroundTaskWithNotif(
+        String msg,
+        String latestVersionName,
+        BundleInfo current,
+        Boolean error,
+        Boolean isDirectUpdate,
+        String failureAction,
+        String failureEvent,
+        boolean shouldSendStats
+    ) {
         if (error) {
-            Log.i(
-                CapacitorUpdater.TAG,
+            logger.info(
                 "endBackGroundTaskWithNotif error: " +
-                error +
-                " current: " +
-                current.getVersionName() +
-                "latestVersionName: " +
-                latestVersionName
+                    error +
+                    " current: " +
+                    current.getVersionName() +
+                    "latestVersionName: " +
+                    latestVersionName
             );
-            this.implementation.sendStats("download_fail", current.getVersionName());
+            if (shouldSendStats) {
+                this.implementation.sendStats(failureAction, current.getVersionName());
+            }
             final JSObject ret = new JSObject();
             ret.put("version", latestVersionName);
-            this.notifyListeners("downloadFailed", ret);
+            this.notifyListeners(failureEvent, ret);
         }
         final JSObject ret = new JSObject();
-        ret.put("bundle", current.toJSON());
+        ret.put("bundle", mapToJSObject(current.toJSONMap()));
         this.notifyListeners("noNeedUpdate", ret);
-        this.sendReadyToJs(current, msg);
+        this.sendReadyToJs(current, msg, isDirectUpdate);
         this.backgroundDownloadTask = null;
-        Log.i(CapacitorUpdater.TAG, "endBackGroundTaskWithNotif " + msg);
+        logger.info("endBackGroundTaskWithNotif " + msg);
     }
 
     private Thread backgroundDownload() {
-        String messageUpdate = this.implementation.directUpdate
+        final boolean plannedDirectUpdate = this.shouldUseDirectUpdate();
+        final boolean initialDirectUpdateAllowed = this.isDirectUpdateCurrentlyAllowed(plannedDirectUpdate);
+        this.implementation.directUpdate = initialDirectUpdateAllowed;
+        final String messageUpdate = initialDirectUpdateAllowed
             ? "Update will occur now."
             : "Update will occur next time app moves to background.";
         return startNewThread(() -> {
-            Log.i(CapacitorUpdater.TAG, "Check for update via: " + CapacitorUpdaterPlugin.this.updateUrl);
-            CapacitorUpdaterPlugin.this.implementation.getLatest(CapacitorUpdaterPlugin.this.updateUrl, null, res -> {
+            logger.info("Check for update via: " + CapacitorUpdaterPlugin.this.updateUrl);
+            try {
+                CapacitorUpdaterPlugin.this.implementation.getLatest(CapacitorUpdaterPlugin.this.updateUrl, null, (res) -> {
+                    JSObject jsRes = mapToJSObject(res);
                     final BundleInfo current = CapacitorUpdaterPlugin.this.implementation.getCurrentBundle();
-                    try {
-                        if (res.has("message")) {
-                            Log.i(CapacitorUpdater.TAG, "API message: " + res.get("message"));
-                            if (res.has("major") && res.getBoolean("major") && res.has("version")) {
-                                final JSObject majorAvailable = new JSObject();
-                                majorAvailable.put("version", res.getString("version"));
-                                CapacitorUpdaterPlugin.this.notifyListeners("majorAvailable", majorAvailable);
-                            }
-                            CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                    res.getString("message"),
-                                    current.getVersionName(),
-                                    current,
-                                    true
-                                );
-                            return;
-                        }
 
-                        final String latestVersionName = res.getString("version");
+                    // Handle network errors and other failures first
+                    if (jsRes.has("error")) {
+                        String error = jsRes.getString("error");
+                        String errorMessage = jsRes.has("message") ? jsRes.getString("message") : "server did not provide a message";
+                        int statusCode = jsRes.has("statusCode") ? jsRes.optInt("statusCode", 0) : 0;
+                        boolean responseIsOk = statusCode >= 200 && statusCode < 300;
+
+                        logger.error(
+                            "getLatest failed with error: " + error + ", message: " + errorMessage + ", statusCode: " + statusCode
+                        );
+                        String latestVersion = jsRes.has("version") ? jsRes.getString("version") : current.getVersionName();
+
+                        CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
+                            errorMessage,
+                            latestVersion,
+                            current,
+                            true,
+                            plannedDirectUpdate,
+                            "download_fail",
+                            "downloadFailed",
+                            !responseIsOk
+                        );
+                        return;
+                    }
+
+                    try {
+                        final String latestVersionName = jsRes.getString("version");
 
                         if ("builtin".equals(latestVersionName)) {
-                            Log.i(CapacitorUpdater.TAG, "Latest version is builtin");
-                            if (CapacitorUpdaterPlugin.this.implementation.directUpdate) {
-                                Log.i(CapacitorUpdater.TAG, "Direct update to builtin version");
+                            logger.info("Latest version is builtin");
+                            final boolean directUpdateAllowedNow = CapacitorUpdaterPlugin.this.isDirectUpdateCurrentlyAllowed(
+                                plannedDirectUpdate
+                            );
+                            if (directUpdateAllowedNow) {
+                                logger.info("Direct update to builtin version");
                                 this._reset(false);
                                 CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                        "Updated to builtin version",
-                                        latestVersionName,
-                                        CapacitorUpdaterPlugin.this.implementation.getCurrentBundle(),
-                                        false
-                                    );
+                                    "Updated to builtin version",
+                                    latestVersionName,
+                                    CapacitorUpdaterPlugin.this.implementation.getCurrentBundle(),
+                                    false,
+                                    true
+                                );
                             } else {
-                                Log.i(CapacitorUpdater.TAG, "Setting next bundle to builtin");
+                                if (plannedDirectUpdate && !directUpdateAllowedNow) {
+                                    logger.info(
+                                        "Direct update skipped because splashscreen timeout occurred. Update will be applied later."
+                                    );
+                                }
+                                logger.info("Setting next bundle to builtin");
                                 CapacitorUpdaterPlugin.this.implementation.setNextBundle(BundleInfo.ID_BUILTIN);
                                 CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                        "Next update will be to builtin version",
-                                        latestVersionName,
-                                        current,
-                                        false
-                                    );
+                                    "Next update will be to builtin version",
+                                    latestVersionName,
+                                    current,
+                                    false
+                                );
                             }
                             return;
                         }
 
-                        if (!res.has("url") || !CapacitorUpdaterPlugin.this.isValidURL(res.getString("url"))) {
-                            Log.e(CapacitorUpdater.TAG, "Error no url or wrong format");
+                        if (!jsRes.has("url") || !CapacitorUpdaterPlugin.this.isValidURL(jsRes.getString("url"))) {
+                            logger.error("Error no url or wrong format");
                             CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                    "Error no url or wrong format",
-                                    current.getVersionName(),
-                                    current,
-                                    true
-                                );
+                                "Error no url or wrong format",
+                                current.getVersionName(),
+                                current,
+                                true,
+                                plannedDirectUpdate
+                            );
                             return;
                         }
 
@@ -1089,129 +1759,158 @@ public class CapacitorUpdaterPlugin extends Plugin {
                             final BundleInfo latest = CapacitorUpdaterPlugin.this.implementation.getBundleInfoByName(latestVersionName);
                             if (latest != null) {
                                 final JSObject ret = new JSObject();
-                                ret.put("bundle", latest.toJSON());
+                                ret.put("bundle", mapToJSObject(latest.toJSONMap()));
                                 if (latest.isErrorStatus()) {
-                                    Log.e(CapacitorUpdater.TAG, "Latest bundle already exists, and is in error state. Aborting update.");
+                                    logger.error("Latest bundle already exists, and is in error state. Aborting update.");
                                     CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                            "Latest bundle already exists, and is in error state. Aborting update.",
-                                            latestVersionName,
-                                            current,
-                                            true
-                                        );
+                                        "Latest bundle already exists, and is in error state. Aborting update.",
+                                        latestVersionName,
+                                        current,
+                                        true,
+                                        plannedDirectUpdate
+                                    );
                                     return;
                                 }
                                 if (latest.isDownloaded()) {
-                                    Log.i(
-                                        CapacitorUpdater.TAG,
-                                        "Latest bundle already exists and download is NOT required. " + messageUpdate
+                                    logger.info("Latest bundle already exists and download is NOT required. " + messageUpdate);
+                                    final boolean directUpdateAllowedNow = CapacitorUpdaterPlugin.this.isDirectUpdateCurrentlyAllowed(
+                                        plannedDirectUpdate
                                     );
-                                    if (CapacitorUpdaterPlugin.this.implementation.directUpdate) {
-                                        CapacitorUpdaterPlugin.this.implementation.set(latest);
-                                        CapacitorUpdaterPlugin.this._reload();
-                                        CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                                "Update installed",
+                                    if (directUpdateAllowedNow) {
+                                        String delayUpdatePreferences = prefs.getString(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES, "[]");
+                                        ArrayList<DelayCondition> delayConditionList = delayUpdateUtils.parseDelayConditions(
+                                            delayUpdatePreferences
+                                        );
+                                        if (!delayConditionList.isEmpty()) {
+                                            logger.info("Update delayed until delay conditions met");
+                                            CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
+                                                "Update delayed until delay conditions met",
                                                 latestVersionName,
                                                 latest,
-                                                false
+                                                false,
+                                                plannedDirectUpdate
                                             );
+                                            return;
+                                        }
+                                        CapacitorUpdaterPlugin.this.implementation.set(latest);
+                                        CapacitorUpdaterPlugin.this._reload();
+                                        CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
+                                            "Update installed",
+                                            latestVersionName,
+                                            latest,
+                                            false,
+                                            true
+                                        );
                                     } else {
+                                        if (plannedDirectUpdate && !directUpdateAllowedNow) {
+                                            logger.info(
+                                                "Direct update skipped because splashscreen timeout occurred. Update will install on next background."
+                                            );
+                                        }
                                         CapacitorUpdaterPlugin.this.notifyListeners("updateAvailable", ret);
                                         CapacitorUpdaterPlugin.this.implementation.setNextBundle(latest.getId());
                                         CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                                "update downloaded, will install next background",
-                                                latestVersionName,
-                                                latest,
-                                                false
-                                            );
+                                            "update downloaded, will install next background",
+                                            latestVersionName,
+                                            latest,
+                                            false
+                                        );
                                     }
                                     return;
                                 }
                                 if (latest.isDeleted()) {
-                                    Log.i(
-                                        CapacitorUpdater.TAG,
-                                        "Latest bundle already exists and will be deleted, download will overwrite it."
-                                    );
+                                    logger.info("Latest bundle already exists and will be deleted, download will overwrite it.");
                                     try {
                                         final Boolean deleted = CapacitorUpdaterPlugin.this.implementation.delete(latest.getId(), true);
                                         if (deleted) {
-                                            Log.i(CapacitorUpdater.TAG, "Failed bundle deleted: " + latest.getVersionName());
+                                            logger.info("Failed bundle deleted: " + latest.getVersionName());
                                         }
                                     } catch (final IOException e) {
-                                        Log.e(CapacitorUpdater.TAG, "Failed to delete failed bundle: " + latest.getVersionName(), e);
+                                        logger.error("Failed to delete failed bundle: " + latest.getVersionName() + " " + e.getMessage());
                                     }
                                 }
                             }
                             startNewThread(() -> {
                                 try {
-                                    Log.i(
-                                        CapacitorUpdater.TAG,
+                                    logger.info(
                                         "New bundle: " +
-                                        latestVersionName +
-                                        " found. Current is: " +
-                                        current.getVersionName() +
-                                        ". " +
-                                        messageUpdate
+                                            latestVersionName +
+                                            " found. Current is: " +
+                                            current.getVersionName() +
+                                            ". " +
+                                            messageUpdate
                                     );
 
-                                    final String url = res.getString("url");
-                                    final String sessionKey = res.has("sessionKey") ? res.getString("sessionKey") : "";
-                                    final String checksum = res.has("checksum") ? res.getString("checksum") : "";
+                                    final String url = jsRes.getString("url");
+                                    final String sessionKey = jsRes.has("sessionKey") ? jsRes.getString("sessionKey") : "";
+                                    final String checksum = jsRes.has("checksum") ? jsRes.getString("checksum") : "";
 
-                                    if (res.has("manifest")) {
+                                    if (jsRes.has("manifest")) {
                                         // Handle manifest-based download
-                                        JSONArray manifest = res.getJSONArray("manifest");
+                                        JSONArray manifest = jsRes.getJSONArray("manifest");
                                         CapacitorUpdaterPlugin.this.implementation.downloadBackground(
-                                                url,
-                                                latestVersionName,
-                                                sessionKey,
-                                                checksum,
-                                                manifest
-                                            );
+                                            url,
+                                            latestVersionName,
+                                            sessionKey,
+                                            checksum,
+                                            manifest
+                                        );
                                     } else {
                                         // Handle single file download (existing code)
                                         CapacitorUpdaterPlugin.this.implementation.downloadBackground(
-                                                url,
-                                                latestVersionName,
-                                                sessionKey,
-                                                checksum,
-                                                null
-                                            );
+                                            url,
+                                            latestVersionName,
+                                            sessionKey,
+                                            checksum,
+                                            null
+                                        );
                                     }
                                 } catch (final Exception e) {
-                                    Log.e(CapacitorUpdater.TAG, "error downloading file", e);
+                                    logger.error("error downloading file " + e.getMessage());
                                     CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                            "Error downloading file",
-                                            latestVersionName,
-                                            CapacitorUpdaterPlugin.this.implementation.getCurrentBundle(),
-                                            true
-                                        );
+                                        "Error downloading file",
+                                        latestVersionName,
+                                        CapacitorUpdaterPlugin.this.implementation.getCurrentBundle(),
+                                        true,
+                                        plannedDirectUpdate
+                                    );
                                 }
                             });
                         } else {
-                            Log.i(CapacitorUpdater.TAG, "No need to update, " + current.getId() + " is the latest bundle.");
+                            logger.info("No need to update, " + current.getId() + " is the latest bundle.");
                             CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif("No need to update", latestVersionName, current, false);
                         }
-                    } catch (final JSONException e) {
-                        Log.e(CapacitorUpdater.TAG, "error parsing JSON", e);
+                    } catch (final Exception e) {
+                        logger.error("error in update check " + e.getMessage());
                         CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
-                                "Error parsing JSON",
-                                current.getVersionName(),
-                                current,
-                                true
-                            );
+                            "Error in update check",
+                            current.getVersionName(),
+                            current,
+                            true,
+                            plannedDirectUpdate
+                        );
                     }
                 });
+            } catch (final Exception e) {
+                logger.error("getLatest call failed: " + e.getMessage());
+                final BundleInfo current = CapacitorUpdaterPlugin.this.implementation.getCurrentBundle();
+                CapacitorUpdaterPlugin.this.endBackGroundTaskWithNotif(
+                    "Network connection failed",
+                    current.getVersionName(),
+                    current,
+                    true,
+                    plannedDirectUpdate
+                );
+            }
         });
     }
 
     private void installNext() {
         try {
-            Gson gson = new Gson();
-            String delayUpdatePreferences = prefs.getString(DELAY_CONDITION_PREFERENCES, "[]");
-            Type type = new TypeToken<ArrayList<DelayCondition>>() {}.getType();
-            ArrayList<DelayCondition> delayConditionList = gson.fromJson(delayUpdatePreferences, type);
-            if (delayConditionList != null && !delayConditionList.isEmpty()) {
-                Log.i(CapacitorUpdater.TAG, "Update delayed until delay conditions met");
+            String delayUpdatePreferences = prefs.getString(DelayUpdateUtils.DELAY_CONDITION_PREFERENCES, "[]");
+            ArrayList<DelayCondition> delayConditionList = delayUpdateUtils.parseDelayConditions(delayUpdatePreferences);
+            if (!delayConditionList.isEmpty()) {
+                logger.info("Update delayed until delay conditions met");
                 return;
             }
             final BundleInfo current = this.implementation.getCurrentBundle();
@@ -1219,16 +1918,16 @@ public class CapacitorUpdaterPlugin extends Plugin {
 
             if (next != null && !next.isErrorStatus() && !next.getId().equals(current.getId())) {
                 // There is a next bundle waiting for activation
-                Log.d(CapacitorUpdater.TAG, "Next bundle is: " + next.getVersionName());
+                logger.debug("Next bundle is: " + next.getVersionName());
                 if (this.implementation.set(next) && this._reload()) {
-                    Log.i(CapacitorUpdater.TAG, "Updated to bundle: " + next.getVersionName());
+                    logger.info("Updated to bundle: " + next.getVersionName());
                     this.implementation.setNextBundle(null);
                 } else {
-                    Log.e(CapacitorUpdater.TAG, "Update to bundle: " + next.getVersionName() + " Failed!");
+                    logger.error("Update to bundle: " + next.getVersionName() + " Failed!");
                 }
             }
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Error during onActivityStopped", e);
+            logger.error("Error during onActivityStopped " + e.getMessage());
         }
     }
 
@@ -1237,33 +1936,34 @@ public class CapacitorUpdaterPlugin extends Plugin {
         final BundleInfo current = this.implementation.getCurrentBundle();
 
         if (current.isBuiltin()) {
-            Log.i(CapacitorUpdater.TAG, "Built-in bundle is active. We skip the check for notifyAppReady.");
+            logger.info("Built-in bundle is active. We skip the check for notifyAppReady.");
             return;
         }
-        Log.d(CapacitorUpdater.TAG, "Current bundle is: " + current);
+        logger.debug("Current bundle is: " + current);
 
         if (BundleStatus.SUCCESS != current.getStatus()) {
-            Log.e(CapacitorUpdater.TAG, "notifyAppReady was not called, roll back current bundle: " + current.getId());
-            Log.i(CapacitorUpdater.TAG, "Did you forget to call 'notifyAppReady()' in your Capacitor App code?");
+            logger.error("notifyAppReady was not called, roll back current bundle: " + current.getId());
+            logger.info("Did you forget to call 'notifyAppReady()' in your Capacitor App code?");
             final JSObject ret = new JSObject();
-            ret.put("bundle", current.toJSON());
+            ret.put("bundle", mapToJSObject(current.toJSONMap()));
+            this.persistLastFailedBundle(current);
             this.notifyListeners("updateFailed", ret);
             this.implementation.sendStats("update_fail", current.getVersionName());
             this.implementation.setError(current);
             this._reset(true);
             if (CapacitorUpdaterPlugin.this.autoDeleteFailed && !current.isBuiltin()) {
-                Log.i(CapacitorUpdater.TAG, "Deleting failing bundle: " + current.getVersionName());
+                logger.info("Deleting failing bundle: " + current.getVersionName());
                 try {
                     final Boolean res = this.implementation.delete(current.getId(), false);
                     if (res) {
-                        Log.i(CapacitorUpdater.TAG, "Failed bundle deleted: " + current.getVersionName());
+                        logger.info("Failed bundle deleted: " + current.getVersionName());
                     }
                 } catch (final IOException e) {
-                    Log.e(CapacitorUpdater.TAG, "Failed to delete failed bundle: " + current.getVersionName(), e);
+                    logger.error("Failed to delete failed bundle: " + current.getVersionName() + " " + e.getMessage());
                 }
             }
         } else {
-            Log.i(CapacitorUpdater.TAG, "notifyAppReady was called. This is fine: " + current.getId());
+            logger.info("notifyAppReady was called. This is fine: " + current.getId());
         }
     }
 
@@ -1272,15 +1972,12 @@ public class CapacitorUpdaterPlugin extends Plugin {
         @Override
         public void run() {
             try {
-                Log.i(
-                    CapacitorUpdater.TAG,
-                    "Wait for " + CapacitorUpdaterPlugin.this.appReadyTimeout + "ms, then check for notifyAppReady"
-                );
+                logger.info("Wait for " + CapacitorUpdaterPlugin.this.appReadyTimeout + "ms, then check for notifyAppReady");
                 Thread.sleep(CapacitorUpdaterPlugin.this.appReadyTimeout);
                 CapacitorUpdaterPlugin.this.checkRevert();
                 CapacitorUpdaterPlugin.this.appReadyCheck = null;
             } catch (final InterruptedException e) {
-                Log.i(CapacitorUpdater.TAG, DeferredNotifyAppReadyCheck.class.getName() + " was interrupted.");
+                logger.info(DeferredNotifyAppReadyCheck.class.getName() + " was interrupted.");
             }
         }
     }
@@ -1288,14 +1985,21 @@ public class CapacitorUpdaterPlugin extends Plugin {
     public void appMovedToForeground() {
         final BundleInfo current = CapacitorUpdaterPlugin.this.implementation.getCurrentBundle();
         CapacitorUpdaterPlugin.this.implementation.sendStats("app_moved_to_foreground", current.getVersionName());
-        this._checkCancelDelay(false);
+        this.delayUpdateUtils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.FOREGROUND);
+        this.delayUpdateUtils.unsetBackgroundTimestamp();
+
         if (
             CapacitorUpdaterPlugin.this._isAutoUpdateEnabled() &&
             (this.backgroundDownloadTask == null || !this.backgroundDownloadTask.isAlive())
         ) {
             this.backgroundDownloadTask = this.backgroundDownload();
         } else {
-            Log.i(CapacitorUpdater.TAG, "Auto update is disabled");
+            final CapConfig config = CapConfig.loadDefault(this.getActivity());
+            String serverUrl = config.getServerUrl();
+            if (serverUrl != null && !serverUrl.isEmpty()) {
+                CapacitorUpdaterPlugin.this.implementation.sendStats("blocked_by_server_url", current.getVersionName());
+            }
+            logger.info("Auto update is disabled");
             this.sendReadyToJs(current, "disabled");
         }
         this.checkAppReady();
@@ -1303,40 +2007,50 @@ public class CapacitorUpdaterPlugin extends Plugin {
 
     public void appMovedToBackground() {
         final BundleInfo current = CapacitorUpdaterPlugin.this.implementation.getCurrentBundle();
-        CapacitorUpdaterPlugin.this.implementation.sendStats("app_moved_to_background", current.getVersionName());
-        Log.i(CapacitorUpdater.TAG, "Checking for pending update");
-        try {
-            Gson gson = new Gson();
-            String delayUpdatePreferences = prefs.getString(DELAY_CONDITION_PREFERENCES, "[]");
-            Type type = new TypeToken<ArrayList<DelayCondition>>() {}.getType();
-            ArrayList<DelayCondition> delayConditionList = gson.fromJson(delayUpdatePreferences, type);
-            String backgroundValue = null;
-            for (DelayCondition delayCondition : delayConditionList) {
-                if (delayCondition.getKind().toString().equals("background")) {
-                    String value = delayCondition.getValue();
-                    backgroundValue = (value != null && !value.isEmpty()) ? value : "0";
-                }
+
+        // Show splashscreen FIRST, before any other background work to ensure launcher shows it
+        if (this.autoSplashscreen) {
+            boolean canShowSplashscreen = true;
+
+            if (!this._isAutoUpdateEnabled()) {
+                logger.warn(
+                    "autoSplashscreen is enabled but autoUpdate is disabled. Splashscreen will not be shown. Enable autoUpdate or disable autoSplashscreen."
+                );
+                canShowSplashscreen = false;
             }
-            if (backgroundValue != null) {
-                taskRunning = true;
-                final Long timeout = Long.parseLong(backgroundValue);
-                if (backgroundTask != null) {
-                    backgroundTask.interrupt();
+
+            if (!this.shouldUseDirectUpdate()) {
+                if ("false".equals(this.directUpdateMode)) {
+                    logger.warn(
+                        "autoSplashscreen is enabled but directUpdate is not configured for immediate updates. Set directUpdate to 'always' or disable autoSplashscreen."
+                    );
+                } else if ("atInstall".equals(this.directUpdateMode) || "onLaunch".equals(this.directUpdateMode)) {
+                    logger.info(
+                        "autoSplashscreen is enabled but directUpdate is set to \"" +
+                            this.directUpdateMode +
+                            "\". This is normal. Skipping autoSplashscreen logic."
+                    );
                 }
-                backgroundTask = startNewThread(
-                    () -> {
-                        taskRunning = false;
-                        _checkCancelDelay(false);
-                        installNext();
-                    },
-                    timeout
-                );
-            } else {
-                this._checkCancelDelay(false);
-                this.installNext();
+                canShowSplashscreen = false;
+            }
+
+            if (canShowSplashscreen) {
+                logger.info("Showing splashscreen for launcher/task switcher");
+                this.showSplashscreen();
             }
+        }
+
+        // Do other background work after splashscreen is shown
+        CapacitorUpdaterPlugin.this.implementation.sendStats("app_moved_to_background", current.getVersionName());
+        logger.info("Checking for pending update");
+
+        try {
+            // We need to set "backgrounded time"
+            this.delayUpdateUtils.setBackgroundTimestamp(System.currentTimeMillis());
+            this.delayUpdateUtils.checkCancelDelay(DelayUpdateUtils.CancelDelaySource.BACKGROUND);
+            this.installNext();
         } catch (final Exception e) {
-            Log.e(CapacitorUpdater.TAG, "Error during onActivityStopped", e);
+            logger.error("Error during onActivityStopped " + e.getMessage());
         }
     }
 
@@ -1363,48 +2077,156 @@ public class CapacitorUpdaterPlugin extends Plugin {
         }
     }
 
-    private void appKilled() {
-        Log.d(CapacitorUpdater.TAG, "onActivityDestroyed: all activity destroyed");
-        this._checkCancelDelay(true);
-    }
-
     @Override
     public void handleOnStart() {
-        if (isPreviousMainActivity) {
-            this.appMovedToForeground();
+        try {
+            if (isPreviousMainActivity) {
+                logger.info("handleOnStart: appMovedToForeground");
+                this.appMovedToForeground();
+            }
+            logger.info("handleOnStart: onActivityStarted " + getActivity().getClass().getName());
+            isPreviousMainActivity = true;
+
+            // Initialize shake menu if enabled and activity is BridgeActivity
+            if (shakeMenuEnabled && getActivity() instanceof com.getcapacitor.BridgeActivity && shakeMenu == null) {
+                try {
+                    shakeMenu = new ShakeMenu(this, (com.getcapacitor.BridgeActivity) getActivity(), logger);
+                    logger.info("Shake menu initialized");
+                } catch (Exception e) {
+                    logger.error("Failed to initialize shake menu: " + e.getMessage());
+                }
+            }
+        } catch (Exception e) {
+            logger.error("Failed to run handleOnStart: " + e.getMessage());
         }
-        Log.i(CapacitorUpdater.TAG, "onActivityStarted " + getActivity().getClass().getName());
-        isPreviousMainActivity = true;
     }
 
     @Override
     public void handleOnStop() {
-        isPreviousMainActivity = isMainActivity();
-        if (isPreviousMainActivity) {
-            this.appMovedToBackground();
+        try {
+            isPreviousMainActivity = isMainActivity();
+            if (isPreviousMainActivity) {
+                logger.info("handleOnStop: appMovedToBackground");
+                this.appMovedToBackground();
+            }
+        } catch (Exception e) {
+            logger.error("Failed to run handleOnStop: " + e.getMessage());
         }
     }
 
     @Override
     public void handleOnResume() {
-        if (backgroundTask != null && taskRunning) {
-            backgroundTask.interrupt();
+        try {
+            if (backgroundTask != null && taskRunning) {
+                backgroundTask.interrupt();
+            }
+            this.implementation.activity = getActivity();
+        } catch (Exception e) {
+            logger.error("Failed to run handleOnResume: " + e.getMessage());
         }
-        this.implementation.activity = getActivity();
     }
 
     @Override
     public void handleOnPause() {
-        this.implementation.activity = getActivity();
+        try {
+            this.implementation.activity = getActivity();
+        } catch (Exception e) {
+            logger.error("Failed to run handleOnPause: " + e.getMessage());
+        }
     }
 
     @Override
     public void handleOnDestroy() {
-        Log.i(CapacitorUpdater.TAG, "onActivityDestroyed " + getActivity().getClass().getName());
-        this.implementation.activity = getActivity();
-        counterActivityCreate--;
-        if (counterActivityCreate == 0) {
-            this.appKilled();
+        try {
+            logger.info("onActivityDestroyed " + getActivity().getClass().getName());
+            this.implementation.activity = getActivity();
+
+            // Clean up shake menu
+            if (shakeMenu != null) {
+                try {
+                    shakeMenu.stop();
+                    shakeMenu = null;
+                    logger.info("Shake menu cleaned up");
+                } catch (Exception e) {
+                    logger.error("Failed to clean up shake menu: " + e.getMessage());
+                }
+            }
+        } catch (Exception e) {
+            logger.error("Failed to run handleOnDestroy: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void setShakeMenu(final PluginCall call) {
+        final Boolean enabled = call.getBoolean("enabled");
+        if (enabled == null) {
+            logger.error("setShakeMenu called without enabled parameter");
+            call.reject("setShakeMenu called without enabled parameter");
+            return;
+        }
+
+        this.shakeMenuEnabled = enabled;
+        logger.info("Shake menu " + (enabled ? "enabled" : "disabled"));
+
+        // Manage shake menu instance based on enabled state
+        if (enabled && getActivity() instanceof com.getcapacitor.BridgeActivity && shakeMenu == null) {
+            try {
+                shakeMenu = new ShakeMenu(this, (com.getcapacitor.BridgeActivity) getActivity(), logger);
+                logger.info("Shake menu initialized");
+            } catch (Exception e) {
+                logger.error("Failed to initialize shake menu: " + e.getMessage());
+            }
+        } else if (!enabled && shakeMenu != null) {
+            try {
+                shakeMenu.stop();
+                shakeMenu = null;
+                logger.info("Shake menu stopped");
+            } catch (Exception e) {
+                logger.error("Failed to stop shake menu: " + e.getMessage());
+            }
+        }
+
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void isShakeMenuEnabled(final PluginCall call) {
+        try {
+            final JSObject ret = new JSObject();
+            ret.put("enabled", this.shakeMenuEnabled);
+            call.resolve(ret);
+        } catch (final Exception e) {
+            logger.error("Could not get shake menu status " + e.getMessage());
+            call.reject("Could not get shake menu status", e);
+        }
+    }
+
+    @PluginMethod
+    public void getAppId(final PluginCall call) {
+        try {
+            final JSObject ret = new JSObject();
+            ret.put("appId", this.implementation.appId);
+            call.resolve(ret);
+        } catch (final Exception e) {
+            logger.error("Could not get appId " + e.getMessage());
+            call.reject("Could not get appId", e);
         }
     }
+
+    @PluginMethod
+    public void setAppId(final PluginCall call) {
+        if (!this.getConfig().getBoolean("allowModifyAppId", false)) {
+            logger.error("setAppId not allowed set allowModifyAppId in your config to true to allow it");
+            call.reject("setAppId not allowed");
+            return;
+        }
+        final String appId = call.getString("appId");
+        if (appId == null) {
+            logger.error("setAppId called without appId");
+            call.reject("setAppId called without appId");
+            return;
+        }
+        this.implementation.appId = appId;
+        call.resolve();
+    }
 }