From ce2b0d4292f88db0a01ef01c50b3b68461073b4f Mon Sep 17 00:00:00 2001
From: im7mortal <5336231+im7mortal@users.noreply.github.com>
Date: Sun, 7 Dec 2025 10:53:19 +0300
Subject: [PATCH] Add draft proposal of Android battery optimisations

---
 3rdparty/glean                                |   2 +-
 3rdparty/i18n                                 |   2 +-
 android/AndroidManifest.xml                   |   1 +
 .../qt/common/BatteryOptimizationHelper.kt    | 199 ++++++++++++++++++
 .../firefox/vpn/daemon/BootReceiver.kt        |  78 ++++++-
 .../mozilla/firefox/vpn/daemon/VPNService.kt  |  31 +++
 android/tunnel/src/go/CMakeLists.txt          |   2 +-
 .../mozilla/firefox/vpn/qt/VPNActivity.java   | 125 +++++++++++
 scripts/android/cmake.sh                      |  10 +-
 src/commands/commandui.cpp                    |   2 +-
 10 files changed, 439 insertions(+), 13 deletions(-)
 create mode 100644 android/common/src/main/java/org/mozilla/firefox/qt/common/BatteryOptimizationHelper.kt

diff --git a/3rdparty/glean b/3rdparty/glean
index 9f785a92bd..3bfe35be0e 160000
--- a/3rdparty/glean
+++ b/3rdparty/glean
@@ -1 +1 @@
-Subproject commit 9f785a92bdcacc862c609cd3e02b05b68c74862a
+Subproject commit 3bfe35be0e94ff751aaeb9daa6c5f1a207b47d69
diff --git a/3rdparty/i18n b/3rdparty/i18n
index e084d11c11..1154db049c 160000
--- a/3rdparty/i18n
+++ b/3rdparty/i18n
@@ -1 +1 @@
-Subproject commit e084d11c11dd6145b55f7c7b3022d693a6d4e551
+Subproject commit 1154db049c11965546f4fbf3ecf7b15d986c5d34
diff --git a/android/AndroidManifest.xml b/android/AndroidManifest.xml
index fe949a9abc..5df57507bb 100644
--- a/android/AndroidManifest.xml
+++ b/android/AndroidManifest.xml
@@ -12,6 +12,7 @@ file, You can obtain one at http://mozilla.org/MPL/2.0/.
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"/>
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
     <uses-permission android:name="com.google.android.gms.permission.AD_ID"/>
 
     <!-- The following comment will be replaced upon deployment with default features based on the dependencies of the application.
