Use scheduled task for start with system (#308)

Co-authored-by: Owen McGirr <o.a.mcgirr@gmail.com>

Author: enaboapps

src/SwitchifyPc.App/App.xaml.cs

@@ -74,7 +74,7 @@ protected override void OnStartup(StartupEventArgs e)
         updateService.StartAutomaticUpdateChecks();
         StartPairingExpiryTimer();
         _ = StartBluetoothAsync();
-        _ = RecordStartupDiagnosticsAsync(e.Args, launchOptions.StartHidden);
+        _ = InitializeStartupRegistrationAsync(e.Args, launchOptions.StartHidden);
         trayIcon = new NativeTrayIcon(
             ShowMainWindow,
             ShowSettingsWindow,
@@ -213,7 +213,8 @@ private SystemStartupService CreateStartupService()
             platform: "win32",
             isPackaged: IsInstalledApp(),
             executablePath: Environment.ProcessPath ?? string.Empty,
-            startupRegistry: new WindowsStartupRegistry(),
+            startupTask: new WindowsStartupTask(),
+            legacyStartupRegistry: new WindowsStartupRegistry(),
             startupCommandFor: WindowsStartupRegistry.StartupCommandFor);
     }
 
@@ -436,6 +437,26 @@ private void UpdateBluetoothState(BluetoothStatus status)
         Dispatcher.BeginInvoke(() => mainWindowViewModel.SetBluetoothState(desktopState, status));
     }
 
+    private async Task InitializeStartupRegistrationAsync(string[] argv, bool startHidden)
+    {
+        await RepairStartupRegistrationAsync();
+        await RecordStartupDiagnosticsAsync(argv, startHidden);
+    }
+
+    private async Task RepairStartupRegistrationAsync()
+    {
+        try
+        {
+            await CreateStartupService().RepairLegacyStartupRegistrationAsync();
+        }
+        catch (Exception error)
+        {
+            Console.WriteLine(string.IsNullOrWhiteSpace(error.Message)
+                ? "Could not repair startup registration."
+                : error.Message);
+        }
+    }
+
     private async Task RecordStartupDiagnosticsAsync(string[] argv, bool startHidden)
     {
         try
@@ -451,7 +472,8 @@ private async Task RecordStartupDiagnosticsAsync(string[] argv, bool startHidden
                     ExecutablePath: Environment.ProcessPath ?? string.Empty,
                     Argv: argv,
                     StartHidden: startHidden,
-                    StartupRegistration: JsonlDiagnostics.RegistrationFromSettings(startupSettings)));
+                    StartupRegistration: JsonlDiagnostics.RegistrationFromSettings(startupSettings),
+                    StartupTask: JsonlDiagnostics.TaskFromSettings(startupSettings)));
         }
         catch
         {

src/SwitchifyPc.Core/Diagnostics/JsonlDiagnostics.cs

@@ -12,13 +12,21 @@ public sealed record StartupDiagnosticsEntry(
     string ExecutablePath,
     IReadOnlyList<string> Argv,
     bool StartHidden,
-    StartupDiagnosticsRegistration? StartupRegistration = null);
+    StartupDiagnosticsRegistration? StartupRegistration = null,
+    StartupTaskDiagnostics? StartupTask = null);
 
 public sealed record StartupDiagnosticsRegistration(
     bool StartWithSystem,
     string? RegisteredCommand,
     string StartupApproved);
 
+public sealed record StartupTaskDiagnostics(
+    bool Exists,
+    bool Enabled,
+    string? RegisteredExecutablePath,
+    IReadOnlyList<string> RegisteredArguments,
+    string? LastRunResult);
+
 public sealed record UpdateInstallDiagnosticEntry(
     string Event,
     string At,
@@ -77,6 +85,18 @@ public static void AppendUpdateInstallDiagnostic(
                 settings.Registration.StartupApproved);
     }
 
