Merge pull request #834 from Flow-Launcher/GlobalHotkeyRefactor

jjw24 · web-flow · commit 2855c6c31777 · 2021-12-08T20:56:03.000+11:00
[dev] Global hotkey refactor
diff --git a/Flow.Launcher.Infrastructure/Flow.Launcher.Infrastructure.csproj b/Flow.Launcher.Infrastructure/Flow.Launcher.Infrastructure.csproj
@@ -11,6 +11,7 @@
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
     <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -21,7 +22,6 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   
@@ -32,7 +32,6 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   
diff --git a/Flow.Launcher.Infrastructure/Hotkey/GlobalHotkey.cs b/Flow.Launcher.Infrastructure/Hotkey/GlobalHotkey.cs
@@ -9,41 +9,28 @@ namespace Flow.Launcher.Infrastructure.Hotkey
     /// Listens keyboard globally.
     /// <remarks>Uses WH_KEYBOARD_LL.</remarks>
     /// </summary>
-    public class GlobalHotkey : IDisposable
+    public unsafe class GlobalHotkey : IDisposable
     {
-        private static GlobalHotkey instance;
-        private InterceptKeys.LowLevelKeyboardProc hookedLowLevelKeyboardProc;
-        private IntPtr hookId = IntPtr.Zero;
+        private static readonly IntPtr hookId;
+        
+        
+        
         public delegate bool KeyboardCallback(KeyEvent keyEvent, int vkCode, SpecialKeyState state);
-        public event KeyboardCallback hookedKeyboardCallback;
+        internal static Func<KeyEvent, int, SpecialKeyState, bool> hookedKeyboardCallback;
 
         //Modifier key constants
         private const int VK_SHIFT = 0x10;
         private const int VK_CONTROL = 0x11;
         private const int VK_ALT = 0x12;
         private const int VK_WIN = 91;
 
-        public static GlobalHotkey Instance
+        static GlobalHotkey()
         {
-            get
-            {
-                if (instance == null)
-                {
-                    instance = new GlobalHotkey();
-                }
-                return instance;
-            }
-        }
-
-        private GlobalHotkey()
-        {
-            // We have to store the LowLevelKeyboardProc, so that it is not garbage collected runtime
-            hookedLowLevelKeyboardProc = LowLevelKeyboardProc;
             // Set the hook
-            hookId = InterceptKeys.SetHook(hookedLowLevelKeyboardProc);
+            hookId = InterceptKeys.SetHook(& LowLevelKeyboardProc);
         }
 
-        public SpecialKeyState CheckModifiers()
+        public static SpecialKeyState CheckModifiers()
         {
             SpecialKeyState state = new SpecialKeyState();
             if ((InterceptKeys.GetKeyState(VK_SHIFT) & 0x8000) != 0)
@@ -70,8 +57,8 @@ public SpecialKeyState CheckModifiers()
             return state;
         }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam)
+        [UnmanagedCallersOnly]
+        private static IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam)
         {
             bool continues = true;
 
@@ -91,17 +78,17 @@ private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam)
             {
                 return InterceptKeys.CallNextHookEx(hookId, nCode, wParam, lParam);
             }
-            return (IntPtr)1;
+            return (IntPtr)(-1);
         }
 
-        ~GlobalHotkey()
+        public void Dispose()
         {
-            Dispose();
+            InterceptKeys.UnhookWindowsHookEx(hookId);
         }
 
-        public void Dispose()
+        ~GlobalHotkey()
         {
-            InterceptKeys.UnhookWindowsHookEx(hookId);
+            Dispose();
         }
     }
 }
