feat: add Windows enable mode (#21)

Currently we try to enable the auto launch dynamically (system-wide first if we have admin privileges, with a fallback to current user). In some cases it might make sense to configure this behavior though - for instance when the app is installed to the current user only, and you want to avoid the local machine registry.

Author: lucasfernog

src/lib.rs

@@ -62,7 +62,12 @@
 //!
 //! ### Windows
 //!
-//! On Windows, it will add a registry entry under `\HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Run`.
+//! On Windows, it will add a registry entry under either `\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run` (system-wide) or
+//! `\HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Run` (current user only).
+//!
+//! By default we try to apply the auto launch to the system registry, which requires admin privileges and applies the auto launch to any user in the system.
+//! If there's no permission to do so, we fallback to enabling it to the current user only.
+//! To change this behavior, you can use [`AutoLaunch::set_windows_enable_mode`].
 //!
 //! ```rust
 //! # #[cfg(target_os = "windows")]
@@ -192,6 +197,9 @@ pub struct AutoLaunch {
     /// Whether use Launch Agent for implement or use AppleScript
     pub(crate) use_launch_agent: bool,
 
+    #[cfg(windows)]
+    pub(crate) enable_mode: WindowsEnableMode,
+
     /// Args passed to the binary on startup
     pub(crate) args: Vec<String>,
 }
@@ -266,9 +274,29 @@ pub struct AutoLaunchBuilder {
 
     pub use_launch_agent: bool,
 
+    pub windows_enable_mode: WindowsEnableMode,
+
     pub args: Option<Vec<String>>,
 }
 
+/// Determines how the auto launch is enabled on Windows.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WindowsEnableMode {
+    /// Dynamically tries to enable the auto launch for the system (admin privileges required),
+    /// fallbacks to the current user if there is no permission to modify the system registry.
+    Dynamic,
+    /// Enables the auto launch for the current user only. Does not require admin permissions.
+    CurrentUser,
+    /// Enables the auto launch for all users. Requires admin permissions.
+    System,
+}
+
+impl Default for WindowsEnableMode {
+    fn default() -> Self {
+        Self::Dynamic
+    }
+}
+
 impl AutoLaunchBuilder {
     pub fn new() -> AutoLaunchBuilder {
         AutoLaunchBuilder::default()
@@ -293,6 +321,13 @@ impl AutoLaunchBuilder {
         self
     }
 
+    /// Set the [`WindowsEnableMode`].
+    /// This setting only works on Windows
+    pub fn set_windows_enable_mode(&mut self, mode: WindowsEnableMode) -> &mut Self {
+        self.windows_enable_mode = mode;
+        self
+    }
+
     /// Set the args
     pub fn set_args(&mut self, args: &[impl AsRef<str>]) -> &mut Self {
         self.args = Some(args.iter().map(|s| s.as_ref().to_string()).collect());
@@ -324,7 +359,12 @@ impl AutoLaunchBuilder {
             &args,
         ));
         #[cfg(target_os = "windows")]
-        return Ok(AutoLaunch::new(app_name, app_path, &args));
+        return Ok(AutoLaunch::new(
+            app_name,
+            app_path,
+            self.windows_enable_mode,
+            &args,
+        ));
 
         #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
         return Err(Error::UnsupportedOS);

src/windows.rs

@@ -1,4 +1,4 @@
-use crate::{AutoLaunch, Result};
+use crate::{AutoLaunch, Result, WindowsEnableMode};
 use windows_registry::{Key, CURRENT_USER, LOCAL_MACHINE};
 use windows_result::HRESULT;
 
@@ -19,15 +19,22 @@ impl AutoLaunch {
     /// Create a new AutoLaunch instance
     /// - `app_name`: application name
     /// - `app_path`: application path
+    /// - `enable_mode`: behavior of the enable feature
     /// - `args`: startup args passed to the binary
     ///
     /// ## Notes
     ///
     /// The parameters of `AutoLaunch::new` are different on each platform.
-    pub fn new(app_name: &str, app_path: &str, args: &[impl AsRef<str>]) -> AutoLaunch {
+    pub fn new(
+        app_name: &str,
+        app_path: &str,
+        enable_mode: WindowsEnableMode,
+        args: &[impl AsRef<str>],
+    ) -> AutoLaunch {
         AutoLaunch {
             app_name: app_name.into(),
             app_path: app_path.into(),
+            enable_mode,
             args: args.iter().map(|s| s.as_ref().to_string()).collect(),
         }
     }
@@ -39,15 +46,22 @@ impl AutoLaunch {
     /// - failed to open the registry key
     /// - failed to set value
     pub fn enable(&self) -> Result<()> {
-        self.enable_as_admin()
-            .or_else(|e| {
-                if e.code() == E_ACCESSDENIED {
-                    self.enable_as_current_user()
-                } else {
-                    Err(e)
-                }
-            })
-            .map_err(std::io::Error::from)?;
+        match self.enable_mode {
+            WindowsEnableMode::Dynamic => self
+                .enable_as_admin()
+                .or_else(|e| {
+                    if e.code() == E_ACCESSDENIED {
+                        self.enable_as_current_user()
+                    } else {
+                        Err(e)
+                    }
+                })
+                .map_err(std::io::Error::from)?,
+            WindowsEnableMode::CurrentUser => self
+                .enable_as_current_user()
+                .map_err(std::io::Error::from)?,
+            WindowsEnableMode::System => self.enable_as_admin().map_err(std::io::Error::from)?,
+        }
         Ok(())
     }
 
@@ -90,16 +104,21 @@ impl AutoLaunch {
     /// - failed to open the registry key
     /// - failed to delete value
     pub fn disable(&self) -> Result<()> {
-        self.disable_as_admin()
-            .or_else(|e| {
-                if e.code() == E_ACCESSDENIED {
-                    self.disable_as_current_user()
-                } else {
-                    Err(e)
-                }
-            })
-            .map_err(std::io::Error::from)?;
-        Ok(())
+        // try to delete both admin and current user registry values
+        match self.disable_as_admin() {
+            Ok(()) => {
+                // try to delete for current user aswell, ignoring errors
+                // this is useful in case the app was previously registered as a system-wide auto launch
+                // but changed to a current user only mode
+                let _ = self.disable_as_current_user();
+                Ok(())
+            }
+            Err(_e) => {
+                self.disable_as_current_user()
+                    .map_err(std::io::Error::from)?;
+                Ok(())
+            }
+        }
     }
 
     fn disable_as_admin(&self) -> windows_registry::Result<()> {
@@ -118,14 +137,18 @@ impl AutoLaunch {
 
     /// Check whether the AutoLaunch setting is enabled
     pub fn is_enabled(&self) -> Result<bool> {
-        let res = match self.is_enabled_as_admin() {
-            Ok(false) => self.is_enabled_as_current_user(),
-            Err(e) if e.code() == E_ACCESSDENIED => self.is_enabled_as_current_user(),
-            Ok(enabled) => Ok(enabled),
-            Err(e) => Err(e),
+        match self.enable_mode {
+            WindowsEnableMode::Dynamic => match self.is_enabled_as_admin() {
+                Ok(false) => self.is_enabled_as_current_user(),
+                Err(e) if e.code() == E_ACCESSDENIED => self.is_enabled_as_current_user(),
+                Ok(enabled) => Ok(enabled),
+                Err(e) => Err(e),
+            },
+            WindowsEnableMode::CurrentUser => self.is_enabled_as_current_user(),
+            WindowsEnableMode::System => self.is_enabled_as_admin(),
         }
-        .map_err(std::io::Error::from)?;
-        Ok(res)
+        .map_err(std::io::Error::from)
+        .map_err(Into::into)
     }
 
     fn is_enabled_as_admin(&self) -> windows_registry::Result<bool> {