[KBM] Migrate Engine and Editor into separate processes (#10774)

* Move KBM engine into separate process (#10672) * [KBM] Migrate KBM UI out of the runner (#10709) * Clean up keyboard hook handles (#10817) * [C++ common] Unhandled exception handler (#10821) * [KBM] Use icon in the KeyboardManagerEditor (#10845) * [KBM] Move resources from the Common project to the Editor. (#10844) * KBM Editor tests (#10858) * Rename engine executable (#10868) * clean up (#10870) * [KBM] Changed Editor and libraries output folders (#10871) * [KBM] New logs structure (#10872) * Add unhandled exception handling to the editor (#10874) * [KBM] Trace for edit keyboard window * Logging for XamlBridge message loop * [KBM] Added Editor and Engine to the installer (#10876) * Fix spelling * Interprocess communication logs, remove unnecessary windows message logs * [KBM] Separated telemetry for the engine and editor. (#10889) * [KBM] Editor test project (#10891) * Versions for the engine and the editor (#10897) * Add the editor's and the engine's executables to signing process (#10900) * [KBM editor] Run only one instance, exit when parent process exits (#10890) * [KBM] Force kill editor process to avoid XAML crash (#10907) * [KBM] Force kill editor process to avoid XAML crash * Fix event releasing Co-authored-by: mykhailopylyp <17161067+mykhailopylyp@users.noreply.github.com> * Make the editor dpi aware (#10908) * [KBM] KeyboardManagerCommon refactoring (#10909) * Do not start the process if it is already started (#10910) * logs * Update src/modules/keyboardmanager/KeyboardManagerEditorLibrary/EditKeyboardWindow.cpp * Update src/modules/keyboardmanager/KeyboardManagerEditorLibrary/EditKeyboardWindow.cpp * [KBM] Rename InitUnhandledExceptionHandler to make it explicit that is for x64 only. We will fix it properly when adding support for ARM64 and add a header with the proper conditional building. * [KBM] rename file/class/variables using camel case * [KBM] Rename "event_locker" -> "EventLocker" * [KBM] rename process_waiter Add a TODO comment * [KBM] rename methods Add TODO comment * [KBM] use uppercase for function names * [KBM] use uppercase for methos, lowercase for properties * [KBM] rename method, make methods private, formatting * [KBM] rename private variables * [KBM] use uppercase for function names * [KBM] Added support to run the editor stand-alone when built in debug mode * Update src/modules/keyboardmanager/KeyboardManagerEditor/KeyboardManagerEditor.cpp * Check success of event creation, comment (#10947) * [KBM] code formatting (#10951) * [KBM] code formatting * Update src/modules/keyboardmanager/KeyboardManagerEditorLibrary/BufferValidationHelpers.cpp * [KBM] tracing * [KBM] Remappings not showing fix. (#10954) * removed mutex * retry loop for reading * retry on reading config once * log error Co-authored-by: Enrico Giordani <enricogior@users.noreply.github.com> Co-authored-by: Enrico Giordani <enricogior@users.noreply.github.com> Co-authored-by: Seraphima Zykova <zykovas91@gmail.com> Co-authored-by: Enrico Giordani <enricogior@users.noreply.github.com> Co-authored-by: Enrico Giordani <enrico.giordani@gmail.com>
2026-04-04 18:26:39 +02:00 · 2021-04-26 22:01:38 +03:00
parent e9a0b58796
commit a8c99e9513
141 changed files with 5124 additions and 2374 deletions
--- a/src/modules/keyboardmanager/common/ErrorTypes.h
+++ b/src/modules/keyboardmanager/common/ErrorTypes.h
@@ -0,0 +1,27 @@
+#pragma once
+
+namespace KeyboardManagerHelper
+{
+    // Type to store codes for different errors
+    enum class ErrorType
+    {
+        NoError,
+        SameKeyPreviouslyMapped,
+        MapToSameKey,
+        ConflictingModifierKey,
+        SameShortcutPreviouslyMapped,
+        MapToSameShortcut,
+        ConflictingModifierShortcut,
+        WinL,
+        CtrlAltDel,
+        RemapUnsuccessful,
+        SaveFailed,
+        ShortcutStartWithModifier,
+        ShortcutCannotHaveRepeatedModifier,
+        ShortcutAtleast2Keys,
+        ShortcutOneActionKey,
+        ShortcutNotMoreThanOneActionKey,
+        ShortcutMaxShortcutSizeOneActionKey,
+        ShortcutDisableAsActionKey
+    };
+}
--- a/src/modules/keyboardmanager/common/Helpers.cpp
+++ b/src/modules/keyboardmanager/common/Helpers.cpp
@@ -1,15 +1,10 @@
 #include "pch.h"
 #include "Helpers.h"
-#include <sstream>

-#include <common/interop/keyboard_layout.h>
 #include <common/interop/shared_constants.h>
 #include <common/utils/process_path.h>
-#include <common/utils/resources.h>

-#include <shlwapi.h>
-#include "keyboardmanager/dll/Generated Files/resource.h"
-#include <common/interop/keyboard_layout.h>
+#include "ErrorTypes.h"
 #include "KeyboardManagerConstants.h"

 using namespace winrt::Windows::Foundation;
@@ -30,17 +25,6 @@ namespace KeyboardManagerHelper
        return splittedStrings;
    }

-    // Function to return the next sibling element for an element under a stack panel
-    IInspectable getSiblingElement(IInspectable const& element)
-    {
-        FrameworkElement frameworkElement = element.as<FrameworkElement>();
-        StackPanel parentElement = frameworkElement.Parent().as<StackPanel>();
-        uint32_t index;
-
-        parentElement.Children().IndexOf(frameworkElement, index);
-        return parentElement.Children().GetAt(index + 1);
-    }
-
    // Function to check if the key is a modifier key
    bool IsModifierKey(DWORD key)
    {
@@ -100,20 +84,6 @@ namespace KeyboardManagerHelper
        }
    }

