[Light Switch] Follow Night Light mode (#43683)

<!-- Enter a brief description/summary of your PR here. What does it
fix/what does it change/how was it tested (even manually, if necessary)?
-->
## Summary of the Pull Request
Introduces a new mode that will have Light Switch follow Windows Night
Light.

<!-- Please review the items on the PR checklist before submitting-->
## PR Checklist

- [x] Closes: https://github.com/microsoft/PowerToys/issues/42457
- [x] **Communication:** I've discussed this with core contributors
already. If the work hasn't been agreed, this work might be rejected
- [ ] **Tests:** Added/updated and all pass
- [x] **Localization:** All end-user-facing strings can be localized
- [ ] **Documentation updated:** If checked, please file a pull request
on [our docs
repo](https://github.com/MicrosoftDocs/windows-uwp/tree/docs/hub/powertoys)
and link it here: #xxx

<!-- Provide a more detailed description of the PR, other things fixed,
or any additional comments/features here -->
## Detailed Description of the Pull Request / Additional comments
Strictly follows the state of Night Light. When NL is on, LS will be
switch to dark mode and when NL is off, LS will switch to light mode
(with respect to the users system/app selection).

<!-- Describe how you validated the behavior. Add automated tests
wherever possible, but list manual validation steps taken as well -->
## Validation Steps Performed
Turn on Follow Night Light mode
Change night light!

## Notes

src/modules/LightSwitch/LightSwitchModuleInterface/dllmain.cpp

@@ -50,6 +50,7 @@ enum class ScheduleMode
     Off,
     FixedHours,
     SunsetToSunrise,
+    FollowNightLight,
     // add more later
 };
 
@@ -61,6 +62,8 @@ inline std::wstring ToString(ScheduleMode mode)
         return L"SunsetToSunrise";
     case ScheduleMode::FixedHours:
         return L"FixedHours";
+    case ScheduleMode::FollowNightLight:
+        return L"FollowNightLight";
     default:
         return L"Off";
     }
@@ -72,6 +75,8 @@ inline ScheduleMode FromString(const std::wstring& str)
         return ScheduleMode::SunsetToSunrise;
     if (str == L"FixedHours")
         return ScheduleMode::FixedHours;
+    if (str == L"FollowNightLight")
+        return ScheduleMode::FollowNightLight;
     return ScheduleMode::Off;
 }
 
