Merge branch 'master' into switch-to-new-socket-lib

Author: theolivenbaum

ElectronNET.API/App.cs

@@ -16,95 +16,31 @@ public sealed class AutoUpdater
         /// <summary>
         /// Whether to automatically download an update when it is found. (Default is true)
         /// </summary>
-        public Task<bool> IsAutoDownloadEnabledAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<bool>("autoUpdater-autoDownload-get-reply", (result) =>
-            {
-                BridgeConnector.Off("autoUpdater-autoDownload-get-reply");
-                taskCompletionSource.SetResult(result);
-            });
-
-            BridgeConnector.Emit("autoUpdater-autoDownload-get");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> IsAutoDownloadEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-autoDownload-get", "autoUpdater-autoDownload-get-reply");
 
         /// <summary>
         /// Whether to automatically install a downloaded update on app quit (if `QuitAndInstall` was not called before).
         /// 
         /// Applicable only on Windows and Linux.
         /// </summary>
-        public Task<bool> IsAutoInstallOnAppQuitEnabledAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<bool>("autoUpdater-autoInstallOnAppQuit-get-reply", (result) =>
-            {
-                BridgeConnector.Off("autoUpdater-autoInstallOnAppQuit-get-reply");
-                taskCompletionSource.SetResult(result);
-            });
-
-            BridgeConnector.Emit("autoUpdater-autoInstallOnAppQuit-get");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> IsAutoInstallOnAppQuitEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-autoInstallOnAppQuit-get", "autoUpdater-autoInstallOnAppQuit-get-reply");
 
         /// <summary>
         /// *GitHub provider only.* Whether to allow update to pre-release versions. 
         /// Defaults to "true" if application version contains prerelease components (e.g. "0.12.1-alpha.1", here "alpha" is a prerelease component), otherwise "false".
         /// 
         /// If "true", downgrade will be allowed("allowDowngrade" will be set to "true").
         /// </summary>
-        public Task<bool> IsAllowPrereleaseEnabledAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<bool>("autoUpdater-allowPrerelease-get-reply", (result) =>
-            {
-                BridgeConnector.Off("autoUpdater-allowPrerelease-get-reply");
-                taskCompletionSource.SetResult(result);
-            });
-
-            BridgeConnector.Emit("autoUpdater-allowPrerelease-get");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> IsAllowPrereleaseEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-allowPrerelease-get", "autoUpdater-allowPrerelease-get-reply");
 
         /// <summary>
         /// *GitHub provider only.* 
         /// Get all release notes (from current version to latest), not just the latest (Default is false).
         /// </summary>
-        public Task<bool> IsFullChangeLogEnabledAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<bool>("autoUpdater-fullChangelog-get-reply", (result) =>
-            {
-                BridgeConnector.Off("autoUpdater-fullChangelog-get-reply");
-                taskCompletionSource.SetResult(result);
-            });
-
-            BridgeConnector.Emit("autoUpdater-fullChangelog-get");
-
-            return taskCompletionSource.Task;
-        }
-
-        public Task<bool> IsAllowDowngradeEnabledAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<bool>("autoUpdater-allowDowngrade-get-reply", (result) =>
-            {
-                BridgeConnector.Off("autoUpdater-allowDowngrade-get-reply");
-                taskCompletionSource.SetResult(result);
-            });
+        public Task<bool> IsFullChangeLogEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-fullChangelog-get", "autoUpdater-fullChangelog-get-reply");
 
-            BridgeConnector.Emit("autoUpdater-allowDowngrade-get");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<bool> IsAllowDowngradeEnabledAsync() => BridgeConnector.OnResult<bool>("autoUpdater-allowDowngrade-get", "autoUpdater-allowDowngrade-get-reply");
+        
 
         /// <summary>
         /// Whether to automatically download an update when it is found. (Default is true)
@@ -172,72 +108,23 @@ public bool AllowDowngrade
         /// <summary>
         /// For test only.
         /// </summary>
-        public Task<string> GetUpdateConfigPathAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<string>("autoUpdater-updateConfigPath-get-reply", (result) =>
-            {
-                BridgeConnector.Off("autoUpdater-updateConfigPath-get-reply");
-                taskCompletionSource.SetResult(result.ToString());
-            });
-
-            BridgeConnector.Emit("autoUpdater-updateConfigPath-get");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<string> GetUpdateConfigPathAsync() => BridgeConnector.OnResult<string>("autoUpdater-updateConfigPath-get", "autoUpdater-updateConfigPath-get-reply");
 
         /// <summary>
         /// The current application version
         /// </summary>