-    Collections::IVector<IInspectable> ToBoxValue(const std::vector<std::pair<DWORD, std::wstring>>& list)
-    {
-        Collections::IVector<IInspectable> boxList = single_threaded_vector<IInspectable>();
-        for (auto& val : list)
-        {
-            auto comboBox = ComboBoxItem();
-            comboBox.DataContext(winrt::box_value(std::to_wstring(val.first)));
-            comboBox.Content(winrt::box_value(val.second));
-            boxList.Append(winrt::box_value(comboBox));
-        }
-
-        return boxList;
-    }
-
    // Function to check if two keys are equal or cover the same set of keys. Return value depends on type of overlap
    ErrorType DoKeysOverlap(DWORD first, DWORD second)
    {
@@ -141,52 +111,6 @@ namespace KeyboardManagerHelper
        }
    }

-    // Function to return the error message
-    winrt::hstring GetErrorMessage(ErrorType errorType)
-    {
-        switch (errorType)
-        {
-        case ErrorType::NoError:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_REMAPSUCCESSFUL).c_str();
-        case ErrorType::SameKeyPreviouslyMapped:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SAMEKEYPREVIOUSLYMAPPED).c_str();
-        case ErrorType::MapToSameKey:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_MAPPEDTOSAMEKEY).c_str();
-        case ErrorType::ConflictingModifierKey:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_CONFLICTINGMODIFIERKEY).c_str();
-        case ErrorType::SameShortcutPreviouslyMapped:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SAMESHORTCUTPREVIOUSLYMAPPED).c_str();
-        case ErrorType::MapToSameShortcut:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_MAPTOSAMESHORTCUT).c_str();
-        case ErrorType::ConflictingModifierShortcut:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_CONFLICTINGMODIFIERSHORTCUT).c_str();
-        case ErrorType::WinL:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_WINL).c_str();
-        case ErrorType::CtrlAltDel:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_CTRLALTDEL).c_str();
-        case ErrorType::RemapUnsuccessful:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_REMAPUNSUCCESSFUL).c_str();
-        case ErrorType::SaveFailed:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SAVEFAILED).c_str();
-        case ErrorType::ShortcutStartWithModifier:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SHORTCUTSTARTWITHMODIFIER).c_str();
-        case ErrorType::ShortcutCannotHaveRepeatedModifier:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SHORTCUTNOREPEATEDMODIFIER).c_str();
-        case ErrorType::ShortcutAtleast2Keys:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SHORTCUTATLEAST2KEYS).c_str();
-        case ErrorType::ShortcutOneActionKey:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SHORTCUTONEACTIONKEY).c_str();
-        case ErrorType::ShortcutNotMoreThanOneActionKey:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_SHORTCUTMAXONEACTIONKEY).c_str();
-        case ErrorType::ShortcutMaxShortcutSizeOneActionKey:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_MAXSHORTCUTSIZE).c_str();
-        case ErrorType::ShortcutDisableAsActionKey:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_DISABLEASACTIONKEY).c_str();
-        default:
-            return GET_RESOURCE_STRING(IDS_ERRORMESSAGE_DEFAULT).c_str();
-        }
-    }
-
    // Function to set the value of a key event based on the arguments
    void SetKeyEvent(LPINPUT keyEventArray, int index, DWORD inputType, WORD keyCode, DWORD flags, ULONG_PTR extraInfo)
    {
@@ -363,12 +287,4 @@ namespace KeyboardManagerHelper
        // If we have at least two keys equal to 'selectedKeyCode' than modifier was repeated
        return numberOfSameType > 1;
    }
-
-    winrt::Windows::Foundation::IInspectable GetWrapped(const winrt::Windows::Foundation::IInspectable& element, double width)
-    {
-        StackPanel sp = StackPanel();
-        sp.Width(width);
-        sp.Children().Append(element.as<FrameworkElement>());
-        return sp;
-    }
 }
--- a/src/modules/keyboardmanager/common/Helpers.h
+++ b/src/modules/keyboardmanager/common/Helpers.h
@@ -1,20 +1,6 @@
 #pragma once
 #include "Shortcut.h"

-namespace winrt
-{
-    struct hstring;
-    namespace Windows::Foundation
-    {
-        struct IInspectable;
-        namespace Collections
-        {
-            template<typename T>
-            struct IVector;
-        }
-    }
-}
-
 class LayoutMap;

 namespace KeyboardManagerHelper
@@ -29,29 +15,6 @@ namespace KeyboardManagerHelper
        Action
    };