diff --git a/Flow.Launcher.Infrastructure/Hotkey/InterceptKeys.cs b/Flow.Launcher.Infrastructure/Hotkey/InterceptKeys.cs
@@ -4,13 +4,13 @@
 
 namespace Flow.Launcher.Infrastructure.Hotkey
 {
-    internal static class InterceptKeys
+    internal static unsafe class InterceptKeys
     {
         public delegate IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam);
 
         private const int WH_KEYBOARD_LL = 13;
 
-        public static IntPtr SetHook(LowLevelKeyboardProc proc)
+        public static IntPtr SetHook(delegate* unmanaged<int, UIntPtr, IntPtr, IntPtr> proc)
         {
             using (Process curProcess = Process.GetCurrentProcess())
             using (ProcessModule curModule = curProcess.MainModule)
@@ -20,7 +20,7 @@ public static IntPtr SetHook(LowLevelKeyboardProc proc)
         }
 
         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
-        public static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
+        public static extern IntPtr SetWindowsHookEx(int idHook, delegate* unmanaged<int, UIntPtr, IntPtr, IntPtr> lpfn, IntPtr hMod, uint dwThreadId);
 
         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
diff --git a/Flow.Launcher.Plugin/Interfaces/IPublicAPI.cs b/Flow.Launcher.Plugin/Interfaces/IPublicAPI.cs
@@ -119,7 +119,21 @@ public interface IPublicAPI
         /// Fired after global keyboard events
         /// if you want to hook something like Ctrl+R, you should use this event
         /// </summary>
+        [Obsolete("Unable to Retrieve correct return value")]
         event FlowLauncherGlobalKeyboardEventHandler GlobalKeyboardEvent;
+        
+        /// <summary>
+        /// Register a callback for Global Keyboard Event
+        /// </summary>
+        /// <param name="callback"></param>
+        public void RegisterGlobalKeyboardCallback(Func<int, int, SpecialKeyState, bool> callback);
+        
+        /// <summary>
+        /// Remove a callback for Global Keyboard Event
+        /// </summary>
+        /// <param name="callback"></param>
+        public void RemoveGlobalKeyboardCallback(Func<int, int, SpecialKeyState, bool> callback);
+
 
         /// <summary>
         /// Fuzzy Search the string with the given query. This is the core search mechanism Flow uses
diff --git a/Flow.Launcher/HotkeyControl.xaml.cs b/Flow.Launcher/HotkeyControl.xaml.cs
@@ -45,7 +45,7 @@ private void TbHotkey_OnPreviewKeyDown(object sender, KeyEventArgs e)
             //when alt is pressed, the real key should be e.SystemKey
             Key key = e.Key == Key.System ? e.SystemKey : e.Key;
 
-            SpecialKeyState specialKeyState = GlobalHotkey.Instance.CheckModifiers();
+            SpecialKeyState specialKeyState = GlobalHotkey.CheckModifiers();
 
             var hotkeyModel = new HotkeyModel(
                 specialKeyState.AltPressed,
diff --git a/Flow.Launcher/PublicAPIInstance.cs b/Flow.Launcher/PublicAPIInstance.cs
@@ -41,7 +41,7 @@ public PublicAPIInstance(SettingWindowViewModel settingsVM, MainViewModel mainVM
             _settingsVM = settingsVM;
             _mainVM = mainVM;
             _alphabet = alphabet;
-            GlobalHotkey.Instance.hookedKeyboardCallback += KListener_hookedKeyboardCallback;
+            GlobalHotkey.hookedKeyboardCallback = KListener_hookedKeyboardCallback;
             WebRequest.RegisterPrefix("data", new DataWebRequestFactory());
         }
 
@@ -204,25 +204,35 @@ public void OpenDirectory(string DirectoryPath, string FileName = null)
                 Arguments = FileName is null ?
                     explorerInfo.DirectoryArgument.Replace("%d", DirectoryPath) :
                     explorerInfo.FileArgument.Replace("%d", DirectoryPath).Replace("%f",
-                    Path.IsPathRooted(FileName) ? FileName : Path.Combine(DirectoryPath, FileName))
+                        Path.IsPathRooted(FileName) ? FileName : Path.Combine(DirectoryPath, FileName))
             };
             explorer.Start();
         }
 
         public event FlowLauncherGlobalKeyboardEventHandler GlobalKeyboardEvent;
 
