fixed the stability of the logic

Author: SharePointRadi

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Desktop App",
+            "type": "coreclr",
+            "request": "launch",
+            "program": "${workspaceFolder}/Desktop/bin/Debug/net9.0-windows/Desktop.exe",
+            "args": [],
+            "cwd": "${workspaceFolder}/Desktop",
+            "console": "internalConsole",
+            "stopAtEntry": false,
+            "preLaunchTask": "build"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,39 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Desktop/Desktop.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/Desktop/Desktop.csproj",
+                "--configuration",
+                "Release",
+                "--output",
+                "${workspaceFolder}/Desktop/bin/Release/net9.0-windows/publish/"
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "always"
+            },
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

Desktop/Desktop.csproj

@@ -12,8 +12,8 @@
     <Product>Input Language Screamer</Product>
     <Description>Plays language-specific MP3 audio files when Windows input language changes using Alt+Shift</Description>
     <Copyright>© 2025 OneBit Software</Copyright>
-    <AssemblyVersion>1.1.0.0</AssemblyVersion>
-    <FileVersion>1.1.0.0</FileVersion>
+    <AssemblyVersion>1.2.0.0</AssemblyVersion>
+    <FileVersion>1.2.0.0</FileVersion>
 
     <!-- Publishing Configuration -->
     <PublishSingleFile>true</PublishSingleFile>

Desktop/GlobalKeyboardHook.cs

@@ -15,15 +15,24 @@ public class GlobalKeyboardHook
 {
     // Windows API constants for keyboard hook
     private const int WH_KEYBOARD_LL = 13;      // Low-level keyboard input hook
+    private const int WM_KEYDOWN = 0x0100;      // Key down message
     private const int WM_KEYUP = 0x0101;        // Key up message
+    private const int WM_SYSKEYDOWN = 0x0104;   // System key down (Alt combinations)
+    private const int WM_SYSKEYUP = 0x0105;     // System key up (Alt combinations)
     private const int VK_LMENU = 0xA4;          // Left Alt key
     private const int VK_RMENU = 0xA5;          // Right Alt key
+    private const int VK_LSHIFT = 0xA0;         // Left Shift key
+    private const int VK_RSHIFT = 0xA1;         // Right Shift key
+    private const int VK_SHIFT = 0x10;          // Generic Shift key
 
     // Static fields for the hook
     private static LowLevelKeyboardProc _proc = HookCallback;
     private static IntPtr _hookID = IntPtr.Zero;
-    private static InputLanguage? _currentLanguage;
-    private static Action? _onLanguageChange;
+    private static uint _currentInputLanguage = 0;
+    private static Action<string>? _onLanguageChange;
+    private static System.Threading.Timer? _languageCheckTimer;
+    private static bool _leftAltPressed = false;
+    private static bool _leftShiftPressed = false;
 
     /// <summary>
     /// Delegate for the low-level keyboard procedure
@@ -33,11 +42,17 @@ public class GlobalKeyboardHook
     /// <summary>
     /// Initializes the global keyboard hook with a callback for language changes
     /// </summary>
-    /// <param name="onLanguageChange">Action to execute when language changes</param>
-    public GlobalKeyboardHook(Action onLanguageChange)
+    /// <param name="onLanguageChange">Action to execute when language changes, receives the new language name</param>
+    public GlobalKeyboardHook(Action<string> onLanguageChange)
     {
         _onLanguageChange = onLanguageChange;
-        _currentLanguage = InputLanguage.CurrentInputLanguage;
+        
+        // Get the initial keyboard layout for the foreground window's thread
+        var foregroundWindow = GetForegroundWindow();
+        var threadId = GetWindowThreadProcessId(foregroundWindow, IntPtr.Zero);
+        var keyboardLayout = GetKeyboardLayout(threadId);
+        _currentInputLanguage = (uint)((long)keyboardLayout & 0xFFFF);
+        
         _hookID = SetHook(_proc);
     }
 
@@ -58,7 +73,7 @@ private static IntPtr SetHook(LowLevelKeyboardProc proc)
 
     /// <summary>
     /// Callback function that processes keyboard events from the hook
-    /// Monitors for Alt key releases and checks for language changes
+    /// Monitors for potential language switching keys and checks for language changes
     /// </summary>
     /// <param name="nCode">Hook code</param>
     /// <param name="wParam">Message identifier</param>
@@ -72,15 +87,49 @@ private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
             // Get the virtual key code from the keyboard input structure
             int vkCode = Marshal.ReadInt32(lParam);
 
-            // Check if this is a key release event
-            if (wParam == (IntPtr)WM_KEYUP)
+            // Check if this is a key press or release event
+            bool isKeyDown = wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN;
+            bool isKeyUp = wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP;
+            
+            // Track Left Alt and Left Shift key states
+            if (vkCode == VK_LMENU)
             {
-                // Check if Alt key was released (left or right Alt)
-                if (vkCode == VK_LMENU || vkCode == VK_RMENU)
+                if (isKeyDown)
+                {
+                    _leftAltPressed = true;
+                    Debug.WriteLine("Left Alt pressed");
+                }
+                else if (isKeyUp)
+                {
+                    _leftAltPressed = false;
+                    Debug.WriteLine("Left Alt released");
+                    
+                    // Check for language change when Alt is released if Shift was also pressed
+                    if (_leftShiftPressed)
+                    {
+                        Debug.WriteLine("Alt+Shift combination detected (Alt released) - checking for language change");
+                        ScheduleLanguageCheck();
+                    }
+                }
+            }
+            else if (vkCode == VK_LSHIFT)
+            {
+                if (isKeyDown)
+                {
+                    _leftShiftPressed = true;
+                    Debug.WriteLine("Left Shift pressed");
+                }
+                else if (isKeyUp)
                 {
-                    // Check for language change when Alt is released
-                    // This catches Alt+Shift language switching
-                    CheckLanguageChange();
+                    _leftShiftPressed = false;
+                    Debug.WriteLine("Left Shift released");
+                    
+                    // Check for language change when Shift is released if Alt was also pressed
+                    if (_leftAltPressed)
+                    {
+                        Debug.WriteLine("Alt+Shift combination detected (Shift released) - checking for language change");
+                        ScheduleLanguageCheck();
+                    }
                 }
             }
         }