-    // Type to store codes for different errors
-    enum class ErrorType
-    {
-        NoError,
-        SameKeyPreviouslyMapped,
-        MapToSameKey,
-        ConflictingModifierKey,
-        SameShortcutPreviouslyMapped,
-        MapToSameShortcut,
-        ConflictingModifierShortcut,
-        WinL,
-        CtrlAltDel,
-        RemapUnsuccessful,
-        SaveFailed,
-        ShortcutStartWithModifier,
-        ShortcutCannotHaveRepeatedModifier,
-        ShortcutAtleast2Keys,
-        ShortcutOneActionKey,
-        ShortcutNotMoreThanOneActionKey,
-        ShortcutMaxShortcutSizeOneActionKey,
-        ShortcutDisableAsActionKey
-    };
-
    // Enum type to store possible decision for input in the low level hook
    enum class KeyboardHookDecision
    {
@@ -63,9 +26,6 @@ namespace KeyboardManagerHelper
    // Function to split a wstring based on a delimiter and return a vector of split strings
    std::vector<std::wstring> splitwstring(const std::wstring& input, wchar_t delimiter);

-    // Function to return the next sibling element for an element under a stack panel
-    winrt::Windows::Foundation::IInspectable getSiblingElement(winrt::Windows::Foundation::IInspectable const& element);
-
    // Function to return if the key is an extended key which requires the use of the extended key flag
    bool IsExtendedKey(DWORD key);

@@ -78,12 +38,6 @@ namespace KeyboardManagerHelper
    // Function to check if two keys are equal or cover the same set of keys. Return value depends on type of overlap
    ErrorType DoKeysOverlap(DWORD first, DWORD second);

-    // Function to return the error message
-    winrt::hstring GetErrorMessage(ErrorType errorType);
-
-    // Function to return the list of key name in the order for the drop down based on the key codes
-    winrt::Windows::Foundation::Collections::IVector<winrt::Windows::Foundation::IInspectable> ToBoxValue(const std::vector<std::pair<DWORD,std::wstring>>& list);
-
    // Function to set the value of a key event based on the arguments
    void SetKeyEvent(LPINPUT keyEventArray, int index, DWORD inputType, WORD keyCode, DWORD flags, ULONG_PTR extraInfo);

@@ -107,6 +61,4 @@ namespace KeyboardManagerHelper

    // Function to check if a modifier has been repeated in the previous drop downs
    bool CheckRepeatedModifier(const std::vector<int32_t>& currentKeys, int selectedKeyCodes);
-
-    winrt::Windows::Foundation::IInspectable GetWrapped(const winrt::Windows::Foundation::IInspectable& element, double width);
 }
--- a/src/modules/keyboardmanager/common/Input.h
+++ b/src/modules/keyboardmanager/common/Input.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <keyboardmanager/common/InputInterface.h>
+#include <keyboardmanager/common/Helpers.h>
+
+namespace KeyboardManagerInput
+{
+    // Class used to wrap keyboard input library methods
+    class Input : public InputInterface
+    {
+    public:
+        // Function to simulate input
+        UINT SendVirtualInput(UINT cInputs, LPINPUT pInputs, int cbSize)
+        {
+            return SendInput(cInputs, pInputs, cbSize);
+        }
+
+        // Function to get the state of a particular key
+        bool GetVirtualKeyState(int key)
+        {
+            return (GetAsyncKeyState(key) & 0x8000);
+        }
+
+        // Function to get the foreground process name
+        void GetForegroundProcess(_Out_ std::wstring& foregroundProcess)
+        {
+            foregroundProcess = KeyboardManagerHelper::GetCurrentApplication(false);
+        }
+    };
+}
--- a/src/modules/keyboardmanager/common/InputInterface.h
+++ b/src/modules/keyboardmanager/common/InputInterface.h
@@ -1,15 +1,18 @@
 #pragma once

-// Interface used to wrap keyboard input library methods
-class InputInterface
+namespace KeyboardManagerInput
 {
-public:
-    // Function to simulate input
-    virtual UINT SendVirtualInput(UINT cInputs, LPINPUT pInputs, int cbSize) = 0;
+    // Interface used to wrap keyboard input library methods
+    class InputInterface
+    {
+    public:
+        // Function to simulate input
+        virtual UINT SendVirtualInput(UINT cInputs, LPINPUT pInputs, int cbSize) = 0;

-    // Function to get the state of a particular key
-    virtual bool GetVirtualKeyState(int key) = 0;
+        // Function to get the state of a particular key
+        virtual bool GetVirtualKeyState(int key) = 0;

-    // Function to get the foreground process name
-    virtual void GetForegroundProcess(_Out_ std::wstring& foregroundProcess) = 0;
-};
+        // Function to get the foreground process name
+        virtual void GetForegroundProcess(_Out_ std::wstring& foregroundProcess) = 0;
+    };
+}
--- a/src/modules/keyboardmanager/common/KeyboardEventHandlers.cpp
+++ b/src/modules/keyboardmanager/common/KeyboardEventHandlers.cpp
@@ -0,0 +1,24 @@
+#include "pch.h"
+#include "KeyboardEventHandlers.h"
+#include <keyboardmanager/common/KeyboardManagerState.h>
+#include <keyboardmanager/common/InputInterface.h>
+#include <keyboardmanager/common/Helpers.h>
+
+namespace KeyboardEventHandlers
+{
+    // Function to ensure Num Lock state does not change when it is suppressed by the low level hook
+    void SetNumLockToPreviousState(KeyboardManagerInput::InputInterface& ii)
+    {
+        // Num Lock's key state is applied before it is intercepted by low level keyboard hooks, so we have to manually set back the state when we suppress the key. This is done by sending an additional key up, key down set of messages.
+        // We need 2 key events because after Num Lock is suppressed, key up to release num lock key and key down to revert the num lock state
+        int key_count = 2;
+        LPINPUT keyEventList = new INPUT[size_t(key_count)]();
+        memset(keyEventList, 0, sizeof(keyEventList));
+
+        // Use the suppress flag to ensure these are not intercepted by any remapped keys or shortcuts
+        KeyboardManagerHelper::SetKeyEvent(keyEventList, 0, INPUT_KEYBOARD, VK_NUMLOCK, KEYEVENTF_KEYUP, KeyboardManagerConstants::KEYBOARDMANAGER_SUPPRESS_FLAG);
+        KeyboardManagerHelper::SetKeyEvent(keyEventList, 1, INPUT_KEYBOARD, VK_NUMLOCK, 0, KeyboardManagerConstants::KEYBOARDMANAGER_SUPPRESS_FLAG);
+        UINT res = ii.SendVirtualInput((UINT)key_count, keyEventList, sizeof(INPUT));
+        delete[] keyEventList;
+    }
+}
--- a/src/modules/keyboardmanager/common/KeyboardEventHandlers.h
+++ b/src/modules/keyboardmanager/common/KeyboardEventHandlers.h
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace KeyboardManagerInput
+{
+    class InputInterface;
+}
+
+namespace KeyboardEventHandlers
+{
+    // Function to ensure Num Lock state does not change when it is suppressed by the low level hook
+    void SetNumLockToPreviousState(KeyboardManagerInput::InputInterface& ii);
+};
--- a/src/modules/keyboardmanager/common/KeyboardManagerCommon.vcxproj
+++ b/src/modules/keyboardmanager/common/KeyboardManagerCommon.vcxproj
@@ -45,16 +45,19 @@
  <ItemGroup>
    <ClCompile Include="..\..\..\common\interop\keyboard_layout.cpp" />
    <ClCompile Include="Helpers.cpp" />