+    public static StartupTaskDiagnostics? TaskFromSettings(SystemStartupSettings settings)
+    {
+        return settings.TaskRegistration is null
+            ? null
+            : new StartupTaskDiagnostics(
+                settings.TaskRegistration.Exists,
+                settings.TaskRegistration.Enabled,
+                settings.TaskRegistration.RegisteredExecutablePath,
+                settings.TaskRegistration.RegisteredArguments,
+                settings.TaskRegistration.LastRunResult);
+    }
+
     private static void AppendBounded(string filePath, IReadOnlyList<string> existing, string nextLine, int maxLines)
     {
         List<string> lines = [.. existing, nextLine];

src/SwitchifyPc.Core/Startup/SystemStartupService.cs

@@ -2,12 +2,23 @@ namespace SwitchifyPc.Core.Startup;
 
 public sealed record StartupRegistration(string ExpectedCommand, string? RegisteredCommand, string StartupApproved);
 
+public sealed record StartupTaskRegistration(
+    string TaskName,
+    bool Exists,
+    bool Enabled,
+    string ExpectedExecutablePath,
+    string? RegisteredExecutablePath,
+    IReadOnlyList<string> ExpectedArguments,
+    IReadOnlyList<string> RegisteredArguments,
+    string? LastRunResult);
+
 public sealed record SystemStartupSettings(
     bool Supported,
     bool StartWithSystem,
     bool StartsHidden,
     string? Reason,
-    StartupRegistration? Registration = null);
+    StartupRegistration? Registration = null,
+    StartupTaskRegistration? TaskRegistration = null);
 
 public interface IStartupRegistry
 {
@@ -18,6 +29,20 @@ public interface IStartupRegistry
 
 public sealed record StartupRegistrySnapshot(string? Command, string StartupApproved);
 
+public sealed record StartupTaskSnapshot(
+    bool Exists,
+    bool Enabled,
+    string? ExecutablePath,
+    IReadOnlyList<string> Arguments,
+    string? LastRunResult);
+
+public interface IStartupTask
+{
+    Task<StartupTaskSnapshot> GetAsync(string taskName);
+    Task SetAsync(string taskName, string executablePath, IReadOnlyList<string> args);
+    Task DeleteAsync(string taskName);
+}
+
 public interface ISystemStartupSettingsService
 {
     Task<SystemStartupSettings> GetSettingsAsync();
@@ -29,26 +54,30 @@ public sealed class SystemStartupService : ISystemStartupSettingsService
 {
     public const string StartHiddenArg = "--start-hidden";
     public const string StartupValueName = "app.switchify.pc";
+    public const string StartupTaskName = "Switchify PC";
 
     private readonly string platform;
     private readonly bool isPackaged;
     private readonly string executablePath;
-    private readonly IStartupRegistry startupRegistry;
+    private readonly IStartupTask startupTask;
+    private readonly IStartupRegistry legacyStartupRegistry;
     private readonly Func<string, IReadOnlyList<string>, string> startupCommandFor;
     private readonly Action<string> warn;
 
     public SystemStartupService(
         string platform,
         bool isPackaged,
         string executablePath,
-        IStartupRegistry startupRegistry,
+        IStartupTask startupTask,
+        IStartupRegistry legacyStartupRegistry,
         Func<string, IReadOnlyList<string>, string> startupCommandFor,
         Action<string>? warn = null)
     {
         this.platform = platform;
         this.isPackaged = isPackaged;
         this.executablePath = executablePath;
-        this.startupRegistry = startupRegistry;
+        this.startupTask = startupTask;
+        this.legacyStartupRegistry = legacyStartupRegistry;
         this.startupCommandFor = startupCommandFor;
         this.warn = warn ?? Console.WriteLine;
     }
@@ -63,30 +92,66 @@ public async Task<SystemStartupSettings> GetSettingsAsync()
         if (!IsSupported()) return UnsupportedSettings();
 
         string expectedCommand = ExpectedCommand();
+        IReadOnlyList<string> expectedArguments = [StartHiddenArg];
+        StartupTaskSnapshot task = await GetTaskSafelyAsync();
         StartupRegistrySnapshot entry = await GetRegistryEntrySafelyAsync();
+        bool taskMatches = IsHealthyTask(task, expectedArguments);
+
         return new SystemStartupSettings(
             Supported: true,
-            StartWithSystem: entry.Command == expectedCommand && entry.StartupApproved != "disabled",
+            StartWithSystem: taskMatches,
             StartsHidden: true,
             Reason: null,
-            Registration: new StartupRegistration(expectedCommand, entry.Command, entry.StartupApproved));
+            Registration: new StartupRegistration(expectedCommand, entry.Command, entry.StartupApproved),
+            TaskRegistration: new StartupTaskRegistration(
+                StartupTaskName,
+                task.Exists,
+                task.Enabled,
+                executablePath,
+                task.ExecutablePath,
+                expectedArguments,
+                task.Arguments,
+                task.LastRunResult));
     }
 
     public async Task<SystemStartupSettings> SetStartWithSystemAsync(bool enabled)
     {
         if (!IsSupported()) return UnsupportedSettings();
         if (enabled)
         {
-            await startupRegistry.SetEntryAsync(StartupValueName, ExpectedCommand());
+            await startupTask.SetAsync(StartupTaskName, executablePath, [StartHiddenArg]);
+            await DeleteLegacyRegistrySafelyAsync();
         }
         else
         {
-            await startupRegistry.DeleteEntryAsync(StartupValueName);
+            await startupTask.DeleteAsync(StartupTaskName);
+            await DeleteLegacyRegistrySafelyAsync();
         }
 
         return await GetSettingsAsync();
     }
 
+    public async Task RepairLegacyStartupRegistrationAsync()
+    {
+        if (!IsSupported()) return;
+
+        IReadOnlyList<string> expectedArguments = [StartHiddenArg];
+        StartupTaskSnapshot task = await GetTaskSafelyAsync();
+        StartupRegistrySnapshot legacy = await GetRegistryEntrySafelyAsync();
+
+        if (IsHealthyTask(task, expectedArguments))
+        {
+            await DeleteLegacyRegistrySafelyAsync();
+            return;
+        }
+
+        if (legacy.Command == ExpectedCommand() && legacy.StartupApproved != "disabled")
+        {
+            await startupTask.SetAsync(StartupTaskName, executablePath, expectedArguments);
+            await DeleteLegacyRegistrySafelyAsync();
+        }
+    }
+
     private bool IsSupported()
     {
         return platform == "win32" && isPackaged;
@@ -97,11 +162,32 @@ private string ExpectedCommand()
         return startupCommandFor(executablePath, [StartHiddenArg]);
     }
 
+    private bool IsHealthyTask(StartupTaskSnapshot task, IReadOnlyList<string> expectedArguments)
+    {
+        return task.Exists &&
+            task.Enabled &&
+            string.Equals(task.ExecutablePath, executablePath, StringComparison.Ordinal) &&
+            task.Arguments.SequenceEqual(expectedArguments, StringComparer.Ordinal);
+    }
+
+    private async Task<StartupTaskSnapshot> GetTaskSafelyAsync()
+    {
+        try
+        {
+            return await startupTask.GetAsync(StartupTaskName);
+        }
+        catch (Exception error)
+        {
+            warn(error.Message);
+            return new StartupTaskSnapshot(false, false, null, [], null);
+        }
+    }
+
     private async Task<StartupRegistrySnapshot> GetRegistryEntrySafelyAsync()
     {
         try
         {
-            return await startupRegistry.GetEntryAsync(StartupValueName);
+            return await legacyStartupRegistry.GetEntryAsync(StartupValueName);
         }
         catch (Exception error)
         {
@@ -110,6 +196,18 @@ private async Task<StartupRegistrySnapshot> GetRegistryEntrySafelyAsync()
         }
     }
 
+    private async Task DeleteLegacyRegistrySafelyAsync()
+    {
+        try
+        {
+            await legacyStartupRegistry.DeleteEntryAsync(StartupValueName);
+        }
+        catch (Exception error)
+        {
+            warn(error.Message);
+        }
+    }
+
     private SystemStartupSettings UnsupportedSettings()
     {
         return new SystemStartupSettings(

src/SwitchifyPc.Core/Ui/SettingsViewModel.cs

@@ -42,18 +42,25 @@ public string StartWithSystemMessage
                     : "Start with system is not available on this platform.";
             }
 
-            if (startupSettings.Registration?.StartupApproved == "disabled")
+            if (startupSettings.TaskRegistration is { Exists: true, Enabled: false })
             {
-                return "Start with system is disabled in Windows Startup settings.";
+                return "Start with system is disabled in Windows Task Scheduler.";
             }
 
             if (!startupSettings.StartWithSystem &&
-                !string.IsNullOrWhiteSpace(startupSettings.Registration?.RegisteredCommand) &&
-                startupSettings.Registration.RegisteredCommand != startupSettings.Registration.ExpectedCommand)
+                startupSettings.TaskRegistration is { Exists: true } taskRegistration &&
+                (!string.Equals(taskRegistration.RegisteredExecutablePath, taskRegistration.ExpectedExecutablePath, StringComparison.Ordinal) ||
+                 !taskRegistration.RegisteredArguments.SequenceEqual(taskRegistration.ExpectedArguments, StringComparer.Ordinal)))
             {
                 return "Start with system is registered to an older app path. Turn it off and on again to repair it.";
             }
 
+            if (!startupSettings.StartWithSystem &&
+                !string.IsNullOrWhiteSpace(startupSettings.Registration?.RegisteredCommand))
+            {
+                return "Start with system is using an older Windows startup registration. Turn it off and on again to repair it.";
+            }
+
             return startupSettings.StartWithSystem
                 ? "Switchify PC will start hidden when you sign in."
                 : "Switchify PC will not start when you sign in.";

src/SwitchifyPc.Tests/JsonlDiagnosticsTests.cs

@@ -23,6 +23,10 @@ public void AppendsStartupDiagnosticsEntry()
         Assert.Equal("0.2.0", root.GetProperty("version").GetString());
         Assert.True(root.GetProperty("startHidden").GetBoolean());
         Assert.True(root.GetProperty("startupRegistration").GetProperty("startWithSystem").GetBoolean());
+        Assert.True(root.GetProperty("startupTask").GetProperty("exists").GetBoolean());
+        Assert.True(root.GetProperty("startupTask").GetProperty("enabled").GetBoolean());
+        Assert.Equal("C:\\Program Files\\Switchify PC\\Switchify PC.exe", root.GetProperty("startupTask").GetProperty("registeredExecutablePath").GetString());
+        Assert.Equal("--start-hidden", root.GetProperty("startupTask").GetProperty("registeredArguments")[0].GetString());
     }
 
     [Fact]