@@ -89,25 +138,84 @@ private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
         return CallNextHookEx(_hookID, nCode, wParam, lParam);
     }
 
+    /// <summary>
+    /// Schedules a single delayed language check
+    /// </summary>
+    private static void ScheduleLanguageCheck()
+    {
+        // Cancel any existing timer to prevent duplicates
+        _languageCheckTimer?.Dispose();
+        
+        // Schedule a single check after a delay to allow the language change to complete
+        _languageCheckTimer = new System.Threading.Timer(
+            callback: _ => CheckLanguageChange(),
+            state: null,
+            dueTime: TimeSpan.FromMilliseconds(250),
+            period: Timeout.InfiniteTimeSpan
+        );
+    }
+
     /// <summary>
     /// Checks if the input language has changed and triggers the callback if it has
     /// </summary>
     private static void CheckLanguageChange()
     {
-        var newLanguage = InputLanguage.CurrentInputLanguage;
-        if (newLanguage != _currentLanguage)
+        try
+        {
+            // Get the keyboard layout for the foreground window's thread instead of current thread
+            var foregroundWindow = GetForegroundWindow();
+            var threadId = GetWindowThreadProcessId(foregroundWindow, IntPtr.Zero);
+            var keyboardLayout = GetKeyboardLayout(threadId);
+            var newInputLanguage = (uint)((long)keyboardLayout & 0xFFFF);
+
+            // Get language name for debugging
+            string currentLangName = GetLanguageName(_currentInputLanguage);
+            string newLangName = GetLanguageName(newInputLanguage);
+
+            Debug.WriteLine($"Current: {currentLangName} (0x{_currentInputLanguage:X4}), New: {newLangName} (0x{newInputLanguage:X4}), Thread: {threadId}, Layout: 0x{(long)keyboardLayout:X8}");
+
+            if (newInputLanguage != _currentInputLanguage)
+            {
+                Debug.WriteLine($"Language changed from {currentLangName} to {newLangName}");
+                _currentInputLanguage = newInputLanguage;
+                _onLanguageChange?.Invoke(newLangName);
+            }
+        }
+        catch (Exception ex)
         {
-            _currentLanguage = newLanguage;
-            _onLanguageChange?.Invoke();
+            Debug.WriteLine($"Error checking language change: {ex.Message}");
+            // Silently ignore errors to prevent disrupting the hook
         }
     }
 
+    /// <summary>
+    /// Gets a readable language name from language ID for debugging and audio file matching
+    /// </summary>
+    private static string GetLanguageName(uint langId)
+    {
+        return langId switch
+        {
+            0x0409 => "English",
+            0x0809 => "English", 
+            0x0402 => "Bulgarian",
+            0x0407 => "German",
+            0x040C => "French",
+            0x0410 => "Italian",
+            0x0C0A => "Spanish",
+            0x0419 => "Russian",
+            0x041F => "Turkish",
+            _ => $"Unknown"
+        };
+    }
+
     /// <summary>
     /// Disposes of the keyboard hook resources
     /// </summary>
     public void Dispose()
     {
         UnhookWindowsHookEx(_hookID);
+        _languageCheckTimer?.Dispose();
+        _languageCheckTimer = null;
     }
 
     // Windows API function imports for keyboard hook functionality
@@ -138,4 +246,22 @@ private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
     /// </summary>
     [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
     private static extern IntPtr GetModuleHandle(string lpModuleName);
+
+    /// <summary>
+    /// Retrieves the active input locale identifier (keyboard layout) for the specified thread
+    /// </summary>
+    [DllImport("user32.dll")]
+    private static extern IntPtr GetKeyboardLayout(uint idThread);
+
+    /// <summary>
+    /// Retrieves a handle to the foreground window
+    /// </summary>
+    [DllImport("user32.dll")]
+    private static extern IntPtr GetForegroundWindow();
+
+    /// <summary>
+    /// Retrieves the identifier of the thread that created the specified window
+    /// </summary>
+    [DllImport("user32.dll")]
+    private static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr processId);
 }