@@ -167,7 +172,9 @@ public:
             ToString(g_settings.m_scheduleMode),
             { { L"Off", L"Disable the schedule" },
               { L"FixedHours", L"Set hours manually" },
-              { L"SunsetToSunrise", L"Use sunrise/sunset times" } });
+              { L"SunsetToSunrise", L"Use sunrise/sunset times" },
+              { L"FollowNightLight", L"Follow Windows Night Light state" }
+            });
 
         // Integer spinners
         settings.add_int_spinner(

src/modules/LightSwitch/LightSwitchService/LightSwitchService.cpp

@@ -13,10 +13,12 @@
 #include <utils/logger_helper.h>
 #include "LightSwitchStateManager.h"
 #include <LightSwitchUtils.h>
+#include <NightLightRegistryObserver.h>
 
 SERVICE_STATUS g_ServiceStatus = {};
 SERVICE_STATUS_HANDLE g_StatusHandle = nullptr;
 HANDLE g_ServiceStopEvent = nullptr;
+static LightSwitchStateManager* g_stateManagerPtr = nullptr;
 
 VOID WINAPI ServiceMain(DWORD argc, LPTSTR* argv);
 VOID WINAPI ServiceCtrlHandler(DWORD dwCtrl);
@@ -168,7 +170,15 @@ static void DetectAndHandleExternalThemeChange(LightSwitchStateManager& stateMan
     }
 
     // Use shared helper (handles wraparound logic)
-    bool shouldBeLight = ShouldBeLight(nowMinutes, effectiveLight, effectiveDark);
+    bool shouldBeLight = false;
+    if (s.scheduleMode == ScheduleMode::FollowNightLight)
+    {
+        shouldBeLight = !IsNightLightEnabled();
+    } 
+    else
+    {
+        shouldBeLight = ShouldBeLight(nowMinutes, effectiveLight, effectiveDark);
+    }
 
     // Compare current system/apps theme
     bool currentSystemLight = GetCurrentSystemTheme();
@@ -199,15 +209,40 @@ DWORD WINAPI ServiceWorkerThread(LPVOID lpParam)
     // Initialization
     // ────────────────────────────────────────────────────────────────
     static LightSwitchStateManager stateManager;
+    g_stateManagerPtr = &stateManager;
 
     LightSwitchSettings::instance().InitFileWatcher();
 
     HANDLE hManualOverride = OpenEventW(SYNCHRONIZE | EVENT_MODIFY_STATE, FALSE, L"POWERTOYS_LIGHTSWITCH_MANUAL_OVERRIDE");
     HANDLE hSettingsChanged = LightSwitchSettings::instance().GetSettingsChangedEvent();
 
+    static std::unique_ptr<NightLightRegistryObserver> g_nightLightWatcher;
+
     LightSwitchSettings::instance().LoadSettings();
     const auto& settings = LightSwitchSettings::instance().settings();
 
+    // after loading settings:
+    bool nightLightNeeded = (settings.scheduleMode == ScheduleMode::FollowNightLight);
+
+    if (nightLightNeeded && !g_nightLightWatcher)
+    {
+        Logger::info(L"[LightSwitchService] Starting Night Light registry watcher...");
+
+        g_nightLightWatcher = std::make_unique<NightLightRegistryObserver>(
+            HKEY_CURRENT_USER,
+            NIGHT_LIGHT_REGISTRY_PATH,
+            []() {
+                if (g_stateManagerPtr)
+                    g_stateManagerPtr->OnNightLightChange();
+            });
+    }
+    else if (!nightLightNeeded && g_nightLightWatcher)
+    {
+        Logger::info(L"[LightSwitchService] Stopping Night Light registry watcher...");
+        g_nightLightWatcher->Stop();
+        g_nightLightWatcher.reset();
+    }
+
     SYSTEMTIME st;
     GetLocalTime(&st);
     int nowMinutes = st.wHour * 60 + st.wMinute;
@@ -274,6 +309,31 @@ DWORD WINAPI ServiceWorkerThread(LPVOID lpParam)
             ResetEvent(hSettingsChanged);
             LightSwitchSettings::instance().LoadSettings();
             stateManager.OnSettingsChanged();
+
+            const auto& settings = LightSwitchSettings::instance().settings();
+            bool nightLightNeeded = (settings.scheduleMode == ScheduleMode::FollowNightLight);
+
+            if (nightLightNeeded && !g_nightLightWatcher)
+            {
+                Logger::info(L"[LightSwitchService] Starting Night Light registry watcher...");
+
+                g_nightLightWatcher = std::make_unique<NightLightRegistryObserver>(
+                    HKEY_CURRENT_USER,
+                    NIGHT_LIGHT_REGISTRY_PATH,
+                    []() {
+                        if (g_stateManagerPtr)
+                            g_stateManagerPtr->OnNightLightChange();
+                    });
+
+                stateManager.OnNightLightChange();
+            }
+            else if (!nightLightNeeded && g_nightLightWatcher)
+            {
+                Logger::info(L"[LightSwitchService] Stopping Night Light registry watcher...");
+                g_nightLightWatcher->Stop();
+                g_nightLightWatcher.reset();
+            }
+
             continue;
         }
     }
@@ -285,6 +345,11 @@ DWORD WINAPI ServiceWorkerThread(LPVOID lpParam)
         CloseHandle(hManualOverride);
     if (hParent)
         CloseHandle(hParent);
+    if (g_nightLightWatcher)
+    {
+        g_nightLightWatcher->Stop();
+        g_nightLightWatcher.reset();
+    }
 
     Logger::info(L"[LightSwitchService] Worker thread exiting cleanly.");
     return 0;

src/modules/LightSwitch/LightSwitchService/LightSwitchService.vcxproj

@@ -76,6 +76,7 @@
     <ClCompile Include="LightSwitchService.cpp" />
     <ClCompile Include="LightSwitchSettings.cpp" />
     <ClCompile Include="LightSwitchStateManager.cpp" />
+    <ClCompile Include="NightLightRegistryObserver.cpp" />
     <ClCompile Include="SettingsConstants.cpp" />
     <ClCompile Include="ThemeHelper.cpp" />
     <ClCompile Include="ThemeScheduler.cpp" />
@@ -88,6 +89,7 @@
     <ClInclude Include="LightSwitchSettings.h" />
     <ClInclude Include="LightSwitchStateManager.h" />
     <ClInclude Include="LightSwitchUtils.h" />
+    <ClInclude Include="NightLightRegistryObserver.h" />
     <ClInclude Include="SettingsConstants.h" />
     <ClInclude Include="SettingsObserver.h" />
     <ClInclude Include="ThemeHelper.h" />

src/modules/LightSwitch/LightSwitchService/LightSwitchService.vcxproj.filters

@@ -36,6 +36,9 @@
     <ClCompile Include="LightSwitchStateManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="NightLightRegistryObserver.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="ThemeScheduler.h">