-        public Task<SemVer> GetCurrentVersionAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<SemVer>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<SemVer>("autoUpdater-currentVersion-get-reply", (version) =>
-            {
-                BridgeConnector.Off("autoUpdater-currentVersion-get-reply");
-                taskCompletionSource.SetResult(version);
-            });
-            BridgeConnector.Emit("autoUpdater-currentVersion-get");
-
-            return taskCompletionSource.Task;
-        }
+        public Task<SemVer> GetCurrentVersionAsync() => BridgeConnector.OnResult<SemVer>("autoUpdater-updateConcurrentVersionfigPath-get", "autoUpdater-currentVersion-get-reply");
 
         /// <summary>
         /// Get the update channel. Not applicable for GitHub. 
         /// Doesn’t return channel from the update configuration, only if was previously set.
         /// </summary>
-        public Task<string> GetChannelAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            BridgeConnector.On<string>("autoUpdater-channel-get-reply", (result) =>
-            {
-                BridgeConnector.Off("autoUpdater-channel-get-reply");
-                taskCompletionSource.SetResult(result.ToString());
-            });
-            BridgeConnector.Emit("autoUpdater-channel-get");
-
-            return taskCompletionSource.Task;
-        }
-
-
+        public Task<string> GetChannelAsync() => BridgeConnector.OnResult<string>("autoUpdater-channel-get", "autoUpdater-channel-get-reply");
 
         /// <summary>
         /// The request headers.
         /// </summary>
-        public Task<Dictionary<string, string>> GetRequestHeadersAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>(TaskCreationOptions.RunContinuationsAsynchronously);
-            BridgeConnector.On<Dictionary<string, string>>("autoUpdater-requestHeaders-get-reply", (headers) =>
-            {
-                BridgeConnector.Off("autoUpdater-requestHeaders-get-reply");
-                taskCompletionSource.SetResult(headers);
-            });
-            BridgeConnector.Emit("autoUpdater-requestHeaders-get");
-            return taskCompletionSource.Task;
-        }
+        public Task<Dictionary<string, string>> GetRequestHeadersAsync() => BridgeConnector.OnResult<Dictionary<string, string>>("autoUpdater-requestHeaders-get", "autoUpdater-requestHeaders-get-reply");
 
         /// <summary>
         /// The request headers.
@@ -246,7 +133,7 @@ public Dictionary<string, string> RequestHeaders
         {
             set
             {
-                BridgeConnector.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
+                BridgeConnector.Emit("autoUpdater-requestHeaders-set", value);
             }
         }
 
@@ -581,10 +468,5 @@ public Task<string> GetFeedURLAsync()
 
             return taskCompletionSource.Task;
         }
-
-        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver()
-        };
     }
 }

ElectronNET.API/AutoUpdater.cs

@@ -1,9 +1,13 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 using SocketIOClient;
+using SocketIOClient.JsonSerializer;
 using SocketIOClient.Newtonsoft.Json;
 
 namespace ElectronNET.API