+    <ClCompile Include="KeyboardEventHandlers.cpp" />
    <ClCompile Include="KeyboardManagerState.cpp" />
    <ClCompile Include="KeyDelay.cpp" />
    <ClCompile Include="pch.cpp">
      <PrecompiledHeader Condition="'$(CIBuild)'!='true'">Create</PrecompiledHeader>
    </ClCompile>
-    <ClCompile Include="RemapShortcut.cpp" />
+    <ClCompile Include="SettingsHelper.cpp" />
    <ClCompile Include="Shortcut.cpp" />
-    <ClCompile Include="trace.cpp" />
  </ItemGroup>
  <ItemGroup>
+    <ClInclude Include="ErrorTypes.h" />
+    <ClInclude Include="Input.h" />
+    <ClInclude Include="KeyboardEventHandlers.h" />
    <ClInclude Include="ModifierKey.h" />
    <ClInclude Include="InputInterface.h" />
    <ClInclude Include="Helpers.h" />
@@ -63,8 +66,8 @@
    <ClInclude Include="KeyDelay.h" />
    <ClInclude Include="pch.h" />
    <ClInclude Include="RemapShortcut.h" />
+    <ClInclude Include="SettingsHelper.h" />
    <ClInclude Include="Shortcut.h" />
-    <ClInclude Include="trace.h" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\..\common\COMUtils\COMUtils.vcxproj">
@@ -73,11 +76,15 @@
    <ProjectReference Include="..\..\..\common\Display\Display.vcxproj">
      <Project>{caba8dfb-823b-4bf2-93ac-3f31984150d9}</Project>
    </ProjectReference>
+    <ProjectReference Include="..\..\..\common\logger\logger.vcxproj">
+      <Project>{d9b8fc84-322a-4f9f-bbb9-20915c47ddfd}</Project>
+    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="..\..\..\..\deps\spdlog.props" />
  <ImportGroup Label="ExtensionTargets">
    <Import Project="..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\..\..\..\packages\Microsoft.Windows.CppWinRT.2.0.200729.8\build\native\Microsoft.Windows.CppWinRT.targets')" />
  </ImportGroup>
--- a/src/modules/keyboardmanager/common/KeyboardManagerCommon.vcxproj.filters
+++ b/src/modules/keyboardmanager/common/KeyboardManagerCommon.vcxproj.filters
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Source Files">
@@ -27,16 +27,16 @@
    <ClCompile Include="Shortcut.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="RemapShortcut.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="KeyDelay.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="Trace.cpp">
+    <ClCompile Include="..\..\..\common\interop\keyboard_layout.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="..\..\..\common\interop\keyboard_layout.cpp">
+    <ClCompile Include="SettingsHelper.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="KeyboardEventHandlers.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
@@ -62,15 +62,24 @@
    <ClInclude Include="KeyboardManagerConstants.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="Trace.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
    <ClInclude Include="InputInterface.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="ModifierKey.h">
      <Filter>Header Files</Filter>
    </ClInclude>
+    <ClInclude Include="SettingsHelper.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="KeyboardEventHandlers.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Input.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ErrorTypes.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
--- a/src/modules/keyboardmanager/common/KeyboardManagerConstants.h
+++ b/src/modules/keyboardmanager/common/KeyboardManagerConstants.h
@@ -1,12 +1,12 @@
 #pragma once
-#include <string>
-#include <winrt/base.h>
-#include <common/utils/resources.h>
-#include "keyboardmanager/dll/Generated Files/resource.h"
-#include "common/interop/shared_constants.h"

 namespace KeyboardManagerConstants
 {
+    // Event name for signaling settings changes
+    inline const std::wstring SettingsEventName = L"PowerToys_KeyboardManager_Event_Settings"; 
+
+    inline const std::wstring EditorWindowEventName = L"PowerToys_KeyboardManager_Event_EditorWindow"; 
+
    // Name of the powertoy module.
    inline const std::wstring ModuleName = L"Keyboard Manager";

@@ -40,9 +40,6 @@ namespace KeyboardManagerConstants
    // Name of the default configuration.
    inline const std::wstring DefaultConfiguration = L"default";

-    // Name of the named mutex used for configuration file.
-    inline const std::wstring ConfigFileMutexName = CommonSharedConstants::KEYBOARD_MANAGER_CONFIG_FILE_MUTEX_NAME;
-
    // Name of the dummy update file.
    inline const std::wstring DummyUpdateFileName = L"settings-updated.json";

@@ -106,9 +103,6 @@ namespace KeyboardManagerConstants
    // Number of key messages required while sending a dummy key event
    inline const size_t DUMMY_KEY_EVENT_SIZE = 2;

-    // String constant for the default app name in Remap shortcuts
-    inline const std::wstring DefaultAppName = GET_RESOURCE_STRING(IDS_EDITSHORTCUTS_ALLAPPS);
-
    // String constant to represent no activated application in app-specific shortcuts
    inline const std::wstring NoActivatedApp = L"";
 }
