WingMan – Diff between revs 10 and 14

Subversion Repositories:

?pathlinks?

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

Only display areas with differences – Ignore whitespace

 ï»¿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);
+        private volatile bool ProcessPipe;
         public KeyInterceptor(RemoteKeyBindings remoteKeyBindings, MqttCommunication mqttCommunication,
             TaskScheduler taskScheduler, CancellationToken cancellationToken)
+        {
+            DataFlowSemaphoreSlim = new SemaphoreSlim(1, 1);
             RemoteKeyBindings = remoteKeyBindings;
+            RemoteKeyBindings.Bindings.CollectionChanged += OnRemoteKeyBindingsChanged;
             MqttCommunication = mqttCommunication;
             TaskScheduler = taskScheduler;
             CancellationToken = cancellationToken;
-            KeyCombo = new List<string>();
             MouseKeyGloalHook = Hook.GlobalEvents();
             MouseKeyGloalHook.KeyUp += MouseKeyGloalHookOnKeyUp;
             MouseKeyGloalHook.KeyDown += MouseKeyGloalHookOnKeyDown;
+        }
+        private BatchBlock<string> KeyComboBatchBlock { get; set; }
+        private ActionBlock<string[]> KeyComboActionBlock { get; set; }
+        private IDisposable KeyComboDataFlowLink { get; set; }
+        private SemaphoreSlim DataFlowSemaphoreSlim { get; }
         private RemoteKeyBindings RemoteKeyBindings { get; }
         private MqttCommunication MqttCommunication { get; }
         private TaskScheduler TaskScheduler { get; }
         private CancellationToken CancellationToken { get; }
-        private IKeyboardMouseEvents MouseKeyGloalHook { get; }
-        public List<string> KeyCombo { get; set; }
+        private IKeyboardMouseEvents MouseKeyGloalHook { get; set; }
         public void Dispose()
+        {
             MouseKeyGloalHook.KeyUp -= MouseKeyGloalHookOnKeyUp;
             MouseKeyGloalHook.KeyDown -= MouseKeyGloalHookOnKeyDown;
+            RemoteKeyBindings.Bindings.CollectionChanged -= OnRemoteKeyBindingsChanged;
-            MouseKeyGloalHook.Dispose();
+            KeyComboDataFlowLink?.Dispose();
-        }
+            KeyComboDataFlowLink = null;
+            MouseKeyGloalHook?.Dispose();
+            MouseKeyGloalHook = null;
         public event MouseKeyBindingMatched OnMouseKeyBindingMatched;
+        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);
-        private void MouseKeyGloalHookOnKeyDown(object sender, KeyEventArgs e)
+                KeyComboBatchBlock =
+                    new BatchBlock<string>(maxKeyComboLength);
+                KeyComboActionBlock = new ActionBlock<string[]>(ProcessKeyCombos,
+                    new ExecutionDataflowBlockOptions {CancellationToken = CancellationToken});
+                KeyComboDataFlowLink = KeyComboBatchBlock.LinkTo(KeyComboActionBlock);
+            }
             finally
-            e.SuppressKeyPress = false;
+            {
                 DataFlowSemaphoreSlim.Release();
-            if (KeyConversion.KeysToString.TryGetValue((byte) e.KeyCode, out var key)) KeyCombo.Add(key);
+            }
+        }
-        }
+        private async Task ProcessKeyCombos(string[] keys)
+        {
+            await DataFlowSemaphoreSlim.WaitAsync(CancellationToken);
-        private void MouseKeyGloalHookOnKeyUp(object sender, KeyEventArgs e)
+            try
-        {
+            {
+                if (!ProcessPipe)
+                    return;
-            e.SuppressKeyPress = false;
+                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,
+                                new KeyBindingMatchedEventArgs(binding.Nick, binding.Name, binding.Keys)),
+                            CancellationToken,
-            var combo = new List<string>(KeyCombo);
+                            TaskContinuationOptions.None, TaskScheduler);
+                    using (var memoryStream = new MemoryStream())
+                    {
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+                        ExecuteKeyBinding.XmlSerializer.Serialize(memoryStream,
-            Task.Run(() => SimulateMouseKey(new List<string>(combo)), CancellationToken);
+                            new ExecuteKeyBinding(binding.Nick, binding.Name));
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+                        memoryStream.Position = 0L;
-            KeyCombo.Clear();
-        }
-        private async Task SimulateMouseKey(List<string> mouseKeyCombo)
+                        await MqttCommunication.Broadcast("execute", memoryStream.ToArray());
-        {
-            foreach (var binding in RemoteKeyBindings.Bindings)
-            {
-                if (!binding.Keys.SequenceEqual(mouseKeyCombo))
+                    }
-                    continue;
+                }
-                // Raise the match event.
+            }
+            finally
-                await Task.Delay(0, CancellationToken)
+            {
-                    .ContinueWith(
+                DataFlowSemaphoreSlim.Release();
+            }
+        }
-                        _ => OnMouseKeyBindingMatched?.Invoke(this,
+        public event MouseKeyBindingMatched OnMouseKeyBindingMatched;
+        private async void MouseKeyGloalHookOnKeyDown(object sender, KeyEventArgs e)
+        {
-                            new KeyBindingMatchedEventArgs(binding.Nick, binding.Name, binding.Keys)),
+            ProcessPipe = true;
                         CancellationToken,
+            if (!KeyConversion.KeysToString.TryGetValue((byte) e.KeyCode, out var key))
+                return;
+            await DataFlowSemaphoreSlim.WaitAsync(CancellationToken);
+            try
                         TaskContinuationOptions.None, TaskScheduler);
                 if (KeyComboBatchBlock != null) await KeyComboBatchBlock.SendAsync(key, CancellationToken);
                 using (var memoryStream = new MemoryStream())
             finally
                     ExecuteKeyBinding.XmlSerializer.Serialize(memoryStream,
-                        new ExecuteKeyBinding(binding.Nick, binding.Name));
+                DataFlowSemaphoreSlim.Release();
+            }
                     memoryStream.Position = 0L;
-                    await MqttCommunication.Broadcast("execute", memoryStream.ToArray());
+        private void MouseKeyGloalHookOnKeyUp(object sender, KeyEventArgs e)
+        {
             ProcessPipe = false;
+        }
+    }
+}