starred/Electron.NET
1
0
Fork 0
mirror of https://github.com/ElectronNET/Electron.NET.git synced 2026-02-04 05:34:51 +00:00
Code Issues 668 Packages Projects Releases 20 Wiki Activity

Merge pull request #920 from Denny09310/feature/using-once

Browse Source 
feat: Add "Once" socket listener registration for one-time handlers
This commit is contained in:
Florian Rappl
2025-11-10 22:29:01 +01:00
committed by GitHub
parent 14bf7fdcd8 9a0a494bc5
commit 979cf72d4c
24 changed files with 310 additions and 750 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/ElectronNET.API/API/ApiBase.cs
View File

@@ -152,10 +152,8 @@
var messageName = apiBase.propertyMessageNames.GetOrAdd(callerName, s => apiBase.objectName + s.StripAsync());
BridgeConnector.Socket.On<T>(eventName, (result) =>
BridgeConnector.Socket.Once<T>(eventName, (result) =>
{
BridgeConnector.Socket.Off(eventName);
lock (this)
{
try

71
src/ElectronNET.API/API/App.cs
View File

@@ -547,13 +547,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<string>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<string>("appGetPathCompleted", (path) =>
{
BridgeConnector.Socket.Off("appGetPathCompleted");
taskCompletionSource.SetResult(path);
});
BridgeConnector.Socket.Once<string>("appGetPathCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appGetPath", pathName.GetDescription());
return await taskCompletionSource.Task
@@ -716,12 +710,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("appSetAsDefaultProtocolClientCompleted", (success) =>
{
BridgeConnector.Socket.Off("appSetAsDefaultProtocolClientCompleted");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("appSetAsDefaultProtocolClientCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appSetAsDefaultProtocolClient", protocol, path, args);
return await taskCompletionSource.Task
@@ -770,12 +759,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("appRemoveAsDefaultProtocolClientCompleted", (success) =>
{
BridgeConnector.Socket.Off("appRemoveAsDefaultProtocolClientCompleted");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("appRemoveAsDefaultProtocolClientCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appRemoveAsDefaultProtocolClient", protocol, path, args);
return await taskCompletionSource.Task
@@ -842,12 +826,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("appIsDefaultProtocolClientCompleted", (success) =>
{
BridgeConnector.Socket.Off("appIsDefaultProtocolClientCompleted");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("appIsDefaultProtocolClientCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appIsDefaultProtocolClient", protocol, path, args);
return await taskCompletionSource.Task
@@ -870,12 +849,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("appSetUserTasksCompleted", (success) =>
{
BridgeConnector.Socket.Off("appSetUserTasksCompleted");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("appSetUserTasksCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appSetUserTasks", userTasks);
return await taskCompletionSource.Task
@@ -943,11 +917,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("appRequestSingleInstanceLockCompleted", (success) =>
{
BridgeConnector.Socket.Off("appRequestSingleInstanceLockCompleted");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("appRequestSingleInstanceLockCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Off("secondInstance");
BridgeConnector.Socket.On<JsonElement>("secondInstance", (result) =>
@@ -1069,12 +1039,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<int>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<int>("appImportCertificateCompleted", (result) =>
{
BridgeConnector.Socket.Off("appImportCertificateCompleted");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<int>("appImportCertificateCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appImportCertificate", options);
return await taskCompletionSource.Task
@@ -1125,12 +1090,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("appSetBadgeCountCompleted", (success) =>
{
BridgeConnector.Socket.Off("appSetBadgeCountCompleted");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("appSetBadgeCountCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appSetBadgeCount", count);
return await taskCompletionSource.Task
@@ -1185,11 +1145,7 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<LoginItemSettings>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
BridgeConnector.Socket.On<LoginItemSettings>("appGetLoginItemSettingsCompleted", (result) =>
{
BridgeConnector.Socket.Off("appGetLoginItemSettingsCompleted");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<LoginItemSettings>("appGetLoginItemSettingsCompleted", taskCompletionSource.SetResult);
if (options == null)
{
@@ -1304,13 +1260,8 @@ namespace ElectronNET.API
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("appGetUserAgentFallbackCompleted", (result) =>
{
BridgeConnector.Socket.Off("appGetUserAgentFallbackCompleted");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<string>("appGetUserAgentFallbackCompleted", taskCompletionSource.SetResult);
BridgeConnector.Socket.Emit("appGetUserAgentFallback");
return taskCompletionSource.Task;

132
src/ElectronNET.API/API/AutoUpdater.cs
View File

@@ -24,17 +24,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("autoUpdater-autoDownload-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-autoDownload-get-reply");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("autoUpdater-autoDownload-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-autoDownload-get");
return taskCompletionSource.Task;
return tcs.Task;
}).Result;
}
set
@@ -54,17 +49,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("autoUpdater-autoInstallOnAppQuit-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-autoInstallOnAppQuit-get-reply");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("autoUpdater-autoInstallOnAppQuit-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-autoInstallOnAppQuit-get");
return taskCompletionSource.Task;
return tcs.Task;
}).Result;
}
set
@@ -85,17 +75,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("autoUpdater-allowPrerelease-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-allowPrerelease-get-reply");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("autoUpdater-allowPrerelease-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-allowPrerelease-get");
return taskCompletionSource.Task;
return tcs.Task;
}).Result;
}
set
@@ -114,17 +99,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("autoUpdater-fullChangelog-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-fullChangelog-get-reply");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("autoUpdater-fullChangelog-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-fullChangelog-get");
return taskCompletionSource.Task;
return tcs.Task;
}).Result;
}
set
@@ -144,17 +124,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("autoUpdater-allowDowngrade-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-allowDowngrade-get-reply");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("autoUpdater-allowDowngrade-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-allowDowngrade-get");
return taskCompletionSource.Task;
return tcs.Task;
}).Result;
}
set
@@ -172,17 +147,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("autoUpdater-updateConfigPath-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-updateConfigPath-get-reply");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("autoUpdater-updateConfigPath-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-updateConfigPath-get");
return taskCompletionSource.Task;
return tcs.Task;
}).Result;
}
}
@@ -196,16 +166,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<SemVer>();
var tcs = new TaskCompletionSource<SemVer>();
BridgeConnector.Socket.On<SemVer>("autoUpdater-currentVersion-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-currentVersion-get-reply");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<SemVer>("autoUpdater-currentVersion-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-currentVersion-get");
return taskCompletionSource.Task;
return tcs.Task;
});
}
}
@@ -233,16 +199,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<string>();
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("autoUpdater-channel-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-channel-get-reply");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<string>("autoUpdater-channel-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-channel-get");
return taskCompletionSource.Task;
return tcs.Task;
});
}
}
@@ -257,14 +219,12 @@ namespace ElectronNET.API
{
return Task.Run(() =>
{
var taskCompletionSource = new TaskCompletionSource<Dictionary<string, string>>();
BridgeConnector.Socket.On<Dictionary<string, string>>("autoUpdater-requestHeaders-get-reply", (result) =>
{
BridgeConnector.Socket.Off("autoUpdater-requestHeaders-get-reply");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<Dictionary<string, string>>();
BridgeConnector.Socket.Once<Dictionary<string, string>>("autoUpdater-requestHeaders-get-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdater-requestHeaders-get");
return taskCompletionSource.Task;
return tcs.Task;
});
}
}
@@ -382,11 +342,10 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<UpdateCheckResult>("autoUpdaterCheckForUpdatesComplete" + guid, (result) =>
BridgeConnector.Socket.Once<UpdateCheckResult>("autoUpdaterCheckForUpdatesComplete" + guid, (result) =>
{
try
{
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
taskCompletionSource.SetResult(result);
}
@@ -395,10 +354,9 @@ namespace ElectronNET.API
taskCompletionSource.SetException(ex);
}
});
BridgeConnector.Socket.On<string>("autoUpdaterCheckForUpdatesError" + guid, (result) =>
BridgeConnector.Socket.Once<string>("autoUpdaterCheckForUpdatesError" + guid, (result) =>
{
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesComplete" + guid);
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesError" + guid);
string message = "An error occurred in CheckForUpdatesAsync";
if (!string.IsNullOrEmpty(result)) message = result;
taskCompletionSource.SetException(new Exception(message));
@@ -420,11 +378,10 @@ namespace ElectronNET.API
var taskCompletionSource = new TaskCompletionSource<UpdateCheckResult>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<UpdateCheckResult>("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (result) =>
BridgeConnector.Socket.Once<UpdateCheckResult>("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid, (result) =>
{
try
{
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
taskCompletionSource.SetResult(result);
}
@@ -433,10 +390,9 @@ namespace ElectronNET.API
taskCompletionSource.SetException(ex);
}
});
BridgeConnector.Socket.On<string>("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (result) =>
BridgeConnector.Socket.Once<string>("autoUpdaterCheckForUpdatesAndNotifyError" + guid, (result) =>
{
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyComplete" + guid);
BridgeConnector.Socket.Off("autoUpdaterCheckForUpdatesAndNotifyError" + guid);
string message = "An error occurred in autoUpdaterCheckForUpdatesAndNotify";
if (!string.IsNullOrEmpty(result)) message = result;
taskCompletionSource.SetException(new Exception(message));
@@ -467,18 +423,13 @@ namespace ElectronNET.API
/// <returns>Path to downloaded file.</returns>
public Task<string> DownloadUpdateAsync()
{
var taskCompletionSource = new TaskCompletionSource<string>();
var tcs = new TaskCompletionSource<string>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string>("autoUpdaterDownloadUpdateComplete" + guid, (downloadedPath) =>
{
BridgeConnector.Socket.Off("autoUpdaterDownloadUpdateComplete" + guid);
taskCompletionSource.SetResult(downloadedPath);
});
BridgeConnector.Socket.Once<string>("autoUpdaterDownloadUpdateComplete" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdaterDownloadUpdate", guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -487,18 +438,13 @@ namespace ElectronNET.API
/// <returns>Feed URL.</returns>
public Task<string> GetFeedURLAsync()
{
var taskCompletionSource = new TaskCompletionSource<string>();
var tcs = new TaskCompletionSource<string>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string>("autoUpdaterGetFeedURLComplete" + guid, (downloadedPath) =>
{
BridgeConnector.Socket.Off("autoUpdaterGetFeedURLComplete" + guid);
taskCompletionSource.SetResult(downloadedPath);
});
BridgeConnector.Socket.Once<string>("autoUpdaterGetFeedURLComplete" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("autoUpdaterGetFeedURL", guid);
return taskCompletionSource.Task;
return tcs.Task;
}

11
src/ElectronNET.API/API/BrowserView.cs
View File

@@ -30,20 +30,15 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<Rectangle>();
var tcs = new TaskCompletionSource<Rectangle>();
Task.Run(() =>
{
BridgeConnector.Socket.On<Rectangle>("browserView-getBounds-reply", (result) =>
{
BridgeConnector.Socket.Off("browserView-getBounds-reply");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<Rectangle>("browserView-getBounds-reply", tcs.SetResult);
BridgeConnector.Socket.Emit("browserView-getBounds", Id);
});
return taskCompletionSource.Task.GetAwaiter().GetResult();
return tcs.Task.GetAwaiter().GetResult();
}
set
{

11
src/ElectronNET.API/API/BrowserWindow.cs
View File

@@ -1008,14 +1008,9 @@ public class BrowserWindow : ApiBase
/// <returns>Whether the buttons were added successfully.</returns>
public Task<bool> SetThumbarButtonsAsync(ThumbarButton[] thumbarButtons)
{
var taskCompletionSource = new TaskCompletionSource<bool>();
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("browserWindowSetThumbarButtons-completed", (success) =>
{
BridgeConnector.Socket.Off("browserWindowSetThumbarButtons-completed");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("browserWindowSetThumbarButtons-completed", tcs.SetResult);
thumbarButtons.AddThumbarButtonsId();
BridgeConnector.Socket.Emit("browserWindowSetThumbarButtons", Id, thumbarButtons);
@@ -1029,7 +1024,7 @@ public class BrowserWindow : ApiBase
thumbarButton?.Click();
});
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>

80
src/ElectronNET.API/API/Clipboard.cs
View File

@@ -43,18 +43,12 @@ namespace ElectronNET.API
/// <returns>The content in the clipboard as plain text.</returns>
public Task<string> ReadTextAsync(string type = "")
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("clipboard-readText-Completed", (text) =>
{
BridgeConnector.Socket.Off("clipboard-readText-Completed");
taskCompletionSource.SetResult(text);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("clipboard-readText-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("clipboard-readText", type);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -74,18 +68,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<string> ReadHTMLAsync(string type = "")
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("clipboard-readHTML-Completed", (text) =>
{
BridgeConnector.Socket.Off("clipboard-readHTML-Completed");
taskCompletionSource.SetResult(text);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("clipboard-readHTML-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("clipboard-readHTML", type);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -105,18 +93,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<string> ReadRTFAsync(string type = "")
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("clipboard-readRTF-Completed", (text) =>
{
BridgeConnector.Socket.Off("clipboard-readRTF-Completed");
taskCompletionSource.SetResult(text);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("clipboard-readRTF-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("clipboard-readRTF", type);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -137,17 +119,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<ReadBookmark> ReadBookmarkAsync()
{
var taskCompletionSource = new TaskCompletionSource<ReadBookmark>();
BridgeConnector.Socket.On<ReadBookmark>("clipboard-readBookmark-Completed", (result) =>
{
BridgeConnector.Socket.Off("clipboard-readBookmark-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<ReadBookmark>();
BridgeConnector.Socket.Once<ReadBookmark>("clipboard-readBookmark-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("clipboard-readBookmark");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -173,17 +150,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<string> ReadFindTextAsync()
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("clipboard-readFindText-Completed", (text) =>
{
BridgeConnector.Socket.Off("clipboard-readFindText-Completed");
taskCompletionSource.SetResult(text);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("clipboard-readFindText-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("clipboard-readFindText");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -212,17 +184,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<string[]> AvailableFormatsAsync(string type = "")
{
var taskCompletionSource = new TaskCompletionSource<string[]>();
BridgeConnector.Socket.On<string[]>("clipboard-availableFormats-Completed", (formats) =>
{
BridgeConnector.Socket.Off("clipboard-availableFormats-Completed");
taskCompletionSource.SetResult(formats);
});
var tcs = new TaskCompletionSource<string[]>();
BridgeConnector.Socket.Once<string[]>("clipboard-availableFormats-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("clipboard-availableFormats", type);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -242,17 +209,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<NativeImage> ReadImageAsync(string type = "")
{
var taskCompletionSource = new TaskCompletionSource<NativeImage>();
BridgeConnector.Socket.On<NativeImage>("clipboard-readImage-Completed", (result) =>
{
BridgeConnector.Socket.Off("clipboard-readImage-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<NativeImage>();
BridgeConnector.Socket.Once<NativeImage>("clipboard-readImage-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("clipboard-readImage", type);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>

30
src/ElectronNET.API/API/CommandLine.cs
View File

@@ -69,22 +69,17 @@ namespace ElectronNET.API
/// <param name="switchName">A command-line switch</param>
/// <param name="cancellationToken"></param>
/// <returns>Whether the command-line switch is present.</returns>
public async Task<bool> HasSwitchAsync(string switchName, CancellationToken cancellationToken = default(CancellationToken))
public async Task<bool> HasSwitchAsync(string switchName, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
var tcs = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("appCommandLineHasSwitchCompleted", (result) =>
{
BridgeConnector.Socket.Off("appCommandLineHasSwitchCompleted");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<bool>("appCommandLineHasSwitchCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("appCommandLineHasSwitch", switchName);
return await taskCompletionSource.Task.ConfigureAwait(false);
return await tcs.Task.ConfigureAwait(false);
}
}
@@ -97,22 +92,17 @@ namespace ElectronNET.API
/// <remarks>
/// Note: When the switch is not present or has no value, it returns empty string.
/// </remarks>
public async Task<string> GetSwitchValueAsync(string switchName, CancellationToken cancellationToken = default(CancellationToken))
public async Task<string> GetSwitchValueAsync(string switchName, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var taskCompletionSource = new TaskCompletionSource<string>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
var tcs = new TaskCompletionSource<string>();
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
BridgeConnector.Socket.On<string>("appCommandLineGetSwitchValueCompleted", (result) =>
{
BridgeConnector.Socket.Off("appCommandLineGetSwitchValueCompleted");
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<string>("appCommandLineGetSwitchValueCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("appCommandLineGetSwitchValue", switchName);
return await taskCompletionSource.Task.ConfigureAwait(false);
return await tcs.Task.ConfigureAwait(false);
}
}
}

51
src/ElectronNET.API/API/Dialog.cs
View File

@@ -47,21 +47,16 @@ namespace ElectronNET.API
/// <returns>An array of file paths chosen by the user</returns>
public Task<string[]> ShowOpenDialogAsync(BrowserWindow browserWindow, OpenDialogOptions options)
{
var taskCompletionSource = new TaskCompletionSource<string[]>();
var tcs = new TaskCompletionSource<string[]>();
var guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string[]>("showOpenDialogComplete" + guid, (filePaths) =>
{
BridgeConnector.Socket.Off("showOpenDialogComplete" + guid);
taskCompletionSource.SetResult(filePaths);
});
BridgeConnector.Socket.Once<string[]>("showOpenDialogComplete" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("showOpenDialog",
browserWindow,
options,
guid);
BridgeConnector.Socket.Emit("showOpenDialog",
browserWindow,
options, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -72,21 +67,16 @@ namespace ElectronNET.API
/// <returns>Returns String, the path of the file chosen by the user, if a callback is provided it returns an empty string.</returns>
public Task<string> ShowSaveDialogAsync(BrowserWindow browserWindow, SaveDialogOptions options)
{
var taskCompletionSource = new TaskCompletionSource<string>();
var tcs = new TaskCompletionSource<string>();
var guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string>("showSaveDialogComplete" + guid, (filename) =>
{
BridgeConnector.Socket.Off("showSaveDialogComplete" + guid);
taskCompletionSource.SetResult(filename);
});
BridgeConnector.Socket.Once<string>("showSaveDialogComplete" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("showSaveDialog",
browserWindow,
options,
guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -140,13 +130,11 @@ namespace ElectronNET.API
/// <returns>The API call will be asynchronous and the result will be passed via MessageBoxResult.</returns>
public Task<MessageBoxResult> ShowMessageBoxAsync(BrowserWindow browserWindow, MessageBoxOptions messageBoxOptions)
{
var taskCompletionSource = new TaskCompletionSource<MessageBoxResult>();
var tcs = new TaskCompletionSource<MessageBoxResult>();
var guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<JsonElement>("showMessageBoxComplete" + guid, (args) =>
BridgeConnector.Socket.Once<JsonElement>("showMessageBoxComplete" + guid, (args) =>
{
BridgeConnector.Socket.Off("showMessageBoxComplete" + guid);
// args is [response:int, checkboxChecked:boolean]
var arr = args.EnumerateArray();
var e = arr.GetEnumerator();
@@ -155,7 +143,7 @@ namespace ElectronNET.API
e.MoveNext();
var checkbox = e.Current.GetBoolean();
taskCompletionSource.SetResult(new MessageBoxResult
tcs.SetResult(new MessageBoxResult
{
Response = response,
CheckboxChecked = checkbox
@@ -174,7 +162,7 @@ namespace ElectronNET.API
guid);
}
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -214,21 +202,16 @@ namespace ElectronNET.API
/// <returns></returns>
public Task ShowCertificateTrustDialogAsync(BrowserWindow browserWindow, CertificateTrustDialogOptions options)
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("showCertificateTrustDialogComplete" + guid, () =>
{
BridgeConnector.Socket.Off("showCertificateTrustDialogComplete" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("showCertificateTrustDialogComplete" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("showCertificateTrustDialog",
browserWindow,
options,
guid);
return taskCompletionSource.Task;
return tcs.Task;
}

52
src/ElectronNET.API/API/Dock.cs
View File

@@ -53,18 +53,13 @@ namespace ElectronNET.API
{
cancellationToken.ThrowIfCancellationRequested();
var taskCompletionSource = new TaskCompletionSource<int>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
var tcs = new TaskCompletionSource<int>();
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
BridgeConnector.Socket.On<int>("dock-bounce-completed", (id) =>
{
BridgeConnector.Socket.Off("dock-bounce-completed");
taskCompletionSource.SetResult(id);
});
BridgeConnector.Socket.Once<int>("dock-bounce-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("dock-bounce", type.GetDescription());
return await taskCompletionSource.Task
return await tcs.Task
.ConfigureAwait(false);
}
}
@@ -105,18 +100,13 @@ namespace ElectronNET.API
{
cancellationToken.ThrowIfCancellationRequested();
var taskCompletionSource = new TaskCompletionSource<string>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
var tcs = new TaskCompletionSource<string>();
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
BridgeConnector.Socket.On<string>("dock-getBadge-completed", (text) =>
{
BridgeConnector.Socket.Off("dock-getBadge-completed");
taskCompletionSource.SetResult(text);
});
BridgeConnector.Socket.Once<string>("dock-getBadge-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("dock-getBadge");
return await taskCompletionSource.Task
return await tcs.Task
.ConfigureAwait(false);
}
}
@@ -147,18 +137,13 @@ namespace ElectronNET.API
{
cancellationToken.ThrowIfCancellationRequested();
var taskCompletionSource = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
var tcs = new TaskCompletionSource<bool>();
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
BridgeConnector.Socket.On<bool>("dock-isVisible-completed", (isVisible) =>
{
BridgeConnector.Socket.Off("dock-isVisible-completed");
taskCompletionSource.SetResult(isVisible);
});
BridgeConnector.Socket.Once<bool>("dock-isVisible-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("dock-isVisible");
return await taskCompletionSource.Task
return await tcs.Task
.ConfigureAwait(false);
}
}
@@ -204,18 +189,13 @@ namespace ElectronNET.API
{
cancellationToken.ThrowIfCancellationRequested();
var taskCompletionSource = new TaskCompletionSource<Menu>();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
var tcs = new TaskCompletionSource<Menu>();
using (cancellationToken.Register(() => tcs.TrySetCanceled()))
{
BridgeConnector.Socket.On<Menu>("dock-getMenu-completed", (menu) =>
{
BridgeConnector.Socket.Off("dock-getMenu-completed");
taskCompletionSource.SetResult(menu);
});
BridgeConnector.Socket.Once<Menu>("dock-getMenu-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("dock-getMenu");
return await taskCompletionSource.Task
return await tcs.Task
.ConfigureAwait(false);
}
}

2
src/ElectronNET.API/API/Entities/Display.cs
View File

@@ -61,7 +61,7 @@
/// <summary>
/// Output device's pixel scale factor.
/// </summary>
public int ScaleFactor { get; set; }
public double ScaleFactor { get; set; }
/// <summary>
/// Can be available, unavailable, unknown.

12
src/ElectronNET.API/API/GlobalShortcut.cs
View File

@@ -73,18 +73,12 @@ namespace ElectronNET.API
/// <returns>Whether this application has registered accelerator.</returns>
public Task<bool> IsRegisteredAsync(string accelerator)
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("globalShortcut-isRegisteredCompleted", (isRegistered) =>
{
BridgeConnector.Socket.Off("globalShortcut-isRegisteredCompleted");
taskCompletionSource.SetResult(isRegistered);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("globalShortcut-isRegisteredCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("globalShortcut-isRegistered", accelerator);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>

19
src/ElectronNET.API/API/HostHook.cs
View File

@@ -48,9 +48,8 @@ namespace ElectronNET.API
/// <param name="arguments">Optional parameters.</param>
public void Call(string socketEventName, params dynamic[] arguments)
{
BridgeConnector.Socket.On<string>(socketEventName + "Error" + oneCallguid, (result) =>
BridgeConnector.Socket.Once<string>(socketEventName + "Error" + oneCallguid, (result) =>
{
BridgeConnector.Socket.Off(socketEventName + "Error" + oneCallguid);
Electron.Dialog.ShowErrorBox("Host Hook Exception", result);
});
@@ -66,20 +65,18 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<T> CallAsync<T>(string socketEventName, params dynamic[] arguments)
{
var taskCompletionSource = new TaskCompletionSource<T>();
var tcs = new TaskCompletionSource<T>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string>(socketEventName + "Error" + guid, (result) =>
BridgeConnector.Socket.Once<string>(socketEventName + "Error" + guid, (result) =>
{
BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
Electron.Dialog.ShowErrorBox("Host Hook Exception", result);
taskCompletionSource.SetException(new Exception($"Host Hook Exception {result}"));
tcs.SetException(new Exception($"Host Hook Exception {result}"));
});
BridgeConnector.Socket.On<JsonElement>(socketEventName + "Complete" + guid, (result) =>
BridgeConnector.Socket.Once<JsonElement>(socketEventName + "Complete" + guid, (result) =>
{
BridgeConnector.Socket.Off(socketEventName + "Error" + guid);
BridgeConnector.Socket.Off(socketEventName + "Complete" + guid);
T data = default;
try
@@ -88,15 +85,15 @@ namespace ElectronNET.API
}
catch (Exception exception)
{
taskCompletionSource.SetException(exception);
tcs.SetException(exception);
}
taskCompletionSource.SetResult(data);
tcs.SetResult(data);
});
BridgeConnector.Socket.Emit(socketEventName, arguments, guid);
return taskCompletionSource.Task;
return tcs.Task;
}

8
src/ElectronNET.API/API/IpcMain.cs
View File

@@ -48,7 +48,7 @@ namespace ElectronNET.API
{
await BridgeConnector.Socket.Emit("registerIpcMainChannel", channel).ConfigureAwait(false);
BridgeConnector.Socket.Off(channel);
BridgeConnector.Socket.On<System.Text.Json.JsonElement>(channel, (args) =>
BridgeConnector.Socket.On<JsonElement>(channel, (args) =>
{
List<object> objectArray = FormatArguments(args);
@@ -63,7 +63,7 @@ namespace ElectronNET.API
});
}
private static List<object> FormatArguments(System.Text.Json.JsonElement args)
private static List<object> FormatArguments(JsonElement args)
{
var objectArray = args.Deserialize<object[]>(ElectronJson.Options).ToList();
objectArray.RemoveAll(item => item is null);
@@ -82,7 +82,7 @@ namespace ElectronNET.API
public void OnSync(string channel, Func<object, object> listener)
{
BridgeConnector.Socket.Emit("registerSyncIpcMainChannel", channel);
BridgeConnector.Socket.On<System.Text.Json.JsonElement>(channel, (args) =>
BridgeConnector.Socket.On<JsonElement>(channel, (args) =>
{
List<object> objectArray = FormatArguments(args);
object parameter;
@@ -109,7 +109,7 @@ namespace ElectronNET.API
public void Once(string channel, Action<object> listener)
{
BridgeConnector.Socket.Emit("registerOnceIpcMainChannel", channel);
BridgeConnector.Socket.Once<System.Text.Json.JsonElement>(channel, (args) =>
BridgeConnector.Socket.Once<JsonElement>(channel, (args) =>
{
List<object> objectArray = FormatArguments(args);

44
src/ElectronNET.API/API/NativeTheme.cs
View File

@@ -107,17 +107,12 @@ namespace ElectronNET.API
/// </summary>
public Task<ThemeSourceMode> GetThemeSourceAsync()
{
var taskCompletionSource = new TaskCompletionSource<ThemeSourceMode>();
BridgeConnector.Socket.On<ThemeSourceMode>("nativeTheme-themeSource-getCompleted", (themeSource) =>
{
BridgeConnector.Socket.Off("nativeTheme-themeSource-getCompleted");
taskCompletionSource.SetResult(themeSource);
});
var tcs = new TaskCompletionSource<ThemeSourceMode>();
BridgeConnector.Socket.Once<ThemeSourceMode>("nativeTheme-themeSource-getCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("nativeTheme-themeSource-get");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -127,17 +122,12 @@ namespace ElectronNET.API
/// </summary>
public Task<bool> ShouldUseDarkColorsAsync()
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("nativeTheme-shouldUseDarkColors-completed", (shouldUseDarkColors) =>
{
BridgeConnector.Socket.Off("nativeTheme-shouldUseDarkColors-completed");
taskCompletionSource.SetResult(shouldUseDarkColors);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("nativeTheme-shouldUseDarkColors-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("nativeTheme-shouldUseDarkColors");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -146,17 +136,12 @@ namespace ElectronNET.API
/// </summary>
public Task<bool> ShouldUseHighContrastColorsAsync()
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("nativeTheme-shouldUseHighContrastColors-completed", (shouldUseHighContrastColors) =>
{
BridgeConnector.Socket.Off("nativeTheme-shouldUseHighContrastColors-completed");
taskCompletionSource.SetResult(shouldUseHighContrastColors);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("nativeTheme-shouldUseHighContrastColors-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("nativeTheme-shouldUseHighContrastColors");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -165,17 +150,12 @@ namespace ElectronNET.API
/// </summary>
public Task<bool> ShouldUseInvertedColorSchemeAsync()
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("nativeTheme-shouldUseInvertedColorScheme-completed", (shouldUseInvertedColorScheme) =>
{
BridgeConnector.Socket.Off("nativeTheme-shouldUseInvertedColorScheme-completed");
taskCompletionSource.SetResult(shouldUseInvertedColorScheme);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("nativeTheme-shouldUseInvertedColorScheme-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("nativeTheme-shouldUseInvertedColorScheme");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>

11
src/ElectronNET.API/API/Notification.cs
View File

@@ -119,17 +119,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<bool> IsSupportedAsync()
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("notificationIsSupportedComplete", (isSupported) =>
{
BridgeConnector.Socket.Off("notificationIsSupportedComplete");
taskCompletionSource.SetResult(isSupported);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("notificationIsSupportedComplete", tcs.SetResult);
BridgeConnector.Socket.Emit("notificationIsSupported");
return taskCompletionSource.Task;
return tcs.Task;
}

132
src/ElectronNET.API/API/Process.cs
View File

@@ -46,16 +46,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("process-execPath-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-execPath-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("process-execPath-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-execPath");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -70,16 +66,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<string[]>();
BridgeConnector.Socket.On<string[]>("process-argv-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-argv-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<string[]>();
BridgeConnector.Socket.Once<string[]>("process-argv-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-argv");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -91,16 +83,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("process-type-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-type-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("process-type-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-type");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -113,16 +101,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<ProcessVersions>();
BridgeConnector.Socket.On<ProcessVersions>("process-versions-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-versions-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<ProcessVersions>();
BridgeConnector.Socket.Once<ProcessVersions>("process-versions-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-versions");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -135,16 +119,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("process-defaultApp-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-defaultApp-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("process-defaultApp-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-defaultApp");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -156,16 +136,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("process-isMainFrame-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-isMainFrame-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("process-isMainFrame-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-isMainFrame");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -176,16 +152,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("process-resourcesPath-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-resourcesPath-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("process-resourcesPath-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-resourcesPath");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -197,16 +169,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<double>();
BridgeConnector.Socket.On<double>("process-uptime-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-uptime-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<double>();
BridgeConnector.Socket.Once<double>("process-uptime-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-uptime");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -217,16 +185,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<int>();
BridgeConnector.Socket.On<int>("process-pid-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-pid-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<int>();
BridgeConnector.Socket.Once<int>("process-pid-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-pid");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -238,16 +202,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("process-arch-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-arch-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("process-arch-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-arch");
return taskCompletionSource.Task;
return tcs.Task;
}
}
@@ -258,16 +218,12 @@ namespace ElectronNET.API
{
get
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("process-platform-Completed", (result) =>
{
BridgeConnector.Socket.Off("process-platform-Completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("process-platform-Completed", tcs.SetResult);
BridgeConnector.Socket.Emit("process-platform");
return taskCompletionSource.Task;
return tcs.Task;
}
}
}

66
src/ElectronNET.API/API/Screen.cs
View File

@@ -79,17 +79,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<Point> GetCursorScreenPointAsync()
{
var taskCompletionSource = new TaskCompletionSource<Point>();
BridgeConnector.Socket.On<Point>("screen-getCursorScreenPointCompleted", (point) =>
{
BridgeConnector.Socket.Off("screen-getCursorScreenPointCompleted");
taskCompletionSource.SetResult(point);
});
var tcs = new TaskCompletionSource<Point>();
BridgeConnector.Socket.Once<Point>("screen-getCursorScreenPointCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("screen-getCursorScreenPoint");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -98,17 +93,12 @@ namespace ElectronNET.API
/// <returns>The height of the menu bar in pixels.</returns>
public Task<int> GetMenuBarHeightAsync()
{
var taskCompletionSource = new TaskCompletionSource<int>();
BridgeConnector.Socket.On<int>("screen-getMenuBarHeightCompleted", (height) =>
{
BridgeConnector.Socket.Off("screen-getMenuBarHeightCompleted");
taskCompletionSource.SetResult(height);
});
var tcs = new TaskCompletionSource<int>();
BridgeConnector.Socket.Once<int>("screen-getMenuBarHeightCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("screen-getMenuBarHeight");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -117,17 +107,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<Display> GetPrimaryDisplayAsync()
{
var taskCompletionSource = new TaskCompletionSource<Display>();
BridgeConnector.Socket.On<Display>("screen-getPrimaryDisplayCompleted", (display) =>
{
BridgeConnector.Socket.Off("screen-getPrimaryDisplayCompleted");
taskCompletionSource.SetResult(display);
});
var tcs = new TaskCompletionSource<Display>();
BridgeConnector.Socket.Once<Display>("screen-getPrimaryDisplayCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("screen-getPrimaryDisplay");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -136,17 +121,12 @@ namespace ElectronNET.API
/// <returns>An array of displays that are currently available.</returns>
public Task<Display[]> GetAllDisplaysAsync()
{
var taskCompletionSource = new TaskCompletionSource<Display[]>();
BridgeConnector.Socket.On<Display[]>("screen-getAllDisplaysCompleted", (displays) =>
{
BridgeConnector.Socket.Off("screen-getAllDisplaysCompleted");
taskCompletionSource.SetResult(displays);
});
var tcs = new TaskCompletionSource<Display[]>();
BridgeConnector.Socket.Once<Display[]>("screen-getAllDisplaysCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("screen-getAllDisplays");
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -155,17 +135,12 @@ namespace ElectronNET.API
/// <returns>The display nearest the specified point.</returns>
public Task<Display> GetDisplayNearestPointAsync(Point point)
{
var taskCompletionSource = new TaskCompletionSource<Display>();
BridgeConnector.Socket.On<Display>("screen-getDisplayNearestPointCompleted", (display) =>
{
BridgeConnector.Socket.Off("screen-getDisplayNearestPointCompleted");
taskCompletionSource.SetResult(display);
});
var tcs = new TaskCompletionSource<Display>();
BridgeConnector.Socket.Once<Display>("screen-getDisplayNearestPointCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("screen-getDisplayNearestPoint", point);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -175,17 +150,12 @@ namespace ElectronNET.API
/// <returns>The display that most closely intersects the provided bounds.</returns>
public Task<Display> GetDisplayMatchingAsync(Rectangle rectangle)
{
var taskCompletionSource = new TaskCompletionSource<Display>();
BridgeConnector.Socket.On<Display>("screen-getDisplayMatching", (display) =>
{
BridgeConnector.Socket.Off("screen-getDisplayMatching");
taskCompletionSource.SetResult(display);
});
var tcs = new TaskCompletionSource<Display>();
BridgeConnector.Socket.Once<Display>("screen-getDisplayMatching", tcs.SetResult);
BridgeConnector.Socket.Emit("screen-getDisplayMatching", rectangle);
return taskCompletionSource.Task;
return tcs.Task;
}

154
src/ElectronNET.API/API/Session.cs
View File

@@ -49,18 +49,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task ClearAuthCacheAsync(RemovePassword options)
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("webContents-session-clearAuthCache-completed" + guid, () =>
{
BridgeConnector.Socket.Off("webContents-session-clearAuthCache-completed" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("webContents-session-clearAuthCache-completed" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("webContents-session-clearAuthCache", Id, options, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -68,18 +63,13 @@ namespace ElectronNET.API
/// </summary>
public Task ClearAuthCacheAsync()
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("webContents-session-clearAuthCache-completed" + guid, () =>
{
BridgeConnector.Socket.Off("webContents-session-clearAuthCache-completed" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("webContents-session-clearAuthCache-completed" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("webContents-session-clearAuthCache", Id, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -88,18 +78,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task ClearCacheAsync()
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("webContents-session-clearCache-completed" + guid, () =>
{
BridgeConnector.Socket.Off("webContents-session-clearCache-completed" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("webContents-session-clearCache-completed" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("webContents-session-clearCache", Id, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -108,18 +93,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task ClearHostResolverCacheAsync()
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("webContents-session-clearHostResolverCache-completed" + guid, () =>
{
BridgeConnector.Socket.Off("webContents-session-clearHostResolverCache-completed" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("webContents-session-clearHostResolverCache-completed" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("webContents-session-clearHostResolverCache", Id, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -128,18 +108,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task ClearStorageDataAsync()
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("webContents-session-clearStorageData-completed" + guid, () =>
{
BridgeConnector.Socket.Off("webContents-session-clearStorageData-completed" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("webContents-session-clearStorageData-completed" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("webContents-session-clearStorageData", Id, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -149,18 +124,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task ClearStorageDataAsync(ClearStorageDataOptions options)
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("webContents-session-clearStorageData-options-completed" + guid, () =>
{
BridgeConnector.Socket.Off("webContents-session-clearStorageData-options-completed" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("webContents-session-clearStorageData-options-completed" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("webContents-session-clearStorageData-options", Id, options, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -209,18 +179,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<int[]> GetBlobDataAsync(string identifier)
{
var taskCompletionSource = new TaskCompletionSource<int[]>();
var tcs = new TaskCompletionSource<int[]>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<int[]>("webContents-session-getBlobData-completed" + guid, (result) =>
{
BridgeConnector.Socket.Off("webContents-session-getBlobData-completed" + guid);
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<int[]>("webContents-session-getBlobData-completed" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-session-getBlobData", Id, identifier, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -229,18 +194,13 @@ namespace ElectronNET.API
/// <returns>Callback is invoked with the session's current cache size.</returns>
public Task<int> GetCacheSizeAsync()
{
var taskCompletionSource = new TaskCompletionSource<int>();
var tcs = new TaskCompletionSource<int>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<int>("webContents-session-getCacheSize-completed" + guid, (size) =>
{
BridgeConnector.Socket.Off("webContents-session-getCacheSize-completed" + guid);
taskCompletionSource.SetResult(size);
});
BridgeConnector.Socket.Once<int>("webContents-session-getCacheSize-completed" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-session-getCacheSize", Id, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -249,18 +209,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<string[]> GetPreloadsAsync()
{
var taskCompletionSource = new TaskCompletionSource<string[]>();
var tcs = new TaskCompletionSource<string[]>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string[]>("webContents-session-getPreloads-completed" + guid, (result) =>
{
BridgeConnector.Socket.Off("webContents-session-getPreloads-completed" + guid);
taskCompletionSource.SetResult(result);
});
BridgeConnector.Socket.Once<string[]>("webContents-session-getPreloads-completed" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-session-getPreloads", Id, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -269,18 +224,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<string> GetUserAgent()
{
var taskCompletionSource = new TaskCompletionSource<string>();
var tcs = new TaskCompletionSource<string>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string>("webContents-session-getUserAgent-completed" + guid, (userAgent) =>
{
BridgeConnector.Socket.Off("webContents-session-getUserAgent-completed" + guid);
taskCompletionSource.SetResult(userAgent);
});
BridgeConnector.Socket.Once<string>("webContents-session-getUserAgent-completed" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-session-getUserAgent", Id, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -291,18 +241,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<string> ResolveProxyAsync(string url)
{
var taskCompletionSource = new TaskCompletionSource<string>();
var tcs = new TaskCompletionSource<string>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On<string>("webContents-session-resolveProxy-completed" + guid, (proxy) =>
{
BridgeConnector.Socket.Off("webContents-session-resolveProxy-completed" + guid);
taskCompletionSource.SetResult(proxy);
});
BridgeConnector.Socket.Once<string>("webContents-session-resolveProxy-completed" + guid, tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-session-resolveProxy", Id, url, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -333,18 +278,13 @@ namespace ElectronNET.API
/// <returns></returns>
public Task SetProxyAsync(ProxyConfig config)
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
string guid = Guid.NewGuid().ToString();
BridgeConnector.Socket.On("webContents-session-setProxy-completed" + guid, () =>
{
BridgeConnector.Socket.Off("webContents-session-setProxy-completed" + guid);
taskCompletionSource.SetResult(null);
});
BridgeConnector.Socket.Once("webContents-session-setProxy-completed" + guid, () => tcs.SetResult(null));
BridgeConnector.Socket.Emit("webContents-session-setProxy", Id, config, guid);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -381,17 +321,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<ChromeExtensionInfo[]> GetAllExtensionsAsync()
{
var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>();
BridgeConnector.Socket.On<ChromeExtensionInfo[]>("webContents-session-getAllExtensions-completed", (extensionslist) =>
{
BridgeConnector.Socket.Off("webContents-session-getAllExtensions-completed");
taskCompletionSource.SetResult(extensionslist);
});
var tcs = new TaskCompletionSource<ChromeExtensionInfo[]>();
BridgeConnector.Socket.Once<ChromeExtensionInfo[]>("webContents-session-getAllExtensions-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-session-getAllExtensions", Id);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -433,17 +368,12 @@ namespace ElectronNET.API
/// <returns></returns>
public Task<Extension> LoadExtensionAsync(string path, bool allowFileAccess = false)
{
var taskCompletionSource = new TaskCompletionSource<Extension>();
BridgeConnector.Socket.On<Extension>("webContents-session-loadExtension-completed", (extension) =>
{
BridgeConnector.Socket.Off("webContents-session-loadExtension-completed");
taskCompletionSource.SetResult(extension);
});
var tcs = new TaskCompletionSource<Extension>();
BridgeConnector.Socket.Once<Extension>("webContents-session-loadExtension-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-session-loadExtension", Id, path, allowFileAccess);
return taskCompletionSource.Task;
return tcs.Task;
}

62
src/ElectronNET.API/API/Shell.cs
View File

@@ -43,13 +43,13 @@ namespace ElectronNET.API
/// <param name="fullPath">The full path to the directory / file.</param>
public Task ShowItemInFolderAsync(string fullPath)
{
var taskCompletionSource = new TaskCompletionSource<object>();
BridgeConnector.Socket.On("shell-showItemInFolderCompleted", () => { BridgeConnector.Socket.Off("shell-showItemInFolderCompleted"); });
var tcs = new TaskCompletionSource<object>();
// Is this really useful?
BridgeConnector.Socket.Once("shell-showItemInFolderCompleted", () => { });
BridgeConnector.Socket.Emit("shell-showItemInFolder", fullPath);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -59,17 +59,12 @@ namespace ElectronNET.API
/// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
public Task<string> OpenPathAsync(string path)
{
var taskCompletionSource = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("shell-openPathCompleted", (errorMessage) =>
{
BridgeConnector.Socket.Off("shell-openPathCompleted");
taskCompletionSource.SetResult(errorMessage);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("shell-openPathCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("shell-openPath", path);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -92,13 +87,9 @@ namespace ElectronNET.API
/// <returns>The error message corresponding to the failure if a failure occurred, otherwise <see cref="string.Empty"/>.</returns>
public Task<string> OpenExternalAsync(string url, OpenExternalOptions options)
{
var taskCompletionSource = new TaskCompletionSource<string>();
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.On<string>("shell-openExternalCompleted", (error) =>
{
BridgeConnector.Socket.Off("shell-openExternalCompleted");
taskCompletionSource.SetResult(error);
});
BridgeConnector.Socket.Once<string>("shell-openExternalCompleted", tcs.SetResult);
if (options == null)
{
@@ -109,7 +100,7 @@ namespace ElectronNET.API
BridgeConnector.Socket.Emit("shell-openExternal", url, options);
}
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -119,17 +110,12 @@ namespace ElectronNET.API
/// <returns> Whether the item was successfully moved to the trash.</returns>
public Task<bool> TrashItemAsync(string fullPath)
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("shell-trashItem-completed", (success) =>
{
BridgeConnector.Socket.Off("shell-trashItem-completed");
taskCompletionSource.SetResult(success);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("shell-trashItem-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("shell-trashItem", fullPath);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -149,17 +135,12 @@ namespace ElectronNET.API
/// <returns>Whether the shortcut was created successfully.</returns>
public Task<bool> WriteShortcutLinkAsync(string shortcutPath, ShortcutLinkOperation operation, ShortcutDetails options)
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("shell-writeShortcutLinkCompleted", (success) =>
{
BridgeConnector.Socket.Off("shell-writeShortcutLinkCompleted");
taskCompletionSource.SetResult(success);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("shell-writeShortcutLinkCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("shell-writeShortcutLink", shortcutPath, operation.GetDescription(), options);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -170,17 +151,12 @@ namespace ElectronNET.API
/// <returns><see cref="ShortcutDetails"/> of the shortcut.</returns>
public Task<ShortcutDetails> ReadShortcutLinkAsync(string shortcutPath)
{
var taskCompletionSource = new TaskCompletionSource<ShortcutDetails>();
BridgeConnector.Socket.On<ShortcutDetails>("shell-readShortcutLinkCompleted", (shortcutDetails) =>
{
BridgeConnector.Socket.Off("shell-readShortcutLinkCompleted");
taskCompletionSource.SetResult(shortcutDetails);
});
var tcs = new TaskCompletionSource<ShortcutDetails>();
BridgeConnector.Socket.Once<ShortcutDetails>("shell-readShortcutLinkCompleted", tcs.SetResult);
BridgeConnector.Socket.Emit("shell-readShortcutLink", shortcutPath);
return taskCompletionSource.Task;
return tcs.Task;
}

12
src/ElectronNET.API/API/Tray.cs
View File

@@ -218,18 +218,12 @@ namespace ElectronNET.API
/// <returns></returns>
public async Task<bool> IsDestroyedAsync()
{
var taskCompletionSource = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("tray-isDestroyedCompleted", (isDestroyed) =>
{
BridgeConnector.Socket.Off("tray-isDestroyedCompleted");
taskCompletionSource.SetResult(isDestroyed);
});
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.Once<bool>("tray-isDestroyedCompleted", tcs.SetResult);
await BridgeConnector.Socket.Emit("tray-isDestroyed").ConfigureAwait(false);
return await taskCompletionSource.Task.ConfigureAwait(false);
return await tcs.Task.ConfigureAwait(false);
}

70
src/ElectronNET.API/API/WebContents.cs
View File

@@ -158,17 +158,12 @@ public class WebContents
/// <returns>printers</returns>
public Task<PrinterInfo[]> GetPrintersAsync()
{
var taskCompletionSource = new TaskCompletionSource<PrinterInfo[]>();
BridgeConnector.Socket.On<PrinterInfo[]>("webContents-getPrinters-completed", (printers) =>
{
BridgeConnector.Socket.Off("webContents-getPrinters-completed");
taskCompletionSource.SetResult(printers);
});
var tcs = new TaskCompletionSource<PrinterInfo[]>();
BridgeConnector.Socket.Once<PrinterInfo[]>("webContents-getPrinters-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-getPrinters", Id);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -178,13 +173,9 @@ public class WebContents
/// <returns>success</returns>
public Task<bool> PrintAsync(PrintOptions options = null)
{
var taskCompletionSource = new TaskCompletionSource<bool>();
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("webContents-print-completed", (success) =>
{
BridgeConnector.Socket.Off("webContents-print-completed");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("webContents-print-completed", tcs.SetResult);
if (options == null)
{
@@ -195,7 +186,7 @@ public class WebContents
BridgeConnector.Socket.Emit("webContents-print", Id, options);
}
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -209,13 +200,9 @@ public class WebContents
/// <returns>success</returns>
public Task<bool> PrintToPDFAsync(string path, PrintToPDFOptions options = null)
{
var taskCompletionSource = new TaskCompletionSource<bool>();
var tcs = new TaskCompletionSource<bool>();
BridgeConnector.Socket.On<bool>("webContents-printToPDF-completed", (success) =>
{
BridgeConnector.Socket.Off("webContents-printToPDF-completed");
taskCompletionSource.SetResult(success);
});
BridgeConnector.Socket.Once<bool>("webContents-printToPDF-completed", tcs.SetResult);
if (options == null)
{
@@ -226,7 +213,7 @@ public class WebContents
BridgeConnector.Socket.Emit("webContents-printToPDF", Id, options, path);
}
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -247,17 +234,12 @@ public class WebContents
/// </remarks>
public Task<T> ExecuteJavaScriptAsync<T>(string code, bool userGesture = false)
{
var taskCompletionSource = new TaskCompletionSource<T>();
BridgeConnector.Socket.On<T>("webContents-executeJavaScript-completed", (result) =>
{
BridgeConnector.Socket.Off("webContents-executeJavaScript-completed");
taskCompletionSource.SetResult(result);
});
var tcs = new TaskCompletionSource<T>();
BridgeConnector.Socket.Once<T>("webContents-executeJavaScript-completed", tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-executeJavaScript", Id, code, userGesture);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -267,18 +249,12 @@ public class WebContents
/// <returns>URL of the loaded page</returns>
public Task<string> GetUrl()
{
var taskCompletionSource = new TaskCompletionSource<string>();
var eventString = "webContents-getUrl" + Id;
BridgeConnector.Socket.On<string>(eventString, (url) =>
{
BridgeConnector.Socket.Off(eventString);
taskCompletionSource.SetResult(url);
});
var tcs = new TaskCompletionSource<string>();
BridgeConnector.Socket.Once<string>("webContents-getUrl", tcs.SetResult);
BridgeConnector.Socket.Emit("webContents-getUrl", Id);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -313,24 +289,22 @@ public class WebContents
/// <param name="options"></param>
public Task LoadURLAsync(string url, LoadURLOptions options)
{
var taskCompletionSource = new TaskCompletionSource<object>();
var tcs = new TaskCompletionSource<object>();
BridgeConnector.Socket.On("webContents-loadURL-complete" + Id, () =>
BridgeConnector.Socket.Once("webContents-loadURL-complete" + Id, () =>
{
BridgeConnector.Socket.Off("webContents-loadURL-complete" + Id);
BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
taskCompletionSource.SetResult(null);
tcs.SetResult(null);
});
BridgeConnector.Socket.On<string>("webContents-loadURL-error" + Id, (error) =>
BridgeConnector.Socket.Once<string>("webContents-loadURL-error" + Id, (error) =>
{
BridgeConnector.Socket.Off("webContents-loadURL-error" + Id);
taskCompletionSource.SetException(new InvalidOperationException(error));
tcs.SetException(new InvalidOperationException(error));
});
BridgeConnector.Socket.Emit("webContents-loadURL", Id, url, options);
return taskCompletionSource.Task;
return tcs.Task;
}
/// <summary>
@@ -344,6 +318,4 @@ public class WebContents
{
BridgeConnector.Socket.Emit("webContents-insertCSS", Id, isBrowserWindow, path);
}
}

2
src/ElectronNET.API/API/WebRequest.cs
View File

@@ -34,7 +34,7 @@ namespace ElectronNET.API.Entities
{
if (_onBeforeRequest == null)
{
BridgeConnector.Socket.On<System.Text.Json.JsonElement>($"webContents-session-webRequest-onBeforeRequest{Id}",
BridgeConnector.Socket.On<JsonElement>($"webContents-session-webRequest-onBeforeRequest{Id}",
(args) =>
{
//// var details0 = args[0].Deserialize<OnBeforeRequestDetails>(ElectronNET.ElectronJson.Options);

22
src/ElectronNET.API/API/WindowManager.cs
View File

@@ -96,21 +96,18 @@ namespace ElectronNET.API
/// <returns></returns>
public async Task<BrowserWindow> CreateWindowAsync(BrowserWindowOptions options, string loadUrl = "http://localhost")
{
var taskCompletionSource = new TaskCompletionSource<BrowserWindow>();
var tcs = new TaskCompletionSource<BrowserWindow>();
BridgeConnector.Socket.On<int>("BrowserWindowCreated", (id) =>
BridgeConnector.Socket.Once<int>("BrowserWindowCreated", (id) =>
{
BridgeConnector.Socket.Off("BrowserWindowCreated");
var browserWindow = new BrowserWindow(id);
_browserWindows.Add(browserWindow);
taskCompletionSource.SetResult(browserWindow);
tcs.SetResult(browserWindow);
});
BridgeConnector.Socket.On<int[]>("BrowserWindowClosed", (ids) =>
BridgeConnector.Socket.Once<int[]>("BrowserWindowClosed", (ids) =>
{
BridgeConnector.Socket.Off("BrowserWindowClosed");
for (int index = 0; index < _browserWindows.Count; index++)
{
if (!ids.Contains(_browserWindows[index].Id))
@@ -152,7 +149,7 @@ namespace ElectronNET.API
await BridgeConnector.Socket.Emit("createBrowserWindow", options, loadUrl).ConfigureAwait(false);
}
return await taskCompletionSource.Task.ConfigureAwait(false);
return await tcs.Task.ConfigureAwait(false);
}
private bool IsWindows10()
@@ -180,21 +177,20 @@ namespace ElectronNET.API
/// <returns></returns>
public async Task<BrowserView> CreateBrowserViewAsync(BrowserViewConstructorOptions options)
{
var taskCompletionSource = new TaskCompletionSource<BrowserView>();
var tcs = new TaskCompletionSource<BrowserView>();
BridgeConnector.Socket.On<int>("BrowserViewCreated", (id) =>
BridgeConnector.Socket.Once<int>("BrowserViewCreated", (id) =>
{
BridgeConnector.Socket.Off("BrowserViewCreated");
BrowserView browserView = new(id);
_browserViews.Add(browserView);
taskCompletionSource.SetResult(browserView);
tcs.SetResult(browserView);
});
await BridgeConnector.Socket.Emit("createBrowserView", options).ConfigureAwait(false);
return await taskCompletionSource.Task.ConfigureAwait(false);
return await tcs.Task.ConfigureAwait(false);
}
}

2
src/ElectronNET.API/Common/ProcessRunner.cs
View File

@@ -322,7 +322,7 @@
/// <paramref name="cancellationToken"/> has been triggered.
/// This method does not end the process itself.</remarks>
/// <returns>true, if the process has exited, false if the process is still running.</returns>
public async Task<bool> WaitForExitAsync(CancellationToken cancellationToken = default(CancellationToken))
public async Task<bool> WaitForExitAsync(CancellationToken cancellationToken = default)
{
var proc = this.process;