--- a/src/modules/keyboardmanager/common/KeyboardManagerState.cpp
+++ b/src/modules/keyboardmanager/common/KeyboardManagerState.cpp
@@ -5,24 +5,17 @@
 #include <common/SettingsAPI/settings_helpers.h>
 #include "KeyDelay.h"
 #include "Helpers.h"
+#include <common/logger/logger.h>

 // Constructor
 KeyboardManagerState::KeyboardManagerState() :
    uiState(KeyboardManagerUIState::Deactivated), currentUIWindow(nullptr), currentShortcutUI1(nullptr), currentShortcutUI2(nullptr), currentSingleKeyUI(nullptr), detectedRemapKey(NULL), remappingsEnabled(true)
 {
-    configFile_mutex = CreateMutex(
-        NULL, // default security descriptor
-        FALSE, // mutex not owned
-        KeyboardManagerConstants::ConfigFileMutexName.c_str());
 }

 // Destructor
 KeyboardManagerState::~KeyboardManagerState()
 {
-    if (configFile_mutex)
-    {
-        CloseHandle(configFile_mutex);
-    }
 }

 // Function to check the if the UI state matches the argument state. For states with detect windows it also checks if the window is in focus.
@@ -579,28 +572,28 @@ bool KeyboardManagerState::SaveConfigToFile()
    configJson.SetNamedValue(KeyboardManagerConstants::RemapKeysSettingName, remapKeys);
    configJson.SetNamedValue(KeyboardManagerConstants::RemapShortcutsSettingName, remapShortcuts);

-    // Set timeout of 1sec to wait for file to get free.
-    DWORD timeout = 1000;
-    auto dwWaitResult = WaitForSingleObject(
-        configFile_mutex,
-        timeout);
-    if (dwWaitResult == WAIT_OBJECT_0)
+    try
    {
-        try
-        {
-            json::to_file((PTSettingsHelper::get_module_save_folder_location(KeyboardManagerConstants::ModuleName) + L"\\" + GetCurrentConfigName() + L".json"), configJson);
-        }
-        catch (...)
-        {
-            result = false;
-        }
-
-        // Make sure to release the Mutex.
-        ReleaseMutex(configFile_mutex);
+        json::to_file((PTSettingsHelper::get_module_save_folder_location(KeyboardManagerConstants::ModuleName) + L"\\" + GetCurrentConfigName() + L".json"), configJson);
    }
-    else
+    catch (...)
    {
        result = false;
+        Logger::error(L"Failed to save the settings");
+    }
+
+    if (result)
+    {
+        auto hEvent = CreateEvent(nullptr, false, false, KeyboardManagerConstants::SettingsEventName.c_str());
+        if (hEvent)
+        {
+            SetEvent(hEvent);
+            Logger::trace(L"Signaled {} event", KeyboardManagerConstants::SettingsEventName);
+        }
+        else
+        {
+            Logger::error(L"Failed to signal {} event", KeyboardManagerConstants::SettingsEventName);
+        }
    }

    return result;
@@ -629,20 +622,3 @@ std::wstring KeyboardManagerState::GetActivatedApp()
 {
    return activatedAppSpecificShortcutTarget;
 }
-
-bool KeyboardManagerState::AreRemappingsEnabled()
-{
-    return remappingsEnabled;
-}
-
-void KeyboardManagerState::RemappingsDisabledWrapper(std::function<void()> method)
-{
-    // Disable keyboard remappings
-    remappingsEnabled = false;
-
-    // Run the method which requires the remappings to be disabled
-    method();
-
-    // Re-enable the keyboard remappings
-    remappingsEnabled = true;
-}
--- a/src/modules/keyboardmanager/common/KeyboardManagerState.h
+++ b/src/modules/keyboardmanager/common/KeyboardManagerState.h
@@ -78,9 +78,6 @@ private:
    std::wstring currentConfig = KeyboardManagerConstants::DefaultConfiguration;
    std::mutex currentConfig_mutex;

-    // Handle of named mutex used for configuration file.
-    HANDLE configFile_mutex;
-
    // Registered KeyDelay objects, used to notify delayed key events.
    std::map<DWORD, std::unique_ptr<KeyDelay>> keyDelays;
    std::mutex keyDelays_mutex;
@@ -230,8 +227,4 @@ public:

    // Gets the activated target application in app-specific shortcut
    std::wstring GetActivatedApp();
-
-    bool AreRemappingsEnabled();
-
-    void RemappingsDisabledWrapper(std::function<void()> method);
 };