@@ -149,7 +153,7 @@ public static void Once<T>(string eventString, Action<T> fn)
 
         public static async Task<T> OnResult<T>(string triggerEvent, string completedEvent, params object[] args)
         {
-            string eventKey = triggerEvent;
+            string eventKey = completedEvent;
 
             if (args is object && args.Length > 0) // If there are arguments passed, we generate a unique event key with the arguments
                                                    // this allow us to wait for previous events first before registering new ones
@@ -162,7 +166,7 @@ public static async Task<T> OnResult<T>(string triggerEvent, string completedEve
                 eventKey = $"{eventKey}-{(uint)hash.ToHashCode()}";
             }
 
-            if (EventTasks<T>.TryGetOrAdd(triggerEvent, eventKey, out var taskCompletionSource, out var waitThisFirstAndThenTryAgain))
+            if (EventTasks<T>.TryGetOrAdd(completedEvent, eventKey, out var taskCompletionSource, out var waitThisFirstAndThenTryAgain))
             {
                 if (waitThisFirstAndThenTryAgain is object)
                 {
@@ -188,7 +192,7 @@ public static async Task<T> OnResult<T>(string triggerEvent, string completedEve
                     {
                         Off(completedEvent);
                         taskCompletionSource.SetResult(result);
-                        EventTasks<T>.DoneWith(triggerEvent, eventKey, taskCompletionSource);
+                        EventTasks<T>.DoneWith(completedEvent, eventKey, taskCompletionSource);
                     });
 
                     Emit(triggerEvent, args);
@@ -201,21 +205,56 @@ public static async Task<T> OnResult<T>(string triggerEvent, string completedEve
 
         public static async Task<T> OnResult<T>(string triggerEvent, string completedEvent, CancellationToken cancellationToken, params object[] args)
         {
-            var taskCompletionSource = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
+            string eventKey = completedEvent;
 
-            using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+            if (args is object && args.Length > 0) // If there are arguments passed, we generate a unique event key with the arguments
+                                                   // this allow us to wait for previous events first before registering new ones
             {
+                var hash = new HashCode();
+                foreach (var obj in args)
+                {
+                    hash.Add(obj);
+                }
+                eventKey = $"{eventKey}-{(uint)hash.ToHashCode()}";
+            }
 
-                On<T>(completedEvent, (result) =>
+            if (EventTasks<T>.TryGetOrAdd(completedEvent, eventKey, out var taskCompletionSource, out var waitThisFirstAndThenTryAgain))
+            {
+                if (waitThisFirstAndThenTryAgain is object)
                 {
-                    Off(completedEvent);
-                    taskCompletionSource.SetResult(result);
-                });
+                    //There was a pending call with different parameters, so we need to wait that first and then call here again
+                    try
+                    {
+                        await Task.Run(() => waitThisFirstAndThenTryAgain, cancellationToken);
+                    }
+                    catch
+                    {
+                        //Ignore any exceptions here so we can set a new event below
+                        //The exception will also be visible to the original first caller due to taskCompletionSource.Task
+                    }
 
-                Emit(triggerEvent, args);
+                    //Try again to set the event
+                    return await OnResult<T>(triggerEvent, completedEvent, cancellationToken, args);
+                }
+                else
+                {
+                    using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
+                    {
+                        //A new TaskCompletionSource was added, so we need to register the completed event here
+
+                        On<T>(completedEvent, (result) =>
+                        {
+                            Off(completedEvent);
+                            taskCompletionSource.SetResult(result);
+                            EventTasks<T>.DoneWith(completedEvent, eventKey, taskCompletionSource);
+                        });
 
-                return await taskCompletionSource.Task.ConfigureAwait(false);
+                        Emit(triggerEvent, args);
+                    }
+                }
             }
+
+            return await taskCompletionSource.Task;
         }
         private static SocketIO Socket
         {
@@ -235,7 +274,7 @@ private static SocketIO Socket
                                     EIO = 3
                                 });
 
-                                socket.JsonSerializer = new NewtonsoftJsonSerializer(socket.Options.EIO);
+                                socket.JsonSerializer = new CamelCaseNewtonsoftJsonSerializer(socket.Options.EIO);
 
 
                                 socket.OnConnected += (_, __) =>
@@ -258,5 +297,22 @@ private static SocketIO Socket
                 return _socket;
             }
         }
+
+        private class CamelCaseNewtonsoftJsonSerializer : NewtonsoftJsonSerializer
+        {
+            public CamelCaseNewtonsoftJsonSerializer(int eio) : base(eio)
+            {
+            }
+
+            public override JsonSerializerSettings CreateOptions()
+            {
+                return new JsonSerializerSettings()
+                {
+                    ContractResolver = new CamelCasePropertyNamesContractResolver(),
+                    NullValueHandling = NullValueHandling.Ignore,
+                    DefaultValueHandling = DefaultValueHandling.Ignore
+                };
+            }
+        }
     }
 }

ElectronNET.API/BridgeConnector.cs

@@ -31,24 +31,11 @@ public class BrowserView
         /// 
         /// (experimental)
         /// </summary>
-        public Task<Rectangle> GetBoundsAsync()
-        {
-                var taskCompletionSource = new TaskCompletionSource<Rectangle>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-                BridgeConnector.On<Rectangle>("browserView-getBounds-reply", (result) =>
-                {
-                    BridgeConnector.Off("browserView-getBounds-reply");
-                    taskCompletionSource.SetResult(result);
-                });
-
-                BridgeConnector.Emit("browserView-getBounds", Id);
-
-            return taskCompletionSource.Task;
-        }
+        public Task<Rectangle> GetBoundsAsync() => BridgeConnector.OnResult<Rectangle>("browserView-getBounds", "browserView-getBounds-reply" + Id, Id);
 
         public void SetBounds(Rectangle value)
         {
-            BridgeConnector.Emit("browserView-setBounds", Id, JObject.FromObject(value, _jsonSerializer));
+            BridgeConnector.Emit("browserView-setBounds", Id, value);
         }
 
         /// <summary>
@@ -69,7 +56,7 @@ internal BrowserView(int id)
         /// <param name="options"></param>
         public void SetAutoResize(AutoResizeOptions options)
         {
-            BridgeConnector.Emit("browserView-setAutoResize", Id, JObject.FromObject(options, _jsonSerializer));
+            BridgeConnector.Emit("browserView-setAutoResize", Id, options);
         }
 
         /// <summary>
@@ -82,11 +69,5 @@ public void SetBackgroundColor(string color)
         {
             BridgeConnector.Emit("browserView-setBackgroundColor", Id, color);
         }
-
-        private JsonSerializer _jsonSerializer = new JsonSerializer()
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            NullValueHandling = NullValueHandling.Ignore
-        };
     }
 }