diff --git a/android/common/src/main/java/org/mozilla/firefox/qt/common/BatteryOptimizationHelper.kt b/android/common/src/main/java/org/mozilla/firefox/qt/common/BatteryOptimizationHelper.kt
new file mode 100644
index 0000000000..b8eafb042e
--- /dev/null
+++ b/android/common/src/main/java/org/mozilla/firefox/qt/common/BatteryOptimizationHelper.kt
@@ -0,0 +1,199 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+package org.mozilla.firefox.qt.common
+
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.PowerManager
+import android.provider.Settings
+import android.util.Log
+import androidx.annotation.RequiresApi
+
+/**
+ * Helper class for managing battery optimization settings.
+ * 
+ * Battery optimization can cause Android to kill VPN services after a few hours
+ * or prevent them from starting after device reboot. This helper provides methods
+ * to detect battery optimization status and guide users to disable it.
+ */
+object BatteryOptimizationHelper {
+    private const val TAG = "BatteryOptimizationHelper"
+
+    /**
+     * Check if battery optimizations are disabled for this app.
+     * 
+     * @param context Application context
+     * @return true if optimizations are disabled (good for VPN), false if enabled
+     */
+    @JvmStatic
+    fun isIgnoringBatteryOptimizations(context: Context): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            // Battery optimization was introduced in Android M (API 23)
+            return true
+        }
+
+        return try {
+            val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+            powerManager.isIgnoringBatteryOptimizations(context.packageName)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to check battery optimization status", e)
+            // Assume it's okay if we can't check (fail-safe)
+            true
+        }
+    }
+
+    /**
+     * Check if we have permission to request battery optimization exemption.
+     * 
+     * @param context Application context
+     * @return true if permission is granted
+     */
+    @JvmStatic
+    fun hasRequestIgnoreBatteryOptimizationsPermission(context: Context): Boolean {
+        return try {
+            val permission = "android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"
+            context.packageManager.checkPermission(permission, context.packageName) == 
+                PackageManager.PERMISSION_GRANTED
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to check REQUEST_IGNORE_BATTERY_OPTIMIZATIONS permission", e)
+            false
+        }
+    }
+
+    /**
+     * Get intent to request battery optimization exemption or open settings.
+     * 
+     * This method returns different intents based on:
+     * - Whether we have REQUEST_IGNORE_BATTERY_OPTIMIZATIONS permission
+     * - Android version
+     * 
+     * @param context Application context
+     * @return Intent to open appropriate settings screen, or null if failed
+     */
+    @RequiresApi(Build.VERSION_CODES.M)
+    @JvmStatic
+    fun getRequestIgnoreBatteryOptimizationsIntent(context: Context): Intent? {
+        return try {
+            if (hasRequestIgnoreBatteryOptimizationsPermission(context)) {
+                // Can request directly via system dialog
+                val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
+                intent.data = Uri.parse("package:${context.packageName}")
+                intent
+            } else {
+                // Need to guide user to settings manually
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    // Android 12+: Go to app details
+                    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                        data = Uri.parse("package:${context.packageName}")
+                    }
+                } else {
+                    // Android 6-11: Go to battery optimization list
+                    Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS)
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to create battery optimization intent", e)
+            null
+        }
+    }
+
+    /**
+     * Check if background restrictions are enabled for this app.
+     * Background restrictions prevent apps from running in the background.
+     * 
+     * @param context Application context
+     * @return true if restrictions are enabled (bad for VPN), false otherwise
+     */
+    @RequiresApi(Build.VERSION_CODES.P)
+    fun isBackgroundRestricted(context: Context): Boolean {
+        return try {
+            val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as android.app.ActivityManager
+            activityManager.isBackgroundRestricted
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to check background restrictions", e)
+            false
+        }
+    }
+
+    /**
+     * Check if background data is restricted for this app.
+     * Background data restrictions prevent apps from using data in the background.
+     * 
+     * @param context Application context
+     * @return true if data is restricted (bad for VPN), false otherwise
+     */
+    @RequiresApi(Build.VERSION_CODES.N)
+    fun isBackgroundDataRestricted(context: Context): Boolean {
+        return try {
+            val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as android.net.ConnectivityManager
+            connectivityManager.restrictBackgroundStatus == android.net.ConnectivityManager.RESTRICT_BACKGROUND_STATUS_ENABLED
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to check background data restrictions", e)
+            false
+        }
+    }
+
+    /**
+     * Get a user-friendly description of why battery optimization should be disabled.
+     * 
+     * @return String explaining the issue
+     */
+    @JvmStatic
+    fun getBatteryOptimizationExplanation(): String {
+        return "Mozilla VPN may disconnect after a few hours and won't restart after device reboot " +
+               "because battery optimization is enabled.\n\n" +
+               "For reliable VPN operation, please disable battery optimization for Mozilla VPN.\n\n" +
+               "This allows the VPN to maintain your secure connection continuously."
+    }
+
+    /**
+     * Get a short warning message for battery optimization.
+     * 
+     * @return Short warning string
+     */
+    fun getBatteryOptimizationWarning(): String {
+        return "⚠️ Battery optimization is enabled - VPN may disconnect"
+    }
+
+    /**
+     * Log battery optimization status and related restrictions.
+     * Useful for troubleshooting.
+     * 
+     * @param context Application context
+     * @param tag Log tag to use
+     */
+    fun logBatteryOptimizationStatus(context: Context, tag: String = TAG) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            val isIgnoring = isIgnoringBatteryOptimizations(context)
+            if (isIgnoring) {
+                Log.i(tag, "✓ Battery optimization is disabled - VPN should remain stable")
+            } else {
+                Log.w(tag, "⚠️ Battery optimization is ENABLED - VPN may disconnect after a few hours!")
+                Log.w(tag, "⚠️ User should disable battery optimization for reliable VPN operation")
+            }
+
+            // Check background restrictions on Android P+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                if (isBackgroundRestricted(context)) {
+                    Log.w(tag, "⚠️ Background restrictions are enabled - VPN may not work properly!")
+                }
+            }
+
+            // Check background data restrictions on Android N+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                if (isBackgroundDataRestricted(context)) {
+                    Log.w(tag, "⚠️ Background data is restricted - VPN may not work properly!")
+                }
+            }
+        } else {
+            Log.i(tag, "Battery optimization checks not available on Android < 6.0")
+        }
+    }
+}
+
+
diff --git a/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/BootReceiver.kt b/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/BootReceiver.kt
index 2d44d05f9b..c0aec775b7 100644
--- a/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/BootReceiver.kt
+++ b/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/BootReceiver.kt
@@ -8,27 +8,93 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.os.Build
+import org.mozilla.firefox.qt.common.BatteryOptimizationHelper
 import org.mozilla.firefox.qt.common.Prefs
 