--- a/src/modules/keyboardmanager/common/RemapShortcut.cpp
+++ b/src/modules/keyboardmanager/common/RemapShortcut.cpp
@@ -1,2 +0,0 @@
-#include "pch.h"
-#include "RemapShortcut.h"
--- a/src/modules/keyboardmanager/common/SettingsHelper.cpp
+++ b/src/modules/keyboardmanager/common/SettingsHelper.cpp
@@ -0,0 +1,194 @@
+#include "pch.h"
+#include "SettingsHelper.h"
+
+#include <common/SettingsAPI/settings_objects.h>
+#include <common/SettingsAPI/settings_helpers.h>
+#include <common/logger/logger.h>
+
+#include <common/KeyboardManagerConstants.h>
+
+bool LoadSingleKeyRemaps(KeyboardManagerState& keyboardManagerState, const json::JsonObject& jsonData)
+{
+    bool result = true;
+
+    try
+    {
+        auto remapKeysData = jsonData.GetNamedObject(KeyboardManagerConstants::RemapKeysSettingName);
+        keyboardManagerState.ClearSingleKeyRemaps();
+
+        if (remapKeysData)
+        {
+            auto inProcessRemapKeys = remapKeysData.GetNamedArray(KeyboardManagerConstants::InProcessRemapKeysSettingName);
+            for (const auto& it : inProcessRemapKeys)
+            {
+                try
+                {
+                    auto originalKey = it.GetObjectW().GetNamedString(KeyboardManagerConstants::OriginalKeysSettingName);
+                    auto newRemapKey = it.GetObjectW().GetNamedString(KeyboardManagerConstants::NewRemapKeysSettingName);
+
+                    // If remapped to a shortcut
+                    if (std::wstring(newRemapKey).find(L";") != std::string::npos)
+                    {
+                        keyboardManagerState.AddSingleKeyRemap(std::stoul(originalKey.c_str()), Shortcut(newRemapKey.c_str()));
+                    }
+
+                    // If remapped to a key
+                    else
+                    {
+                        keyboardManagerState.AddSingleKeyRemap(std::stoul(originalKey.c_str()), std::stoul(newRemapKey.c_str()));
+                    }
+                }
+                catch (...)
+                {
+                    Logger::error(L"Improper Key Data JSON. Try the next remap.");
+                    result = false;
+                }
+            }
+        }
+    }
+    catch (...)
+    {
+        Logger::error(L"Improper JSON format for single key remaps. Skip to next remap type");
+        result = false;
+    }
+
+    return result;
+}
+
+bool LoadAppSpecificShortcutRemaps(KeyboardManagerState& keyboardManagerState, const json::JsonObject& remapShortcutsData)
+{
+    bool result = true;
+
+    try
+    {
+        auto appSpecificRemapShortcuts = remapShortcutsData.GetNamedArray(KeyboardManagerConstants::AppSpecificRemapShortcutsSettingName);
+        for (const auto& it : appSpecificRemapShortcuts)
+        {
+            try
+            {
+                auto originalKeys = it.GetObjectW().GetNamedString(KeyboardManagerConstants::OriginalKeysSettingName);
+                auto newRemapKeys = it.GetObjectW().GetNamedString(KeyboardManagerConstants::NewRemapKeysSettingName);
+                auto targetApp = it.GetObjectW().GetNamedString(KeyboardManagerConstants::TargetAppSettingName);
+
+                // If remapped to a shortcut
+                if (std::wstring(newRemapKeys).find(L";") != std::string::npos)
+                {
+                    keyboardManagerState.AddAppSpecificShortcut(targetApp.c_str(), Shortcut(originalKeys.c_str()), Shortcut(newRemapKeys.c_str()));
+                }
+
+                // If remapped to a key
+                else
+                {
+                    keyboardManagerState.AddAppSpecificShortcut(targetApp.c_str(), Shortcut(originalKeys.c_str()), std::stoul(newRemapKeys.c_str()));
+                }
+            }
+            catch (...)
+            {
+                Logger::error(L"Improper Key Data JSON. Try the next shortcut.");
+                result = false;
+            }
+        }
+    }
+    catch (...)
+    {
+        Logger::error(L"Improper JSON format for os level shortcut remaps. Skip to next remap type");
+        result = false;
+    }
+
+    return result;
+}
+
+bool LoadShortcutRemaps(KeyboardManagerState& keyboardManagerState, const json::JsonObject& jsonData)
+{
+    bool result = true;
+
+    try
+    {
+        auto remapShortcutsData = jsonData.GetNamedObject(KeyboardManagerConstants::RemapShortcutsSettingName);
+        keyboardManagerState.ClearOSLevelShortcuts();
+        keyboardManagerState.ClearAppSpecificShortcuts();
+        if (remapShortcutsData)
+        {
+            // Load os level shortcut remaps
+            try
+            {
+                auto globalRemapShortcuts = remapShortcutsData.GetNamedArray(KeyboardManagerConstants::GlobalRemapShortcutsSettingName);
+                for (const auto& it : globalRemapShortcuts)
+                {
+                    try
+                    {
+                        auto originalKeys = it.GetObjectW().GetNamedString(KeyboardManagerConstants::OriginalKeysSettingName);
+                        auto newRemapKeys = it.GetObjectW().GetNamedString(KeyboardManagerConstants::NewRemapKeysSettingName);
+
+                        // If remapped to a shortcut
+                        if (std::wstring(newRemapKeys).find(L";") != std::string::npos)
+                        {
+                            keyboardManagerState.AddOSLevelShortcut(Shortcut(originalKeys.c_str()), Shortcut(newRemapKeys.c_str()));
+                        }
+
+                        // If remapped to a key
+                        else
+                        {
+                            keyboardManagerState.AddOSLevelShortcut(Shortcut(originalKeys.c_str()), std::stoul(newRemapKeys.c_str()));
+                        }
+                    }
+                    catch (...)
+                    {
+                        Logger::error(L"Improper Key Data JSON. Try the next shortcut.");
+                        result = false;
+                    }
+                }
+            }
+            catch (...)
+            {
+                Logger::error(L"Improper JSON format for os level shortcut remaps. Skip to next remap type");
+                result = false;
+            }
+
+            // Load app specific shortcut remaps
+            result = result && LoadAppSpecificShortcutRemaps(keyboardManagerState, remapShortcutsData);
+        }
+    }
+    catch (...)
+    {
+        Logger::error(L"Improper JSON format for shortcut remaps. Skip to next remap type");
+        result = false;
+    }
+
+    return result;
+}
+
+bool SettingsHelper::LoadSettings(KeyboardManagerState& keyboardManagerState)
+{
+    Logger::trace(L"SettingsHelper::LoadSettings()");
+    try
+    {
+        PowerToysSettings::PowerToyValues settings = PowerToysSettings::PowerToyValues::load_from_settings_file(KeyboardManagerConstants::ModuleName);
+        auto current_config = settings.get_string_value(KeyboardManagerConstants::ActiveConfigurationSettingName);
+
+        if (!current_config)
+        {
+            return false;
+        }
+
+        keyboardManagerState.SetCurrentConfigName(*current_config);
+
+        // Read the config file and load the remaps.
+        auto configFile = json::from_file(PTSettingsHelper::get_module_save_folder_location(KeyboardManagerConstants::ModuleName) + L"\\" + *current_config + L".json");
+        if (!configFile)
+        {
+            return false;
+        }
+
+        bool result = LoadSingleKeyRemaps(keyboardManagerState, *configFile);
+        result = result && LoadShortcutRemaps(keyboardManagerState, *configFile);
+
+        return result;
+    }
+    catch (...)
+    {
+        Logger::error(L"SettingsHelper::LoadSettings() failed");
+    }
+
+    return false;
+}
--- a/src/modules/keyboardmanager/common/SettingsHelper.h
+++ b/src/modules/keyboardmanager/common/SettingsHelper.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <keyboardmanager/common/KeyboardManagerState.h>
+
+class SettingsHelper
+{
+public:
+    static bool LoadSettings(KeyboardManagerState& state);
+};
--- a/src/modules/keyboardmanager/common/Shortcut.cpp
+++ b/src/modules/keyboardmanager/common/Shortcut.cpp
@@ -2,6 +2,7 @@
 #include "Shortcut.h"
 #include <common/interop/keyboard_layout.h>
 #include <common/interop/shared_constants.h>