+        private readonly List<Func<int, int, SpecialKeyState, bool>> _globalKeyboardHandlers = new();
+
+        public void RegisterGlobalKeyboardCallback(Func<int, int, SpecialKeyState, bool> callback) => _globalKeyboardHandlers.Add(callback);
+        public void RemoveGlobalKeyboardCallback(Func<int, int, SpecialKeyState, bool> callback) => _globalKeyboardHandlers.Remove(callback);
+
         #endregion
 
         #region Private Methods
 
         private bool KListener_hookedKeyboardCallback(KeyEvent keyevent, int vkcode, SpecialKeyState state)
         {
+            var continueHook = true;
             if (GlobalKeyboardEvent != null)
             {
-                return GlobalKeyboardEvent((int)keyevent, vkcode, state);
+                continueHook = GlobalKeyboardEvent((int)keyevent, vkcode, state);
+            }
+            foreach (var x in _globalKeyboardHandlers)
+            {
+                continueHook &= x((int)keyevent, vkcode, state);
             }
 
-            return true;
+            return continueHook;
         }
 
         #endregion
diff --git a/Flow.Launcher/ViewModel/MainViewModel.cs b/Flow.Launcher/ViewModel/MainViewModel.cs
@@ -208,7 +208,7 @@ private void InitializeKeyCommands()
                 {
                     bool hideWindow = result.Action != null && result.Action(new ActionContext
                     {
-                        SpecialKeyState = GlobalHotkey.Instance.CheckModifiers()
+                        SpecialKeyState = GlobalHotkey.CheckModifiers()
                     });
 
                     if (hideWindow)
@@ -244,8 +244,8 @@ private void InitializeKeyCommands()
                         autoCompleteText = SelectedResults.SelectedItem.QuerySuggestionText;
                     }
 
-                    var SpecialKeyState = GlobalHotkey.Instance.CheckModifiers();
-                    if (SpecialKeyState.ShiftPressed)
+                    var specialKeyState = GlobalHotkey.CheckModifiers();
+                    if (specialKeyState.ShiftPressed)
                     {
                         autoCompleteText = result.SubTitle;
                     }
diff --git a/Plugins/Flow.Launcher.Plugin.Shell/Main.cs b/Plugins/Flow.Launcher.Plugin.Shell/Main.cs
@@ -312,7 +312,7 @@ public void Init(PluginInitContext context)
         {
             this.context = context;
             _settings = context.API.LoadSettingJsonStorage<Settings>();
-            context.API.GlobalKeyboardEvent += API_GlobalKeyboardEvent;
+            context.API.RegisterGlobalKeyboardCallback(API_GlobalKeyboardEvent);
         }
 
         bool API_GlobalKeyboardEvent(int keyevent, int vkcode, SpecialKeyState state)
@@ -337,12 +337,9 @@ bool API_GlobalKeyboardEvent(int keyevent, int vkcode, SpecialKeyState state)
 
         private void OnWinRPressed()
         {
-            context.API.ChangeQuery($"{context.CurrentPluginMetadata.ActionKeywords[0]}{Plugin.Query.TermSeparator}");
-
             // show the main window and set focus to the query box
-            Window mainWindow = Application.Current.MainWindow;
-            mainWindow.Show();
-            mainWindow.Focus();
+            context.API.ShowMainWindow();
+            context.API.ChangeQuery($"{context.CurrentPluginMetadata.ActionKeywords[0]}{Plugin.Query.TermSeparator}");
         }
 
         public Control CreateSettingPanel()
diff --git a/Plugins/Flow.Launcher.Plugin.Shell/plugin.json b/Plugins/Flow.Launcher.Plugin.Shell/plugin.json
@@ -4,7 +4,7 @@
   "Name": "Shell",
   "Description": "Provide executing commands from Flow Launcher",
   "Author": "qianlifeng",
-  "Version": "1.4.6",
+  "Version": "1.4.7",
   "Language": "csharp",
   "Website": "https://github.com/Flow-Launcher/Flow.Launcher",
   "ExecuteFileName": "Flow.Launcher.Plugin.Shell.dll",

Original file line number	Diff line number	Diff line change
`@@ -9,41 +9,28 @@ namespace Flow.Launcher.Infrastructure.Hotkey`
`9`	`9`	`/// Listens keyboard globally.`
`10`	`10`	`/// <remarks>Uses WH_KEYBOARD_LL.</remarks>`
`11`	`11`	`/// </summary>`
`12`		`- public class GlobalHotkey : IDisposable`
	`12`	`+ public unsafe class GlobalHotkey : IDisposable`
