WingMan – Diff between revs 10 and 12

Subversion Repositories:

?pathlinks?

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

 ï»¿using System;
+using System.IO;
 using System.Net;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet;
         private async void ClientOnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
+        {
             try
-            {
-                var load = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
+            {
-                e.ApplicationMessage.Payload = AES.Decrypt(e.ApplicationMessage.Payload, Password);
-                var load2 = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
+                e.ApplicationMessage.Payload = await AES.Decrypt(e.ApplicationMessage.Payload, Password);
                 await Task.Delay(0, CancellationToken).ContinueWith(_ => OnMessageReceived?.Invoke(sender, e),
                     CancellationToken, TaskContinuationOptions.None, TaskScheduler);
         private async Task<bool> StartServer()
+        {
             var optionsBuilder = new MqttServerOptionsBuilder()
-                .WithDefaultEndpointBoundIPAddress(IpAddress)
-                .WithSubscriptionInterceptor(MqttSubscriptionIntercept)
-                .WithConnectionValidator(MqttConnectionValidator)
+                .WithDefaultEndpointBoundIPAddress(IpAddress)
                 .WithDefaultEndpointPort(Port);
+            }
             return Running;
-        }
-        private void MqttConnectionValidator(MqttConnectionValidatorContext context)
-        {
-            context.ReturnCode = MqttConnectReturnCode.ConnectionAccepted;
+        }
         private async Task StopServer()
+        {
             UnbindServerHandlers();
-            await Server.StopAsync();
-        }
-        private void MqttSubscriptionIntercept(MqttSubscriptionInterceptorContext context)
-        {
-            if (context.TopicFilter.Topic != "lobby" &&
-                context.TopicFilter.Topic != "exchange" &&
-                context.TopicFilter.Topic != "execute")
-            {
-                context.AcceptSubscription = false;
-                context.CloseConnection = true;
-                return;
-            }
             context.AcceptSubscription = true;
-            context.CloseConnection = false;
+            await Server.StopAsync();
+        }
         private void BindServerHandlers()
         private async void ServerOnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
+        {
             try
-            {
-                var load = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
+            {
-                e.ApplicationMessage.Payload = AES.Decrypt(e.ApplicationMessage.Payload, Password);
-                var load2 = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
+                e.ApplicationMessage.Payload = await AES.Decrypt(e.ApplicationMessage.Payload, Password);
                 await Task.Delay(0, CancellationToken).ContinueWith(_ => OnMessageReceived?.Invoke(sender, e),
                     CancellationToken, TaskContinuationOptions.None, TaskScheduler);
+        {
             await Task.Delay(0, CancellationToken).ContinueWith(_ => OnServerClientConnected?.Invoke(sender, e),
                 CancellationToken, TaskContinuationOptions.None, TaskScheduler);
+        }
-        private void ServerOnStopped(object sender, EventArgs e)
+        private async void ServerOnStopped(object sender, EventArgs e)
         {
+            await Task.Delay(0, CancellationToken).ContinueWith(_ => OnServerStopped?.Invoke(sender, e),
-            OnServerStopped?.Invoke(sender, e);
+                CancellationToken, TaskContinuationOptions.None, TaskScheduler);
         }
-        private void ServerOnStarted(object sender, EventArgs e)
+        private async void ServerOnStarted(object sender, EventArgs e)
+        {
             await Task.Delay(0, CancellationToken).ContinueWith(_ => OnServerStarted?.Invoke(sender, e),
-            OnServerStarted?.Invoke(sender, e);
+                CancellationToken, TaskContinuationOptions.None, TaskScheduler);
+        }
             Running = false;
+        }
         public async Task Broadcast(string topic, byte[] payload)
         {
-            var encryptedPayload = AES.Encrypt(payload, Password);
-            var load = Encoding.UTF8.GetString(encryptedPayload);
-            switch (Type)
+            using (var payloadStream = new MemoryStream(await AES.Encrypt(payload, Password)))
+            {
+                switch (Type)
-            {
+                {
-                case MqttCommunicationType.Client:
+                    case MqttCommunicationType.Client:
-                    await Client.PublishAsync(new ManagedMqttApplicationMessage
+                        await Client.PublishAsync(new []
-                    {
+                        {
+                            new MqttApplicationMessage
+                            {
+                                Topic = topic,
+                                Payload = payloadStream.ToArray(),
+                                QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce
-                        ApplicationMessage = new MqttApplicationMessage {Topic = topic, Payload = encryptedPayload }
+                            }
-                    });
+                        });
-                    break;
+                        break;
+                    case MqttCommunicationType.Server:
+                        await Server.PublishAsync(new[]
+                        {
+                            new MqttApplicationMessage
+                            {
+                                Topic = topic,
-                case MqttCommunicationType.Server:
+                                Payload = payloadStream.ToArray(),
+                                QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce
+                            }
-                    await Server.PublishAsync(new MqttApplicationMessage {Topic = topic, Payload = encryptedPayload });
+                        });
+                        break;
                     break;
+            }
+        }
+    }