+/**
+ * Boot receiver that starts the VPN service when the device boots.
+ * 
+ * IMPORTANT: This receiver may fail to start the VPN service if battery optimization
+ * is enabled, especially on Android 12+ (API 31+). Battery optimization should be
+ * disabled for reliable VPN auto-start after reboot.
+ */
 class BootReceiver : BroadcastReceiver() {
     private val TAG = "BootReceiver"
 
     override fun onReceive(context: Context, arg1: Intent) {
         Log.init(context)
+        
+        // Check if start on boot is enabled
         if (!Prefs.get(context).getBoolean(START_ON_BOOT, false)) {
-            Log.i(TAG, "This device did not enable start on boot - exit")
+            Log.i(TAG, "Start on boot is disabled - exit")
             return
         }
-        Log.i(TAG, "This device did enable start on boot - try to start")
+        
+        Log.i(TAG, "Device rebooted - attempting to start VPN service")
+        
+        // Check battery optimization status and log detailed information
+        checkBatteryOptimizationStatus(context)
+        
+        // Attempt to start the VPN service
         val intent = Intent(context, VPNService::class.java)
         intent.putExtra("startOnBoot", true)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            context.startForegroundService(intent)
+        
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+                Log.i(TAG, "✓ Successfully queued VPN service start (foreground)")
+            } else {
+                context.startService(intent)
+                Log.i(TAG, "✓ Successfully started VPN service")
+            }
+        } catch (e: IllegalStateException) {
+            // This exception commonly happens on Android 12+ when battery optimization is enabled
+            Log.e(TAG, "❌ Failed to start VPN service from background!")
+            Log.e(TAG, "❌ This is likely because battery optimization is enabled")
+            Log.e(TAG, "❌ VPN will not auto-start until user opens the app")
+            Log.e(TAG, "Exception: ${e.message}")
+            Log.stack(TAG, e.stackTrace)
+            
+            // Note: We cannot show a notification here reliably on Android 12+
+            // The user will need to open the app, which will show the battery optimization warning
+        } catch (e: SecurityException) {
+            // Permission denied
+            Log.e(TAG, "❌ Security exception when starting VPN service")
+            Log.e(TAG, "❌ VPN permissions may have been revoked")
+            Log.e(TAG, "Exception: ${e.message}")
+            Log.stack(TAG, e.stackTrace)
+        } catch (e: Exception) {
+            // Other unexpected errors
+            Log.e(TAG, "❌ Unexpected error starting VPN service: ${e.message}")
+            Log.stack(TAG, e.stackTrace)
+        }
+    }
+    
+    /**
+     * Check and log battery optimization status.
+     * This helps diagnose why VPN auto-start may fail after reboot.
+     */
+    private fun checkBatteryOptimizationStatus(context: Context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            BatteryOptimizationHelper.logBatteryOptimizationStatus(context, TAG)
+            
+            val isIgnoring = BatteryOptimizationHelper.isIgnoringBatteryOptimizations(context)
+            if (!isIgnoring) {
+                Log.e(TAG, "⚠️ Battery optimization is enabled - VPN may not start from background!")
+                Log.e(TAG, "⚠️ This is especially problematic on Android 12+ (API 31+)")
+                Log.e(TAG, "⚠️ User should open the app and disable battery optimization")
+                
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    Log.e(TAG, "⚠️ Android 12+ detected - background service start restrictions apply")
+                }
+            } else {
+                Log.i(TAG, "✓ Battery optimization is disabled - VPN should start successfully")
+            }
         } else {
-            context.startService(intent)
+            Log.i(TAG, "Battery optimization checks not available on Android < 6.0")
         }