`13`	`13`	`{`
`14`		`- private static GlobalHotkey instance;`
`15`		`- private InterceptKeys.LowLevelKeyboardProc hookedLowLevelKeyboardProc;`
`16`		`- private IntPtr hookId = IntPtr.Zero;`
	`14`	`+ private static readonly IntPtr hookId;`
	`15`	`+`
	`16`	`+`
	`17`	`+`
`17`	`18`	`public delegate bool KeyboardCallback(KeyEvent keyEvent, int vkCode, SpecialKeyState state);`
`18`		`- public event KeyboardCallback hookedKeyboardCallback;`
	`19`	`+ internal static Func<KeyEvent, int, SpecialKeyState, bool> hookedKeyboardCallback;`
`19`	`20`
`20`	`21`	`//Modifier key constants`
`21`	`22`	`private const int VK_SHIFT = 0x10;`
`22`	`23`	`private const int VK_CONTROL = 0x11;`
`23`	`24`	`private const int VK_ALT = 0x12;`
`24`	`25`	`private const int VK_WIN = 91;`
`25`	`26`
`26`		`- public static GlobalHotkey Instance`
	`27`	`+ static GlobalHotkey()`
`27`	`28`	`{`
`28`		`- get`
`29`		`- {`
`30`		`- if (instance == null)`
`31`		`- {`
`32`		`- instance = new GlobalHotkey();`
`33`		`- }`
`34`		`- return instance;`
`35`		`- }`
`36`		`- }`
`37`		`-`
`38`		`- private GlobalHotkey()`
`39`		`- {`
`40`		`- // We have to store the LowLevelKeyboardProc, so that it is not garbage collected runtime`
`41`		`- hookedLowLevelKeyboardProc = LowLevelKeyboardProc;`
`42`	`29`	`// Set the hook`
`43`		`- hookId = InterceptKeys.SetHook(hookedLowLevelKeyboardProc);`
	`30`	`+ hookId = InterceptKeys.SetHook(& LowLevelKeyboardProc);`
`44`	`31`	`}`
`45`	`32`
`46`		`- public SpecialKeyState CheckModifiers()`
	`33`	`+ public static SpecialKeyState CheckModifiers()`
`47`	`34`	`{`
`48`	`35`	`SpecialKeyState state = new SpecialKeyState();`
`49`	`36`	`if ((InterceptKeys.GetKeyState(VK_SHIFT) & 0x8000) != 0)`
`@@ -70,8 +57,8 @@ public SpecialKeyState CheckModifiers()`
`70`	`57`	`return state;`
`71`	`58`	`}`
`72`	`59`
`73`		`- [MethodImpl(MethodImplOptions.NoInlining)]`
`74`		`- private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam)`
	`60`	`+ [UnmanagedCallersOnly]`
	`61`	`+ private static IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam)`
`75`	`62`	`{`
`76`	`63`	`bool continues = true;`
`77`	`64`
`@@ -91,17 +78,17 @@ private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam)`
`91`	`78`	`{`
`92`	`79`	`return InterceptKeys.CallNextHookEx(hookId, nCode, wParam, lParam);`
`93`	`80`	`}`
`94`		`- return (IntPtr)1;`
	`81`	`+ return (IntPtr)(-1);`
`95`	`82`	`}`
`96`	`83`
`97`		`- ~GlobalHotkey()`
	`84`	`+ public void Dispose()`
`98`	`85`	`{`
`99`		`- Dispose();`
	`86`	`+ InterceptKeys.UnhookWindowsHookEx(hookId);`
`100`	`87`	`}`
`101`	`88`
`102`		`- public void Dispose()`
	`89`	`+ ~GlobalHotkey()`
`103`	`90`	`{`
`104`		`- InterceptKeys.UnhookWindowsHookEx(hookId);`
	`91`	`+ Dispose();`