+#include "ErrorTypes.h"
 #include "Helpers.h"
 #include "InputInterface.h"

@@ -518,7 +519,7 @@ void Shortcut::SetKeyCodes(const std::vector<int32_t>& keys)
 }

 // Function to check if all the modifiers in the shortcut have been pressed down
-bool Shortcut::CheckModifiersKeyboardState(InputInterface& ii) const
+bool Shortcut::CheckModifiersKeyboardState(KeyboardManagerInput::InputInterface& ii) const
 {
    // Check the win key state
    if (winKey == ModifierKey::Both)
@@ -669,7 +670,7 @@ bool IgnoreKeyCode(DWORD key)
 }

 // Function to check if any keys are pressed down except those in the shortcut
-bool Shortcut::IsKeyboardStateClearExceptShortcut(InputInterface& ii) const
+bool Shortcut::IsKeyboardStateClearExceptShortcut(KeyboardManagerInput::InputInterface& ii) const
 {
    // Iterate through all the virtual key codes - 0xFF is set to key down because of the Num Lock
    for (int keyVal = 1; keyVal < 0xFF; keyVal++)
--- a/src/modules/keyboardmanager/common/Shortcut.h
+++ b/src/modules/keyboardmanager/common/Shortcut.h
@@ -1,7 +1,11 @@
 #pragma once
 #include "ModifierKey.h"
 #include <variant>
-class InputInterface;
+
+namespace KeyboardManagerInput
+{
+    class InputInterface;
+}
 class LayoutMap;
 namespace KeyboardManagerHelper
 {
@@ -156,10 +160,10 @@ public:
    void SetKeyCodes(const std::vector<int32_t>& keys);

    // Function to check if all the modifiers in the shortcut have been pressed down
-    bool CheckModifiersKeyboardState(InputInterface& ii) const;
+    bool CheckModifiersKeyboardState(KeyboardManagerInput::InputInterface& ii) const;

    // Function to check if any keys are pressed down except those in the shortcut
-    bool IsKeyboardStateClearExceptShortcut(InputInterface& ii) const;
+    bool IsKeyboardStateClearExceptShortcut(KeyboardManagerInput::InputInterface& ii) const;

    // Function to get the number of modifiers that are common between the current shortcut and the shortcut in the argument
    int GetCommonModifiersCount(const Shortcut& input) const;
--- a/src/modules/keyboardmanager/common/trace.cpp
+++ b/src/modules/keyboardmanager/common/trace.cpp
@@ -1,146 +0,0 @@
-#include "pch.h"
-#include "trace.h"
-
-TRACELOGGING_DEFINE_PROVIDER(
-    g_hProvider,
-    "Microsoft.PowerToys",
-    // {38e8889b-9731-53f5-e901-e8a7c1753074}
-    (0x38e8889b, 0x9731, 0x53f5, 0xe9, 0x01, 0xe8, 0xa7, 0xc1, 0x75, 0x30, 0x74),
-    TraceLoggingOptionProjectTelemetry());
-
-void Trace::RegisterProvider() noexcept
-{
-    TraceLoggingRegister(g_hProvider);
-}
-
-void Trace::UnregisterProvider() noexcept
-{
-    TraceLoggingUnregister(g_hProvider);
-}
-
-// Log if the user has KBM enabled or disabled - Can also be used to see how often users have to restart the keyboard hook
-void Trace::EnableKeyboardManager(const bool enabled) noexcept
-{
-    TraceLoggingWrite(
-        g_hProvider,
-        "KeyboardManager_EnableKeyboardManager",
-        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
-        TraceLoggingBoolean(enabled, "Enabled"));
-}
-
-// Log number of key remaps when the user uses Edit Keyboard and saves settings
-void Trace::KeyRemapCount(const DWORD keyToKeyCount, const DWORD keyToShortcutCount) noexcept
-{
-    TraceLoggingWrite(
-        g_hProvider,
-        "KeyboardManager_KeyRemapCount",
-        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
-        TraceLoggingValue(keyToKeyCount + keyToShortcutCount, "KeyRemapCount"),
-        TraceLoggingValue(keyToKeyCount, "KeyToKeyRemapCount"),
-        TraceLoggingValue(keyToShortcutCount, "KeyToShortcutRemapCount"));
-}
-
-// Log number of os level shortcut remaps when the user uses Edit Shortcuts and saves settings
-void Trace::OSLevelShortcutRemapCount(const DWORD shortcutToShortcutCount, const DWORD shortcutToKeyCount) noexcept
-{
-    TraceLoggingWrite(
-        g_hProvider,
-        "KeyboardManager_OSLevelShortcutRemapCount",
-        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
-        TraceLoggingValue(shortcutToShortcutCount + shortcutToKeyCount, "OSLevelShortcutRemapCount"),
-        TraceLoggingValue(shortcutToShortcutCount, "OSLevelShortcutToShortcutRemapCount"),
-        TraceLoggingValue(shortcutToKeyCount, "OSLevelShortcutToKeyRemapCount"));
-}
-
-// Log number of app specific shortcut remaps when the user uses Edit Shortcuts and saves settings
-void Trace::AppSpecificShortcutRemapCount(const DWORD shortcutToShortcutCount, const DWORD shortcutToKeyCount) noexcept
-{
-    TraceLoggingWrite(
-        g_hProvider,
-        "KeyboardManager_AppSpecificShortcutRemapCount",
-        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
-        TraceLoggingValue(shortcutToShortcutCount + shortcutToKeyCount, "AppSpecificShortcutRemapCount"),
-        TraceLoggingValue(shortcutToShortcutCount, "AppSpecificShortcutToShortcutRemapCount"),
-        TraceLoggingValue(shortcutToKeyCount, "AppSpecificShortcutToKeyRemapCount"));
-}
-
-// Log if a key remap has been invoked
-void Trace::KeyRemapInvoked(bool isKeyToKey) noexcept
-{
-    if (isKeyToKey)
-    {
-        TraceLoggingWrite(
-            g_hProvider,
-            "KeyboardManager_KeyToKeyRemapInvoked",
-            ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-            TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
-    }
-    else
-    {
-        TraceLoggingWrite(
-            g_hProvider,
-            "KeyboardManager_KeyToShortcutRemapInvoked",
-            ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-            TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
-    }
-}
-
-// Log if a shortcut remap has been invoked
-void Trace::ShortcutRemapInvoked(bool isShortcutToShortcut, bool isAppSpecific) noexcept
-{
-    if (isAppSpecific)
-    {
-        if (isShortcutToShortcut)
-        {
-            TraceLoggingWrite(
-                g_hProvider,
-                "KeyboardManager_AppSpecificShortcutToShortcutRemapInvoked",
-                ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-                TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
-        }
-        else
-        {
-            TraceLoggingWrite(
-                g_hProvider,
-                "KeyboardManager_AppSpecificShortcutToKeyRemapInvoked",
-                ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-                TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
-        }
-    }
-    else
-    {
-        if (isShortcutToShortcut)
-        {
-            TraceLoggingWrite(
-                g_hProvider,
-                "KeyboardManager_OSLevelShortcutToShortcutRemapInvoked",
-                ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-                TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
-        }
-        else
-        {
-            TraceLoggingWrite(
-                g_hProvider,
-                "KeyboardManager_OSLevelShortcutToKeyRemapInvoked",
-                ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-                TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE));
-        }
-    }
-}
-
-// Log if an error occurs in KBM
-void Trace::Error(const DWORD errorCode, std::wstring errorMessage, std::wstring methodName) noexcept
-{
-    TraceLoggingWrite(
-        g_hProvider,
-        "KeyboardManager_Error",
-        ProjectTelemetryPrivacyDataTag(ProjectTelemetryTag_ProductAndServicePerformance),
-        TraceLoggingKeyword(PROJECT_KEYWORD_MEASURE),
-        TraceLoggingValue(methodName.c_str(), "MethodName"),
-        TraceLoggingValue(errorCode, "ErrorCode"),
-        TraceLoggingValue(errorMessage.c_str(), "ErrorMessage"));
-}
--- a/src/modules/keyboardmanager/common/trace.h
+++ b/src/modules/keyboardmanager/common/trace.h
@@ -1,29 +0,0 @@
-#pragma once
-
-class Trace
-{
-public:
-    static void RegisterProvider() noexcept;
-    static void UnregisterProvider() noexcept;
-
-    // Log if the user has KBM enabled or disabled - Can also be used to see how often users have to restart the keyboard hook
-    static void EnableKeyboardManager(const bool enabled) noexcept;
-
-    // Log number of key remaps when the user uses Edit Keyboard and saves settings
-    static void KeyRemapCount(const DWORD keyToKeyCount, const DWORD keyToShortcutCount) noexcept;
-
-    // Log number of os level shortcut remaps when the user uses Edit Shortcuts and saves settings
-    static void OSLevelShortcutRemapCount(const DWORD shortcutToShortcutCount, const DWORD shortcutToKeyCount) noexcept;
-
-    // Log number of app specific shortcut remaps when the user uses Edit Shortcuts and saves settings
-    static void AppSpecificShortcutRemapCount(const DWORD shortcutToShortcutCount, const DWORD shortcutToKeyCount) noexcept;
-
-    // Log if a key remap has been invoked
-    static void KeyRemapInvoked(bool isKeyToKey) noexcept;
-
-    // Log if a shortcut remap has been invoked
-    static void ShortcutRemapInvoked(bool isShortcutToShortcut, bool isAppSpecific) noexcept;
-    
-    // Log if an error occurs in KBM
-    static void Error(const DWORD errorCode, std::wstring errorMessage, std::wstring methodName) noexcept;
-};