More thoughts about startup task -- part 2: code form

src/cascadia/TerminalApp/AppLogic.cpp

@@ -363,11 +363,9 @@ namespace winrt::TerminalApp::implementation
             co_return;
         }
 
-
         const auto tryEnableStartupTask = _settings.GlobalSettings().StartOnUserLogin();
         const auto task = co_await StartupTask::GetAsync(StartupTaskName);
 
-        auto taskState = task.State();
         // If user has not set in json:
         //  If user has enabled in settings - enable in user settings
         //  If user has disabled in settings - disable in user settings (can this happen?)
@@ -386,26 +384,69 @@ namespace winrt::TerminalApp::implementation
         // if user goes from enabled to diabled, try to disable in settings
         // if user goes from disabled to enabled, try to enable in settings
         // can we detect if RequestEnable succeeded?
-        std::optional<bool> newFinalStartupTaskState;
-        std::optional<bool> newFinalUserSettingsValue;
+        auto appState{ ApplicationState::SharedInstance() };
+        std::optional<bool> userRequestedStartupTaskState;
+        if (_settings.GlobalSettings().HasStartOnUserLogin())
+        {
+            userRequestedStartupTaskState.emplace(_settings.GlobalSettings().StartOnUserLogin());
+        }
+
+        std::optional<bool> lastSyncedStartupTaskState;
+        if (appState.HasLastStartOnUserLoginStateSyncedWithOS())
+        {
+            lastSyncedStartupTaskState.emplace(appState.LastStartOnUserLoginStateSyncedWithOS());
+        }
 
-        switch (task.State())
+        if (userRequestedStartupTaskState == lastSyncedStartupTaskState)
         {
-        case StartupTaskState::Disabled:
-            if (tryEnableStartupTask)
+            // The user has not changed their state since we last checked (this could also indicate no state ever set);
+            // propagate changes from the OS down to the user settings file.
+            std::optional<bool> newFinalUserSettingsValue;
+            switch (task.State())
             {
-                co_await task.RequestEnableAsync();
+            case StartupTaskState::Enabled: // user or Terminal enabled it
+            case StartupTaskState::EnabledByPolicy: // policy enabled it globally
+                newFinalUserSettingsValue = true;
+                break;
+            case StartupTaskState::DisabledByPolicy: // policy disabled it globally
+            case StartupTaskState::DisabledByUser: // user turned it off in Task Manager
+                newFinalUserSettingsValue = false;
+                break;
+            case StartupTaskState::Disabled: // never set
+            default:
+                break;
+            }
+
+            if (newFinalUserSettingsValue.has_value())
+            {
+                _settings.GlobalSettings().StartOnUserLogin(*newFinalUserSettingsValue);
+                appState.LastStartOnUserLoginStateSyncedWithOS(*newFinalUserSettingsValue);
+                // TODO SAVE SETTINGS AND IGNORE NEXT RELOAD???
+            }
+        }
+        else
+        {
+            // The user changed their state since we last checked;
+            // propagate changes from the user up to the OS.
+            if (userRequestedStartupTaskState == true /* explicit comparison fails for nullopt */)
+            {
+                auto newState{ co_await task.RequestEnableAsync() };
+                if (newState != StartupTaskState::Enabled)
+                {
+                    // We could not enable it. It was disabled by policy. Disable it.
+                    _settings.GlobalSettings().StartOnUserLogin(false);
+                    appState.LastStartOnUserLoginStateSyncedWithOS(false);
+                }
+                else
+                {
+                    appState.LastStartOnUserLoginStateSyncedWithOS(true);
+                }
             }
-            break;
-        case StartupTaskState::DisabledByUser:
-            // TODO: GH#6254: define UX for other StartupTaskStates
-            break;
-        case StartupTaskState::Enabled:
-            if (!tryEnableStartupTask)
+            else if (userRequestedStartupTaskState == false /* explicit comparison fails for nullopt */)
             {
                 task.Disable();
+                appState.LastStartOnUserLoginStateSyncedWithOS(false);
             }
-            break;
         }
     }
     CATCH_LOG();

src/cascadia/TerminalSettingsModel/ApplicationState.cpp

@@ -330,7 +330,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
     MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
 #undef MTSM_APPLICATION_STATE_GEN
 
-    bool ApplicationState::HasLastStartOnUserloginStateSyncedWithOS() const noexcept
+    bool ApplicationState::HasLastStartOnUserLoginStateSyncedWithOS() const noexcept
     {
         const auto state = _state.lock_shared();
         return state->LastStartOnUserLoginStateSyncedWithOS.has_value();

src/cascadia/TerminalSettingsModel/ApplicationState.h

@@ -79,7 +79,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         MTSM_APPLICATION_STATE_FIELDS(MTSM_APPLICATION_STATE_GEN)
 #undef MTSM_APPLICATION_STATE_GEN
 
-        bool HasLastStartOnUserloginStateSyncedWithOS() const noexcept;
+        bool HasLastStartOnUserLoginStateSyncedWithOS() const noexcept;
 
     private:
         struct state_t

src/cascadia/TerminalSettingsModel/ApplicationState.idl

@@ -40,7 +40,7 @@ namespace Microsoft.Terminal.Settings.Model
         Windows.Foundation.Collections.IVector<InfoBarMessage> DismissedMessages;
         Windows.Foundation.Collections.IVector<String> AllowedCommandlines;
 
-        Boolean LastStartOnUserloginStateSyncedWithOS;
-        Boolean HasLastStartOnUserloginStateSyncedWithOS();
+        Boolean LastStartOnUserLoginStateSyncedWithOS;
+        Boolean HasLastStartOnUserLoginStateSyncedWithOS();
     }
 }