WingMan – Diff between revs 10 and 14

Subversion Repositories:

?pathlinks?

Rev 10 – Rev 21 – Go to most recent revision – Details – Blame – Last modification – View Log

 ï»¿using System;
-using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Threading.Tasks.Dataflow;
 using System.Windows.Forms;
 using Gma.System.MouseKeyHook;
 using WingMan.Communication;
+using WingMan.Utilities;
-namespace WingMan.MouseKey
+namespace WingMan.Bindings
+{
     public class KeyInterceptor : IDisposable
+    {
+        public delegate void MouseKeyBindingMatched(object sender, KeyBindingMatchedEventArgs args);
-        public delegate void MouseKeyBindingMatched(object sender, KeyBindingMatchedEventArgs args);
+        private volatile bool ProcessPipe;
         public KeyInterceptor(RemoteKeyBindings remoteKeyBindings, MqttCommunication mqttCommunication,
+            TaskScheduler taskScheduler, CancellationToken cancellationToken)
+        {
-            TaskScheduler taskScheduler, CancellationToken cancellationToken)
+            DataFlowSemaphoreSlim = new SemaphoreSlim(1, 1);
+            RemoteKeyBindings = remoteKeyBindings;
             RemoteKeyBindings.Bindings.CollectionChanged += OnRemoteKeyBindingsChanged;
             RemoteKeyBindings = remoteKeyBindings;
             MqttCommunication = mqttCommunication;
-            TaskScheduler = taskScheduler;
-            CancellationToken = cancellationToken;
             TaskScheduler = taskScheduler;
-            KeyCombo = new List<string>();
+            CancellationToken = cancellationToken;
             MouseKeyGloalHook = Hook.GlobalEvents();
+            MouseKeyGloalHook.KeyUp += MouseKeyGloalHookOnKeyUp;
+            MouseKeyGloalHook.KeyDown += MouseKeyGloalHookOnKeyDown;
+        }
+        private BatchBlock<string> KeyComboBatchBlock { get; set; }
+        private ActionBlock<string[]> KeyComboActionBlock { get; set; }
-            MouseKeyGloalHook.KeyUp += MouseKeyGloalHookOnKeyUp;
+        private IDisposable KeyComboDataFlowLink { get; set; }
             MouseKeyGloalHook.KeyDown += MouseKeyGloalHookOnKeyDown;
         private SemaphoreSlim DataFlowSemaphoreSlim { get; }
         private RemoteKeyBindings RemoteKeyBindings { get; }
-        private MqttCommunication MqttCommunication { get; }
-        private TaskScheduler TaskScheduler { get; }
-        private CancellationToken CancellationToken { get; }
+        private MqttCommunication MqttCommunication { get; }
         private TaskScheduler TaskScheduler { get; }
-        private IKeyboardMouseEvents MouseKeyGloalHook { get; }
+        private CancellationToken CancellationToken { get; }
+        private IKeyboardMouseEvents MouseKeyGloalHook { get; set; }
-        public List<string> KeyCombo { get; set; }
+        public void Dispose()
-        public void Dispose()
+        {
+            MouseKeyGloalHook.KeyUp -= MouseKeyGloalHookOnKeyUp;
+            MouseKeyGloalHook.KeyDown -= MouseKeyGloalHookOnKeyDown;
-        {
+            RemoteKeyBindings.Bindings.CollectionChanged -= OnRemoteKeyBindingsChanged;
             MouseKeyGloalHook.KeyUp -= MouseKeyGloalHookOnKeyUp;
-            MouseKeyGloalHook.KeyDown -= MouseKeyGloalHookOnKeyDown;
+            KeyComboDataFlowLink?.Dispose();
+            KeyComboDataFlowLink = null;
+            MouseKeyGloalHook?.Dispose();
+            MouseKeyGloalHook = null;
+        }
+        private async void OnRemoteKeyBindingsChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            await DataFlowSemaphoreSlim.WaitAsync(CancellationToken);
+            try
+            {
+                // Break the link and dispose it.
+                KeyComboDataFlowLink?.Dispose();
+                KeyComboDataFlowLink = null;
+                // Create a sliding window of size equal to the longest key combination.
+                var maxKeyComboLength = RemoteKeyBindings.Bindings.Max(binding => binding.Keys.Count);
-            MouseKeyGloalHook.Dispose();
+                KeyComboBatchBlock =
-        }
+                    new BatchBlock<string>(maxKeyComboLength);
                 KeyComboActionBlock = new ActionBlock<string[]>(ProcessKeyCombos,
-        public event MouseKeyBindingMatched OnMouseKeyBindingMatched;
+                    new ExecutionDataflowBlockOptions {CancellationToken = CancellationToken});
+                KeyComboDataFlowLink = KeyComboBatchBlock.LinkTo(KeyComboActionBlock);
+            }
+            finally
+            {
-        private void MouseKeyGloalHookOnKeyDown(object sender, KeyEventArgs e)
+                DataFlowSemaphoreSlim.Release();
+            }
-        {
+        }
-            e.SuppressKeyPress = false;
+        private async Task ProcessKeyCombos(string[] keys)
+        {
+            await DataFlowSemaphoreSlim.WaitAsync(CancellationToken);
+            try
+            {
+                if (!ProcessPipe)
+                    return;
-            if (KeyConversion.KeysToString.TryGetValue((byte) e.KeyCode, out var key)) KeyCombo.Add(key);
+                foreach (var binding in RemoteKeyBindings.Bindings)
+                {
+                    if (!keys.SubsetEquals(binding.Keys))
+                        continue;
-        }
+                    // Raise the match event.
+                    await Task.Delay(0, CancellationToken)
+                        .ContinueWith(
+                            _ => OnMouseKeyBindingMatched?.Invoke(this,
-        private void MouseKeyGloalHookOnKeyUp(object sender, KeyEventArgs e)
+                                new KeyBindingMatchedEventArgs(binding.Nick, binding.Name, binding.Keys)),
                             CancellationToken,
-            e.SuppressKeyPress = false;
+                            TaskContinuationOptions.None, TaskScheduler);
+                    using (var memoryStream = new MemoryStream())
-            var combo = new List<string>(KeyCombo);
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(() => SimulateMouseKey(new List<string>(combo)), CancellationToken);
+                    {
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            KeyCombo.Clear();
-        }
+                        ExecuteKeyBinding.XmlSerializer.Serialize(memoryStream,
+                            new ExecuteKeyBinding(binding.Nick, binding.Name));
-        private async Task SimulateMouseKey(List<string> mouseKeyCombo)
-        {
+                        memoryStream.Position = 0L;
-            foreach (var binding in RemoteKeyBindings.Bindings)
-            {
+                        await MqttCommunication.Broadcast("execute", memoryStream.ToArray());
+                    }
+                }
+            }
-                if (!binding.Keys.SequenceEqual(mouseKeyCombo))
+            finally
+            {
+                DataFlowSemaphoreSlim.Release();
+            }
                     continue;
+        public event MouseKeyBindingMatched OnMouseKeyBindingMatched;
+        private async void MouseKeyGloalHookOnKeyDown(object sender, KeyEventArgs e)
+        {
+            ProcessPipe = true;
                 // Raise the match event.
-                await Task.Delay(0, CancellationToken)
+            if (!KeyConversion.KeysToString.TryGetValue((byte) e.KeyCode, out var key))