@@ -143,6 +147,34 @@ public void RegistrationFromSettingsUsesNonSensitiveStartupFields()
         Assert.Equal("\"C:\\Program Files\\Switchify PC\\Switchify PC.exe\" --start-hidden", registration.RegisteredCommand);
     }
 
+    [Fact]
+    public void TaskFromSettingsUsesNonSensitiveStartupFields()
+    {
+        SystemStartupSettings settings = new(
+            Supported: true,
+            StartWithSystem: true,
+            StartsHidden: true,
+            Reason: null,
+            TaskRegistration: new StartupTaskRegistration(
+                TaskName: "Switchify PC",
+                Exists: true,
+                Enabled: true,
+                ExpectedExecutablePath: "C:\\Program Files\\Switchify PC\\Switchify PC.exe",
+                RegisteredExecutablePath: "C:\\Program Files\\Switchify PC\\Switchify PC.exe",
+                ExpectedArguments: ["--start-hidden"],
+                RegisteredArguments: ["--start-hidden"],
+                LastRunResult: "0"));
+
+        StartupTaskDiagnostics? task = JsonlDiagnostics.TaskFromSettings(settings);
+
+        Assert.NotNull(task);
+        Assert.True(task.Exists);
+        Assert.True(task.Enabled);
+        Assert.Equal("C:\\Program Files\\Switchify PC\\Switchify PC.exe", task.RegisteredExecutablePath);
+        Assert.Equal(["--start-hidden"], task.RegisteredArguments);
+        Assert.Equal("0", task.LastRunResult);
+    }
+
     public void Dispose()
     {
         if (Directory.Exists(tempDir))
@@ -164,7 +196,13 @@ private static StartupDiagnosticsEntry StartupEntry(string startedAt = "2026-06-
             StartupRegistration: new StartupDiagnosticsRegistration(
                 StartWithSystem: true,
                 RegisteredCommand: "\"C:\\Program Files\\Switchify PC\\Switchify PC.exe\" --start-hidden",
-                StartupApproved: "enabled"));
+                StartupApproved: "enabled"),
+            StartupTask: new StartupTaskDiagnostics(
+                Exists: true,
+                Enabled: true,
+                RegisteredExecutablePath: "C:\\Program Files\\Switchify PC\\Switchify PC.exe",
+                RegisteredArguments: ["--start-hidden"],
+                LastRunResult: "0"));
     }
 
     private static string[] ReadLines(string filePath)