@@ -62,6 +65,9 @@
     <ClInclude Include="LightSwitchUtils.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="NightLightRegistryObserver.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Natvis Include="$(MSBuildThisFileDirectory)..\..\natvis\wil.natvis" />

src/modules/LightSwitch/LightSwitchService/LightSwitchSettings.h

@@ -19,7 +19,8 @@ enum class ScheduleMode
 {
     Off,
     FixedHours,
-    SunsetToSunrise
+    SunsetToSunrise,
+    FollowNightLight,
     // Add more in the future
 };
 
@@ -31,6 +32,8 @@ inline std::wstring ToString(ScheduleMode mode)
         return L"FixedHours";
     case ScheduleMode::SunsetToSunrise:
         return L"SunsetToSunrise";
+    case ScheduleMode::FollowNightLight:
+        return L"FollowNightLight";
     default:
         return L"Off";
     }
@@ -42,6 +45,8 @@ inline ScheduleMode FromString(const std::wstring& str)
         return ScheduleMode::SunsetToSunrise;
     if (str == L"FixedHours")
         return ScheduleMode::FixedHours;
+    if (str == L"FollowNightLight")
+        return ScheduleMode::FollowNightLight;
     else
         return ScheduleMode::Off;
 }

src/modules/LightSwitch/LightSwitchService/LightSwitchStateManager.cpp

@@ -31,7 +31,10 @@ void LightSwitchStateManager::OnSettingsChanged()
 void LightSwitchStateManager::OnTick(int currentMinutes)
 {
     std::lock_guard<std::mutex> lock(_stateMutex);
-    EvaluateAndApplyIfNeeded();
+    if (_state.lastAppliedMode != ScheduleMode::FollowNightLight)
+    {
+        EvaluateAndApplyIfNeeded();
+    }
 }
 
 // Called when manual override is triggered
@@ -49,8 +52,38 @@ void LightSwitchStateManager::OnManualOverride()
         _state.isAppsLightActive = GetCurrentAppsTheme();
 
         Logger::debug(L"[LightSwitchStateManager] Synced internal theme state to current system theme ({}) and apps theme ({}).",
-                     (_state.isSystemLightActive ? L"light" : L"dark"),
-                     (_state.isAppsLightActive ? L"light" : L"dark"));
+                      (_state.isSystemLightActive ? L"light" : L"dark"),
+                      (_state.isAppsLightActive ? L"light" : L"dark"));
+    }
+
+    EvaluateAndApplyIfNeeded();
+}
+
+// Runs with the registry observer detects a change in Night Light settings.
+void LightSwitchStateManager::OnNightLightChange()
+{
+    std::lock_guard<std::mutex> lock(_stateMutex);
+
+    bool newNightLightState = IsNightLightEnabled();
+
+    // In Follow Night Light mode, treat a Night Light toggle as a boundary
+    if (_state.lastAppliedMode == ScheduleMode::FollowNightLight && _state.isManualOverride)
+    {
+        Logger::info(L"[LightSwitchStateManager] Night Light changed while manual override active; "
+                     L"treating as a boundary and clearing manual override.");
+        _state.isManualOverride = false;
+    }
+
+    if (newNightLightState != _state.isNightLightActive)
+    {
+        Logger::info(L"[LightSwitchStateManager] Night Light toggled to {}",
+                     newNightLightState ? L"ON" : L"OFF");
+
+        _state.isNightLightActive = newNightLightState;
+    }
+    else
+    {
+        Logger::debug(L"[LightSwitchStateManager] Night Light change event fired, but no actual change.");
     }
 
     EvaluateAndApplyIfNeeded();
@@ -77,9 +110,9 @@ void LightSwitchStateManager::SyncInitialThemeState()
     _state.isSystemLightActive = GetCurrentSystemTheme();
     _state.isAppsLightActive = GetCurrentAppsTheme();
     Logger::debug(L"[LightSwitchStateManager] Synced initial state to current system theme ({})",
-                 _state.isSystemLightActive ? L"light" : L"dark");
+                  _state.isSystemLightActive ? L"light" : L"dark");
     Logger::debug(L"[LightSwitchStateManager] Synced initial state to current apps theme ({})",
-                 _state.isAppsLightActive ? L"light" : L"dark");
+                  _state.isAppsLightActive ? L"light" : L"dark");
 }
 
 static std::pair<int, int> update_sun_times(auto& settings)
@@ -194,7 +227,15 @@ void LightSwitchStateManager::EvaluateAndApplyIfNeeded()
 
     _state.lastAppliedMode = _currentSettings.scheduleMode;
 