-        Log.i(TAG, "Queued VPNService start")
     }
+    
     companion object {
         const val START_ON_BOOT = "startOnBoot"
     }
diff --git a/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/VPNService.kt b/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/VPNService.kt
index f4166c4e51..c1f848b7f3 100644
--- a/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/VPNService.kt
+++ b/android/daemon/src/main/java/org/mozilla/firefox/vpn/daemon/VPNService.kt
@@ -20,6 +20,7 @@ import mozilla.telemetry.glean.BuildInfo
 import mozilla.telemetry.glean.Glean
 import mozilla.telemetry.glean.config.Configuration
 import org.json.JSONObject
+import org.mozilla.firefox.qt.common.BatteryOptimizationHelper
 import org.mozilla.firefox.qt.common.CoreBinder
 import org.mozilla.firefox.qt.common.Prefs
 import org.mozilla.firefox.vpn.daemon.GleanMetrics.ConnectionHealth
@@ -147,6 +148,9 @@ class VPNService : android.net.VpnService() {
         Log.i(tag, "Wireguard reported current tunnel: $currentTunnelHandle")
         mAlreadyInitialised = true
 
+        // Check battery optimization status and log warnings
+        checkBatteryOptimizationStatus()
+
         // It's usually a bad practice to initialize Glean with the wrong
         // value for uploadEnabled... However, since this is a very controlled
         // situation -- it should only happen when logging in to a brand new
@@ -159,6 +163,26 @@ class VPNService : android.net.VpnService() {
         initializeGlean(Prefs.get(this).getBoolean("glean_enabled", false))
     }
 
+    /**
+     * Check battery optimization status and log warnings.
+     * This helps users understand why VPN may disconnect after a few hours.
+     */
+    private fun checkBatteryOptimizationStatus() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            BatteryOptimizationHelper.logBatteryOptimizationStatus(this, tag)
+            
+            // If battery optimization is enabled, send broadcast to notify UI
+            if (!BatteryOptimizationHelper.isIgnoringBatteryOptimizations(this)) {
+                try {
+                    val intent = Intent("org.mozilla.firefox.vpn.BATTERY_OPTIMIZATION_WARNING")
+                    sendBroadcast(intent)
+                } catch (e: Exception) {
+                    Log.e(tag, "Failed to send battery optimization warning broadcast: ${e.message}")
+                }
+            }
+        }
+    }
+
     override fun onUnbind(intent: Intent?): Boolean {
         if (!isUp) {
             Log.v(tag, "Client Disconnected, VPN is down - Service might shut down soon")
@@ -360,6 +384,13 @@ class VPNService : android.net.VpnService() {
         // asked boot vpn from the OS
         val prefs = Prefs.get(this)
         prefs.edit().putString("lastConf", json.toString()).apply()
+        
+        // Auto-enable start on boot when VPN connects successfully
+        // This ensures VPN will restart after device reboot
+        if (!prefs.getBoolean(BootReceiver.START_ON_BOOT, false)) {
+            Log.i(tag, "Auto-enabling start on boot for reliable VPN restart after reboot")
+            prefs.edit().putBoolean(BootReceiver.START_ON_BOOT, true).apply()
+        }
 
         // Go foreground
         CannedNotification(mConfig)?.let { mNotificationHandler.show(it) }
diff --git a/android/tunnel/src/go/CMakeLists.txt b/android/tunnel/src/go/CMakeLists.txt
index 4611a0f9a6..48f93e3c39 100644
--- a/android/tunnel/src/go/CMakeLists.txt
+++ b/android/tunnel/src/go/CMakeLists.txt
@@ -56,7 +56,7 @@ file(MAKE_DIRECTORY "${OUTPUT_LIB_DIR}")
 add_custom_command(
         OUTPUT "${OUTPUT_LIB_DIR}/libtunnel.so"
         COMMAND ${CMAKE_COMMAND} -E env ${GO_ENV}
-        ${GO_EXECUTABLE} build -buildmode=c-shared
+        ${GO_EXECUTABLE} build -buildmode=c-shared -buildvcs=false
         -o "${OUTPUT_LIB_DIR}/libtunnel.so"
         "${GO_SRC}"
         WORKING_DIRECTORY "${GO_SRC}"
diff --git a/android/vpnClient/src/main/java/org/mozilla/firefox/vpn/qt/VPNActivity.java b/android/vpnClient/src/main/java/org/mozilla/firefox/vpn/qt/VPNActivity.java
index 10dab870f7..fe989ba801 100644
--- a/android/vpnClient/src/main/java/org/mozilla/firefox/vpn/qt/VPNActivity.java
+++ b/android/vpnClient/src/main/java/org/mozilla/firefox/vpn/qt/VPNActivity.java
@@ -5,10 +5,12 @@
 package org.mozilla.firefox.vpn.qt;
 
 import android.app.Activity;
+import android.app.AlertDialog;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
+import android.content.SharedPreferences;
 import android.content.pm.ActivityInfo;
 import android.graphics.Insets;
 import android.net.Uri;
@@ -29,6 +31,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.nio.charset.StandardCharsets;
+import org.mozilla.firefox.qt.common.BatteryOptimizationHelper;
 import org.mozilla.firefox.vpn.VPNClientBinder;
 import org.mozilla.firefox.vpn.daemon.VPNService;
 import org.qtproject.qt.android.QtActivityBase;
@@ -58,7 +61,34 @@ public void onCreate(Bundle savedInstanceState) {
         setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
     }
     ready = true;
+    
+    // Check battery optimization when activity is created
+    checkAndWarnBatteryOptimization();
+  }
+  
+  @Override
+  protected void onResume() {
+    super.onResume();
+    
+    // Check battery optimization when activity resumes (after Activity is ready to show dialogs)
+    // Also check again when returning to app (user may have changed settings)
+    checkAndWarnBatteryOptimization();
+  }
+  
+  @Override
+  protected void onStart() {
+    super.onStart();
+    
+    // Also check when Activity starts (in case onResume wasn't called)
+    // Use postDelayed to ensure Activity is fully ready
+    getWindow().getDecorView().postDelayed(new Runnable() {
+      @Override
+      public void run() {
+        checkAndWarnBatteryOptimization();
+      }
+    }, 500); // Delay 500ms to ensure Activity is ready
   }
+  
   private static VPNActivity instance;
 
  public VPNActivity() {
@@ -348,4 +378,99 @@ protected void onNewIntent(Intent intent) {
   private static void nativeMethodsRegistered() {
     nativeMethodsAvailable = true;
   }
+  
+  // Constants for battery optimization warning
+  private static final String PREFS_NAME = "vpn_prefs";
+  private static final String PREF_BATTERY_WARNING_DISMISSED = "battery_optimization_warning_dismissed";
+  private static final String PREF_BATTERY_CHECK_SHOWN = "battery_optimization_check_shown";
+  private static final int REQUEST_CODE_BATTERY_SETTINGS = 1001;
+  
+  /**
+   * Check battery optimization status and show warning if needed.
+   * This method respects user preference if they dismissed the warning.
+   */
+  private void checkAndWarnBatteryOptimization() {
+    Log.i("VPNActivity", "checkAndWarnBatteryOptimization() called");
+    
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      // Battery optimization not available before Android M
+      Log.i("VPNActivity", "Battery optimization check skipped - Android < M");
+      return;
+    }
+    
+    SharedPreferences prefs = getSharedPreferences(PREFS_NAME, MODE_PRIVATE);
+    boolean warningDismissed = prefs.getBoolean(PREF_BATTERY_WARNING_DISMISSED, false);
+    boolean checkShown = prefs.getBoolean(PREF_BATTERY_CHECK_SHOWN, false);
+    
+    Log.i("VPNActivity", "Battery optimization check - warning dismissed: " + warningDismissed + ", check shown: " + checkShown);
+    
+    // Check if battery optimization is enabled
+    boolean isIgnoring = BatteryOptimizationHelper.isIgnoringBatteryOptimizations(this);
+    Log.i("VPNActivity", "Battery optimization status - isIgnoring: " + isIgnoring);
+    Log.i("VPNActivity", "Package name: " + getPackageName());
+    
+    // Show dialog if:
+    // 1. Battery optimization is ENABLED (not ignoring), OR
+    // 2. First time check and we have permission to request (proactive check)
+    boolean shouldShow = false;
+    
+    if (!isIgnoring) {
+      // Battery optimization is ENABLED - show warning
+      Log.i("VPNActivity", "Battery optimization is ENABLED - showing warning dialog");
+      shouldShow = true;
+    } else if (!checkShown && !warningDismissed && BatteryOptimizationHelper.hasRequestIgnoreBatteryOptimizationsPermission(this)) {
+      // First time - proactively show dialog to ensure battery optimization stays disabled
+      // Only if we have permission to request it
+      Log.i("VPNActivity", "First launch - proactively showing battery optimization dialog");
+      shouldShow = true;
+      prefs.edit().putBoolean(PREF_BATTERY_CHECK_SHOWN, true).apply();
+    }
+    
+    if (shouldShow && !warningDismissed) {
+      showBatteryOptimizationWarning();
+    } else if (!shouldShow) {
+      Log.i("VPNActivity", "Battery optimization is disabled - no warning needed");
+    }
+  }
+  
+  /**
+   * Show a dialog warning the user about battery optimization.
+   * Provides options to open settings, dismiss temporarily, or dismiss permanently.
+   */
+  private void showBatteryOptimizationWarning() {
+    new AlertDialog.Builder(this)
+        .setTitle("Battery Optimization Detected")
+        .setMessage(BatteryOptimizationHelper.getBatteryOptimizationExplanation())
+        .setPositiveButton("Open Settings", (dialog, which) -> {
+          Intent intent = BatteryOptimizationHelper.getRequestIgnoreBatteryOptimizationsIntent(this);
+          if (intent != null) {
+            try {
+              startActivityForResult(intent, REQUEST_CODE_BATTERY_SETTINGS);
+            } catch (Exception e) {
+              Log.e("VPNActivity", "Failed to open battery settings", e);
+            }
+          }
+        })
+        .setNegativeButton("Not Now", null)
+        .setNeutralButton("Don't Ask Again", (dialog, which) -> {
+          // Save preference to not ask again
+          SharedPreferences prefs = getSharedPreferences(PREFS_NAME, MODE_PRIVATE);
+          prefs.edit().putBoolean(PREF_BATTERY_WARNING_DISMISSED, true).apply();
+          Log.i("VPNActivity", "User dismissed battery optimization warning permanently");
+        })
+        .setCancelable(true)
+        .show();
+  }
+  
+  /**
+   * Allow users to reset the "Don't Ask Again" preference through settings.
+   * This method can be called from the native code if needed.
+   */
+  public static void resetBatteryOptimizationWarning() {
+    if (instance != null) {
+      SharedPreferences prefs = instance.getSharedPreferences(PREFS_NAME, MODE_PRIVATE);
+      prefs.edit().putBoolean(PREF_BATTERY_WARNING_DISMISSED, false).apply();
+      Log.i("VPNActivity", "Battery optimization warning preference reset");
+    }
+  }
 }
diff --git a/scripts/android/cmake.sh b/scripts/android/cmake.sh
index ffb829962d..9851faee27 100755
--- a/scripts/android/cmake.sh
+++ b/scripts/android/cmake.sh
@@ -147,6 +147,7 @@ cp $WORKSPACE_ROOT/qtglean/uniffi.toml 3rdparty/glean/glean-core/uniffi.toml
 if [[ "$RELEASE" ]]; then
   printn Y "Use release config"
   $QTPATH/bin/qt-cmake \
+    --warn-uninitialized \
     -DQT_HOST_PATH=$QT_HOST_PATH \
     -DQT_ANDROID_BUILD_ALL_ABIS=TRUE \
     -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
@@ -156,10 +157,11 @@ if [[ "$RELEASE" ]]; then
     -DADJUST_TOKEN=$ADJUST_SDK_TOKEN \
     -DBUILD_TESTS=OFF \
     -GNinja \
-    -S . -B .tmp/
+    -S . -B .tmp/ || die "CMake configuration failed - check for missing libraries or dependencies"
 else
   printn Y "Use debug config \n"
   $QTPATH/bin/qt-cmake \
+    --warn-uninitialized \
     -DQT_HOST_PATH=$QT_HOST_PATH \
     -DQT_ANDROID_BUILD_ALL_ABIS=FALSE \
     -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
@@ -168,7 +170,7 @@ else
     -DCMAKE_BUILD_TYPE=Debug \
     -DBUILD_TESTS=OFF \
     -GNinja \
-    -S . -B .tmp/
+    -S . -B .tmp/ || die "CMake configuration failed - check for missing libraries or dependencies"
 
 fi
 
@@ -179,7 +181,9 @@ cmake --build .tmp -j$JOBS
 # Generate a valid gradle project and pre-compile it.
 print Y "Generate Android Project"
 
-#androiddeployqt --input .tmp/src/android-mozillavpn-deployment-settings.json --output .tmp/src/android-build || cleanup_and_die
+# Note: androiddeployqt is already called automatically by qt_finalize_target during CMake build
+# It packages QML resources into assets/android_rcc_bundle.rcc (Qt 6 uses RCC bundle instead of qt.qml)
+# No need to call it again here
 
 cd .tmp/src/android-build/
 # This will combine the qt-libs + qt-resources and the client
diff --git a/src/commands/commandui.cpp b/src/commands/commandui.cpp
index 8deca15be5..2d52c30ae0 100644
--- a/src/commands/commandui.cpp
+++ b/src/commands/commandui.cpp
@@ -9,6 +9,7 @@
 
 #include <QQmlApplicationEngine>
 #include <QQmlContext>
+#include <QQmlError>
 #include <QWindow>
 #include <memory>
 
@@ -321,7 +322,6 @@ int CommandUI::run(QStringList& tokens) {
     if (!engineHolder->hasWindow()) {
       logger.error() << "Failed to load " << url.toString();
     }
-
 #ifdef MZ_WINDOWS
     auto const updateWindowDecoration = [engineHolder]() {
       auto const window = engineHolder->window();