Merge remote-tracking branch 'upstream/master' into bug/442

Author: Dan Gidman

Changelog.md

@@ -1,9 +1,10 @@
 # Not released
 
-# 9.31.3
+# 11.5.1
 
 ElectronNET.CLI:
 
+* New Feature: Added new build and start commandline options for single exe (thanks [nathanwienand](https://github.com/nathanwienand)) [\#506](https://github.com/ElectronNET/Electron.NET/pull/506)
 * New Feature: Set a description of the app in `electron.manifest.json` (thanks [BurtsevC](https://github.com/BurtsevC)) [\#433](https://github.com/ElectronNET/Electron.NET/pull/433)
 * New Feature: Set a target for the start command (thanks [gabecook](https://github.com/gabecook)) [\#463](https://github.com/ElectronNET/Electron.NET/pull/463)
 * New Feature: `electronize init` support for F# projects (thanks [kojo12228](https://github.com/kojo12228)) [\#457](https://github.com/ElectronNET/Electron.NET/pull/457)
@@ -12,7 +13,12 @@ ElectronNET.CLI:
 
 ElectronNET.API:
 
-* New Feature: Native Electron 9.2.0 support, but not all new features (we search contributors)
+* New Feature: Native Electron 11.1.1 support, but not all new features (we search contributors)
+* Breaking API Changes (from native Electron 11.0): - Removed: BrowserView.{destroy, fromId, fromWebContents, getAllViews} and id property of BrowserView
+* New Feature: Upgrade to .NET 5 (thanks [scottkuhl](https://github.com/scottkuhl)) [\#509](https://github.com/ElectronNET/Electron.NET/pull/509)
+* New Feature: Adding a configurable default electron port. (thanks [aarong-av](https://github.com/aarong-av)) [\#505](https://github.com/ElectronNET/Electron.NET/pull/505)
+* New Feature: Added support for launching the application with a file on MacOS (thanks [dlitty](https://github.com/dlitty)) [\#478](https://github.com/ElectronNET/Electron.NET/pull/478)
+* Improved: Avoid Blocking Calls in App and AutoUpdater (thanks [freosc](https://github.com/freosc)) [\#474](https://github.com/ElectronNET/Electron.NET/pull/474)
 * Fixed bug: Set default WebPreferences.DefaultFontSize (thanks [duncanawoods](https://github.com/duncanawoods)) [\#468](https://github.com/ElectronNET/Electron.NET/pull/468)
 
 # Released

ElectronNET.API/App.cs

@@ -398,6 +398,70 @@ internal set
         }
         private bool _isReady = false;
 
+        /// <summary>
+        /// Emitted when a MacOS user wants to open a file with the application. The open-file event is usually emitted
+        /// when the application is already open and the OS wants to reuse the application to open the file.
+        /// open-file is also emitted when a file is dropped onto the dock and the application is not yet running.
+        /// <para/>
+        /// On Windows, you have to parse the arguments using App.CommandLine to get the filepath.
+        /// </summary>
+        public event Action<string> OpenFile
+        {
+            add
+            {
+                if (_openFile == null)
+                {
+                    BridgeConnector.Socket.On("app-open-file" + GetHashCode(), (file) =>
+                    {
+                        _openFile(file.ToString());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-app-open-file-event", GetHashCode());
+                }
+                _openFile += value;
+            }
+            remove
+            {
+                _openFile -= value;
+
+                if (_openFile == null)
+                    BridgeConnector.Socket.Off("app-open-file" + GetHashCode());
+            }
+        }
+
+        private event Action<string> _openFile;
+
+
+        /// <summary>
+        /// Emitted when a MacOS user wants to open a URL with the application. Your application's Info.plist file must
+        /// define the URL scheme within the CFBundleURLTypes key, and set NSPrincipalClass to AtomApplication.
+        /// </summary>
+        public event Action<string> OpenUrl
+        {
+            add
+            {
+                if (_openUrl == null)
+                {
+                    BridgeConnector.Socket.On("app-open-url" + GetHashCode(), (url) =>
+                    {
+                        _openUrl(url.ToString());
+                    });
+
+                    BridgeConnector.Socket.Emit("register-app-open-url-event", GetHashCode());
+                }
+                _openUrl += value;
+            }
+            remove
+            {
+                _openUrl -= value;
+
+                if (_openUrl == null)
+                    BridgeConnector.Socket.Off("app-open-url" + GetHashCode());
+            }
+        }
+
+        private event Action<string> _openUrl;
+
         /// <summary>
         /// A <see cref="string"/> property that indicates the current application's name, which is the name in the
         /// application's package.json file.
@@ -407,6 +471,27 @@ internal set
         /// which will be preferred over name by Electron.
         /// </summary>
         public string Name
+        {
+            [Obsolete("Use the asynchronous version NameAsync instead")]
+            get
+            {
+                return NameAsync.Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("appSetName", value);
+            }
+        }
+
+        /// <summary>
+        /// A <see cref="string"/> property that indicates the current application's name, which is the name in the
+        /// application's package.json file.
+        ///
+        /// Usually the name field of package.json is a short lowercase name, according to the npm modules spec. You
+        /// should usually also specify a productName field, which is your application's full capitalized name, and
+        /// which will be preferred over name by Electron.
+        /// </summary>
+        public Task<string> NameAsync
         {
             get
             {
@@ -423,14 +508,11 @@ public string Name
                     BridgeConnector.Socket.Emit("appGetName");
 
                     return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("appSetName", value);
+                });
             }
         }
 
+
         internal App() 
         {
             CommandLine = new CommandLine();
@@ -1479,6 +1561,27 @@ public void SetAboutPanelOptions(AboutPanelOptions options)
         /// is used.
         /// </summary>
         public string UserAgentFallback
+        {
+            [Obsolete("Use the asynchronous version UserAgentFallbackAsync instead")]
+            get
+            {
+                return UserAgentFallbackAsync.Result;
+            }
+            set
+            {
+                BridgeConnector.Socket.Emit("appSetUserAgentFallback", value);
+            }
+        }
+
+        /// <summary>
+        /// A <see cref="string"/> which is the user agent string Electron will use as a global fallback.
+        /// <para/>
+        /// This is the user agent that will be used when no user agent is set at the webContents or
+        /// session level. It is useful for ensuring that your entire app has the same user agent. Set to a
+        /// custom value as early as possible in your app's initialization to ensure that your overridden value
+        /// is used.
+        /// </summary>
+        public Task<string> UserAgentFallbackAsync
         {
             get
             {
@@ -1495,11 +1598,7 @@ public string UserAgentFallback
                     BridgeConnector.Socket.Emit("appGetUserAgentFallback");
 
                     return taskCompletionSource.Task;
-                }).Result;
-            }
-            set
-            {
-                BridgeConnector.Socket.Emit("appSetUserAgentFallback", value);
+                });
             }
         }
 

ElectronNET.API/AutoUpdater.cs

@@ -1,6 +1,9 @@
 using ElectronNET.API.Entities;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace ElectronNET.API
@@ -182,11 +185,48 @@ public string UpdateConfigPath
             }
         }
 
+        /// <summary>
+        /// The current application version
+        /// </summary>
+        public Task<SemVer> CurrentVersionAsync
+        {
+            get
+            {
+                return Task.Run<SemVer>(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<SemVer>();
+
+                    BridgeConnector.Socket.On("autoUpdater-currentVersion-get-reply", (result) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-currentVersion-get-reply");
+                        SemVer version = ((JObject)result).ToObject<SemVer>();
+                        taskCompletionSource.SetResult(version);
+                    });
+                    BridgeConnector.Socket.Emit("autoUpdater-currentVersion-get");
+
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
         /// <summary>
         /// Get the update channel. Not applicable for GitHub. 
         /// Doesn’t return channel from the update configuration, only if was previously set.
         /// </summary>
+        [Obsolete("Use the asynchronous version ChannelAsync instead")]
         public string Channel
+        {
+            get
+            {
+                return ChannelAsync.Result;
+            }
+        }
+
+        /// <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> ChannelAsync
         {
             get
             {
@@ -199,11 +239,45 @@ public string Channel
                         BridgeConnector.Socket.Off("autoUpdater-channel-get-reply");
                         taskCompletionSource.SetResult(result.ToString());
                     });
-
                     BridgeConnector.Socket.Emit("autoUpdater-channel-get");
 
                     return taskCompletionSource.Task;
-                }).Result;
+                });
+            }
+        }
+
+
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        public Task<Dictionary<string, string>> RequestHeadersAsync
+        {
+            get
+            {
+                return Task.Run(() =>
+                {
+                    var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>();
+                    BridgeConnector.Socket.On("autoUpdater-requestHeaders-get-reply", (headers) =>
+                    {
+                        BridgeConnector.Socket.Off("autoUpdater-requestHeaders-get-reply");
+                        Dictionary<string, string> result = ((JObject)headers).ToObject<Dictionary<string, string>>();
+                        taskCompletionSource.SetResult(result);
+                    });
+                    BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-get");
+                    return taskCompletionSource.Task;
+                });
+            }
+        }
+
+        /// <summary>
+        /// The request headers.
+        /// </summary>
+        public Dictionary<string, string> RequestHeaders
+        {
+            set
+            {
+                BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-set", JObject.FromObject(value, _jsonSerializer));
             }
         }
 
@@ -416,9 +490,26 @@ public Task<UpdateCheckResult> CheckForUpdatesAsync()
             string guid = Guid.NewGuid().ToString();
 
             BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesComplete" + guid, (updateCheckResult) =>
+            {
+                try
+                {
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
+                    taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                }
+                catch (Exception ex)
+                {
+                    taskCompletionSource.SetException(ex);
+                }
+            });
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesError" + guid, (error) =>
             {
                 BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
-                taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
+                string message = "An error occurred in CheckForUpdatesAsync";
+                if (error != null && !string.IsNullOrEmpty(error.ToString()))
+                    message = JsonConvert.SerializeObject(error);
+                taskCompletionSource.SetException(new Exception(message));
             });
 
             BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdates", guid);
@@ -438,9 +529,29 @@ public Task<UpdateCheckResult> CheckForUpdatesAndNotifyAsync()
             string guid = Guid.NewGuid().ToString();
 
             BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (updateCheckResult) =>
+            {
+                try
+                {
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
+                    BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                    if (updateCheckResult == null)
+                        taskCompletionSource.SetResult(null);
+                    else
+                        taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                }
+                catch (Exception ex)
+                {
+                    taskCompletionSource.SetException(ex);
+                }
+            });
+            BridgeConnector.Socket.On("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (error) =>
             {
                 BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
-                taskCompletionSource.SetResult(JObject.Parse(updateCheckResult.ToString()).ToObject<UpdateCheckResult>());
+                BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
+                string message = "An error occurred in autoUpdaterCheckForUpdatesAndNotify";
+                if (error != null)
+                    message = JsonConvert.SerializeObject(error);
+                taskCompletionSource.SetException(new Exception(message));
             });
 
             BridgeConnector.Socket.Emit("autoUpdaterCheckForUpdatesAndNotify", guid);
@@ -501,5 +612,10 @@ public Task<string> GetFeedURLAsync()
 
             return taskCompletionSource.Task;
         }
+
+        private readonly JsonSerializer _jsonSerializer = new JsonSerializer()
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver()
+        };
     }
 }