-    bool shouldBeLight = ShouldBeLight(now, _state.effectiveLightMinutes, _state.effectiveDarkMinutes);
+    bool shouldBeLight = false;
+    if (_currentSettings.scheduleMode == ScheduleMode::FollowNightLight)
+    {
+        shouldBeLight = !_state.isNightLightActive;
+    }
+    else
+    {
+        shouldBeLight = ShouldBeLight(now, _state.effectiveLightMinutes, _state.effectiveDarkMinutes);
+    }
 
     bool appsNeedsToChange = _currentSettings.changeApps && (_state.isAppsLightActive != shouldBeLight);
     bool systemNeedsToChange = _currentSettings.changeSystem && (_state.isSystemLightActive != shouldBeLight);
@@ -227,6 +268,3 @@ void LightSwitchStateManager::EvaluateAndApplyIfNeeded()
 
     _state.lastTickMinutes = now;
 }
-
-
-

src/modules/LightSwitch/LightSwitchService/LightSwitchStateManager.h

@@ -9,6 +9,7 @@ struct LightSwitchState
     bool isManualOverride = false;
     bool isSystemLightActive = false;
     bool isAppsLightActive = false;
+    bool isNightLightActive = false;
     int lastEvaluatedDay = -1;
     int lastTickMinutes = -1;
 
@@ -32,6 +33,9 @@ public:
     // Called when manual override is toggled (via shortcut or system change).
     void OnManualOverride();
 
+    // Called when night light changes in windows settings
+    void OnNightLightChange();
+
     // Initial sync at startup to align internal state with system theme
     void SyncInitialThemeState();
 

src/modules/LightSwitch/LightSwitchService/NightLightRegistryObserver.cpp

@@ -0,0 +1 @@
+#include "NightLightRegistryObserver.h"

src/modules/LightSwitch/LightSwitchService/NightLightRegistryObserver.h

@@ -0,0 +1,134 @@
+#pragma once
+#include <wtypes.h>
+#include <string>
+#include <functional>
+#include <thread>
+#include <atomic>
+#include <mutex>
+
+class NightLightRegistryObserver
+{
+public:
+    NightLightRegistryObserver(HKEY root, const std::wstring& subkey, std::function<void()> callback) :
+        _root(root), _subkey(subkey), _callback(std::move(callback)), _stop(false)
+    {
+        _thread = std::thread([this]() { this->Run(); });
+    }
+
+    ~NightLightRegistryObserver()
+    {
+        Stop();
+    }
+
+    void Stop()
+    {
+        _stop = true;
+
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            if (_event)
+                SetEvent(_event);
+        }
+
+        if (_thread.joinable())
+            _thread.join();
+
+        std::lock_guard<std::mutex> lock(_mutex);
+        if (_hKey)
+        {
+            RegCloseKey(_hKey);
+            _hKey = nullptr;
+        }
+
+        if (_event)
+        {
+            CloseHandle(_event);
+            _event = nullptr;
+        }
+    }
+
+
+private:
+    void Run()
+    {
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            if (RegOpenKeyExW(_root, _subkey.c_str(), 0, KEY_NOTIFY, &_hKey) != ERROR_SUCCESS)
+                return;
+
+            _event = CreateEventW(nullptr, TRUE, FALSE, nullptr);
+            if (!_event)
+            {
+                RegCloseKey(_hKey);
+                _hKey = nullptr;
+                return;
+            }
+        }
+
+        while (!_stop)
+        {
+            HKEY hKeyLocal = nullptr;
+            HANDLE eventLocal = nullptr;
+
+            {
+                std::lock_guard<std::mutex> lock(_mutex);
+                if (_stop)
+                    break;
+
+                hKeyLocal = _hKey;
+                eventLocal = _event;
+            }
+
+            if (!hKeyLocal || !eventLocal)
+                break;
+
+            if (_stop)
+                break;
+
+            if (RegNotifyChangeKeyValue(hKeyLocal, FALSE, REG_NOTIFY_CHANGE_LAST_SET, eventLocal, TRUE) != ERROR_SUCCESS)
+                break;
+
+            DWORD wait = WaitForSingleObject(eventLocal, INFINITE);
+            if (_stop || wait == WAIT_FAILED)
+                break;
+
+            ResetEvent(eventLocal);
+
+            if (!_stop && _callback)
+            {
+                try
+                {
+                    _callback();
+                }
+                catch (...)
+                {
+                }
+            }
+        }
+
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            if (_hKey)
+            {
+                RegCloseKey(_hKey);
+                _hKey = nullptr;
+            }
+
+            if (_event)
+            {
+                CloseHandle(_event);
+                _event = nullptr;
+            }
+        }
+    }
+
+
+    HKEY _root;
+    std::wstring _subkey;
+    std::function<void()> _callback;
+    HANDLE _event = nullptr;
+    HKEY _hKey = nullptr;
+    std::thread _thread;
+    std::atomic<bool> _stop;
+    std::mutex _mutex;
+};