`105`	`92`	`}`
`106`	`93`	`}`
`107`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,13 +4,13 @@`
`4`	`4`
`5`	`5`	`namespace Flow.Launcher.Infrastructure.Hotkey`
`6`	`6`	`{`
`7`		`- internal static class InterceptKeys`
	`7`	`+ internal static unsafe class InterceptKeys`
`8`	`8`	`{`
`9`	`9`	`public delegate IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam);`
`10`	`10`
`11`	`11`	`private const int WH_KEYBOARD_LL = 13;`
`12`	`12`
`13`		`- public static IntPtr SetHook(LowLevelKeyboardProc proc)`
	`13`	`+ public static IntPtr SetHook(delegate* unmanaged<int, UIntPtr, IntPtr, IntPtr> proc)`
`14`	`14`	`{`
`15`	`15`	`using (Process curProcess = Process.GetCurrentProcess())`
`16`	`16`	`using (ProcessModule curModule = curProcess.MainModule)`
`@@ -20,7 +20,7 @@ public static IntPtr SetHook(LowLevelKeyboardProc proc)`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]`
`23`		`- public static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);`
	`23`	`+ public static extern IntPtr SetWindowsHookEx(int idHook, delegate* unmanaged<int, UIntPtr, IntPtr, IntPtr> lpfn, IntPtr hMod, uint dwThreadId);`
`24`	`24`
`25`	`25`	`[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]`
`26`	`26`	`[return: MarshalAs(UnmanagedType.Bool)]`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ private void InitializeKeyCommands()`
`208`	`208`	`{`
`209`	`209`	`bool hideWindow = result.Action != null && result.Action(new ActionContext`
`210`	`210`	`{`
`211`		`- SpecialKeyState = GlobalHotkey.Instance.CheckModifiers()`
	`211`	`+ SpecialKeyState = GlobalHotkey.CheckModifiers()`
`212`	`212`	`});`
`213`	`213`
`214`	`214`	`if (hideWindow)`
`@@ -244,8 +244,8 @@ private void InitializeKeyCommands()`
`244`	`244`	`autoCompleteText = SelectedResults.SelectedItem.QuerySuggestionText;`
`245`	`245`	`}`
`246`	`246`
`247`		`- var SpecialKeyState = GlobalHotkey.Instance.CheckModifiers();`
`248`		`- if (SpecialKeyState.ShiftPressed)`
	`247`	`+ var specialKeyState = GlobalHotkey.CheckModifiers();`
	`248`	`+ if (specialKeyState.ShiftPressed)`
`249`	`249`	`{`
`250`	`250`	`autoCompleteText = result.SubTitle;`
`251`	`251`	`}`
Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ public void Init(PluginInitContext context)`
`312`	`312`	`{`
`313`	`313`	`this.context = context;`
`314`	`314`	`_settings = context.API.LoadSettingJsonStorage<Settings>();`
`315`		`- context.API.GlobalKeyboardEvent += API_GlobalKeyboardEvent;`
	`315`	`+ context.API.RegisterGlobalKeyboardCallback(API_GlobalKeyboardEvent);`
`316`	`316`	`}`
`317`	`317`
`318`	`318`	`bool API_GlobalKeyboardEvent(int keyevent, int vkcode, SpecialKeyState state)`
`@@ -337,12 +337,9 @@ bool API_GlobalKeyboardEvent(int keyevent, int vkcode, SpecialKeyState state)`
`337`	`337`
`338`	`338`	`private void OnWinRPressed()`
`339`	`339`	`{`
`340`		`- context.API.ChangeQuery($"{context.CurrentPluginMetadata.ActionKeywords[0]}{Plugin.Query.TermSeparator}");`
`341`		`-`
`342`	`340`	`// show the main window and set focus to the query box`
`343`		`- Window mainWindow = Application.Current.MainWindow;`
`344`		`- mainWindow.Show();`
`345`		`- mainWindow.Focus();`
	`341`	`+ context.API.ShowMainWindow();`
	`342`	`+ context.API.ChangeQuery($"{context.CurrentPluginMetadata.ActionKeywords[0]}{Plugin.Query.TermSeparator}");`
`346`	`343`	`}`
`347`	`344`
`348`	`345`	`public Control CreateSettingPanel()`