WingMan – Rev 36

?pathlinks?

Rev 35 – Blame – Compare with Previous – Last modification – View Log – Download

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using ProtoBuf;
using WingMan.Communication;

namespace WingMan.Bindings
{
    public class KeyBindingsSynchronizer : IDisposable
    {
        public delegate void MouseKeyBindingsSynchronized(object sender, KeyBindingsSynchronizerEventArgs e);

        public KeyBindingsSynchronizer(LocalKeyBindings localKeyBindings, MqttCommunication mqttCommunication,
            TaskScheduler taskScheduler, CancellationToken cancellationToken)
        {
            LocalKeyBindings = localKeyBindings;
            MqttCommunication = mqttCommunication;
            CancellationToken = cancellationToken;
            TaskScheduler = taskScheduler;

            SynchronizedMouseKeyBindings = new ConcurrentDictionary<string, List<string>>();

            MqttCommunication.OnMessageReceived += MqttCommunicationOnMessageReceived;

            Task.Run(PeriodicSynchronize, CancellationToken);
        }

        private LocalKeyBindings LocalKeyBindings { get; }

        private ConcurrentDictionary<string, List<string>> SynchronizedMouseKeyBindings { get; }

        private MqttCommunication MqttCommunication { get; }

        private CancellationToken CancellationToken { get; }
        private TaskScheduler TaskScheduler { get; }

        public void Dispose()
        {
            MqttCommunication.OnMessageReceived -= MqttCommunicationOnMessageReceived;
        }

        public event MouseKeyBindingsSynchronized OnMouseKeyBindingsSynchronized;

        private async void MqttCommunicationOnMessageReceived(object sender,
            MqttCommunicationMessageReceivedEventArgs e)
        {
            if (e.Topic != "exchange")
                return;

            using (var memoryStream = new MemoryStream())
            {
                await e.PayloadStream.CopyToAsync(memoryStream);

                memoryStream.Position = 0L;

                var mouseKeyBindingsExchange =
                    Serializer.Deserialize<KeyBindingExchange>(memoryStream);

                // Do not add own bindings.
                if (string.Equals(mouseKeyBindingsExchange.Nick, MqttCommunication.Nick))
                    return;

                if (SynchronizedMouseKeyBindings.TryGetValue(mouseKeyBindingsExchange.Nick, out var mouseKeyBinding) &&
                    mouseKeyBinding.SequenceEqual(mouseKeyBindingsExchange.KeyBindings))
                    return;

                await Task.Delay(0)
                    .ContinueWith(
                        _ => OnMouseKeyBindingsSynchronized?.Invoke(sender,
                            new KeyBindingsSynchronizerEventArgs(
                                mouseKeyBindingsExchange)),
                        CancellationToken, TaskContinuationOptions.None, TaskScheduler);

                // Nick does not exist so the bindings will be added.
                SynchronizedMouseKeyBindings.AddOrUpdate(mouseKeyBindingsExchange.Nick,
                    mouseKeyBindingsExchange.KeyBindings, (s, list) => mouseKeyBindingsExchange.KeyBindings);
            }
        }

        private async Task PeriodicSynchronize()
        {
            do
            {
                await Task.Delay(1000, CancellationToken);

                if (!MqttCommunication.Running)
                    continue;

                using (var memoryStream = new MemoryStream())
                {
                    Serializer.Serialize(memoryStream,
                        new KeyBindingExchange(MqttCommunication.Nick,
                            LocalKeyBindings.Bindings.Select(binding => binding.Name).ToList()));

                    memoryStream.Position = 0L;

                    await MqttCommunication.Broadcast("exchange", memoryStream.ToArray());
                }
            } while (!CancellationToken.IsCancellationRequested);
        }
    }
}