src/modules/LightSwitch/LightSwitchService/SettingsConstants.h

@@ -11,4 +11,7 @@ enum class SettingId
     Sunset_Offset,
     ChangeSystem,
     ChangeApps
-};
+};
+
+constexpr wchar_t PERSONALIZATION_REGISTRY_PATH[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize";
+constexpr wchar_t NIGHT_LIGHT_REGISTRY_PATH[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\CloudStore\\Store\\DefaultAccount\\Current\\default$windows.data.bluelightreduction.bluelightreductionstate\\windows.data.bluelightreduction.bluelightreductionstate";

src/modules/LightSwitch/LightSwitchService/ThemeHelper.cpp

@@ -3,6 +3,7 @@
 #include <logger/logger.h>
 #include <utils/logger_helper.h>
 #include "ThemeHelper.h"
+#include <SettingsConstants.h>
 
 // Controls changing the themes.
 
@@ -10,7 +11,7 @@ static void ResetColorPrevalence()
 {
     HKEY hKey;
     if (RegOpenKeyEx(HKEY_CURRENT_USER,
-                     L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
+                     PERSONALIZATION_REGISTRY_PATH,
                      0,
                      KEY_SET_VALUE,
                      &hKey) == ERROR_SUCCESS)
@@ -31,7 +32,7 @@ void SetAppsTheme(bool mode)
 {
     HKEY hKey;
     if (RegOpenKeyEx(HKEY_CURRENT_USER,
-                     L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
+                     PERSONALIZATION_REGISTRY_PATH,
                      0,
                      KEY_SET_VALUE,
                      &hKey) == ERROR_SUCCESS)
@@ -50,7 +51,7 @@ void SetSystemTheme(bool mode)
 {
     HKEY hKey;
     if (RegOpenKeyEx(HKEY_CURRENT_USER,
-                     L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
+                     PERSONALIZATION_REGISTRY_PATH,
                      0,
                      KEY_SET_VALUE,
                      &hKey) == ERROR_SUCCESS)
@@ -79,7 +80,7 @@ bool GetCurrentSystemTheme()
     DWORD size = sizeof(value);
 
     if (RegOpenKeyEx(HKEY_CURRENT_USER,
-                     L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
+                     PERSONALIZATION_REGISTRY_PATH,
                      0,
                      KEY_READ,
                      &hKey) == ERROR_SUCCESS)
@@ -98,7 +99,7 @@ bool GetCurrentAppsTheme()
     DWORD size = sizeof(value);
 
     if (RegOpenKeyEx(HKEY_CURRENT_USER,
-                     L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
+                     PERSONALIZATION_REGISTRY_PATH,
                      0,
                      KEY_READ,
                      &hKey) == ERROR_SUCCESS)
@@ -109,3 +110,30 @@ bool GetCurrentAppsTheme()
 
     return value == 1; // true = light, false = dark
 }
+
+bool IsNightLightEnabled()
+{
+    HKEY hKey;
+    const wchar_t* path = NIGHT_LIGHT_REGISTRY_PATH;
+
+    if (RegOpenKeyExW(HKEY_CURRENT_USER, path, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
+        return false;
+
+    // RegGetValueW will set size to the size of the data and we expect that to be at least 25 bytes (we need to access bytes 23 and 24)
+    DWORD size = 0;
+    if (RegGetValueW(hKey, nullptr, L"Data", RRF_RT_REG_BINARY, nullptr, nullptr, &size) != ERROR_SUCCESS || size < 25)
+    {
+        RegCloseKey(hKey);
+        return false;
+    }
+
+    std::vector<BYTE> data(size);
+    if (RegGetValueW(hKey, nullptr, L"Data", RRF_RT_REG_BINARY, nullptr, data.data(), &size) != ERROR_SUCCESS)
+    {
+        RegCloseKey(hKey);
+        return false;
+    }
+
+    RegCloseKey(hKey);
+    return data[23] == 0x10 && data[24] == 0x00;
+}

src/modules/LightSwitch/LightSwitchService/ThemeHelper.h

@@ -3,3 +3,4 @@ void SetSystemTheme(bool dark);
 void SetAppsTheme(bool dark);
 bool GetCurrentSystemTheme();
 bool GetCurrentAppsTheme();
+bool IsNightLightEnabled();