Fix thread management/syncing/closing issues

Author: aleab

ExamplePlugin/ExamplePlugin.csproj

@@ -12,10 +12,14 @@
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <OldToolsVersion>3.5</OldToolsVersion>
-    <SccProjectName>SAK</SccProjectName>
-    <SccLocalPath>SAK</SccLocalPath>
-    <SccAuxPath>SAK</SccAuxPath>
-    <SccProvider>SAK</SccProvider>
+    <SccProjectName>
+    </SccProjectName>
+    <SccLocalPath>
+    </SccLocalPath>
+    <SccAuxPath>
+    </SccAuxPath>
+    <SccProvider>
+    </SccProvider>
     <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

Toastify/src/Core/Auth/AuthHttpServer.cs

@@ -6,6 +6,7 @@
 using System.Web;
 using Microsoft.AspNetCore.Hosting;
 using Toastify.Common;
+using Toastify.Threading;
 using ToastifyAPI.Core.Auth;
 using ToastifyWebAuthAPI_Utils = ToastifyAPI.Core.Auth.ToastifyWebAuthAPI.Utils;
 
@@ -15,6 +16,7 @@ public class AuthHttpServer : IAuthHttpServer, IDisposable
     {
         private readonly IWebHost webHost;
         private readonly NamedPipeServerStream pipe;
+        private readonly CancellationTokenSource cts;
 
         private Thread receiveThread;
 
@@ -38,28 +40,32 @@ public AuthHttpServer()
                           .UseStartup<AuthHttpServerStartup>()
                           .UseUrls(url)
                           .Build();
+
+            this.cts = new CancellationTokenSource();
         }
 
         public async Task Start()
         {
-            await this.webHost.StartAsync().ConfigureAwait(false);
-            this.receiveThread = new Thread(this.ReceiveThread)
-            {
-                Name = $"Toastify_{nameof(AuthHttpServer)}_ReceiveThread_{RuntimeHelpers.GetHashCode(this)}"
-            };
+            await this.webHost.StartAsync(this.cts.Token).ConfigureAwait(false);
+
+            this.receiveThread = ThreadManager.Instance.CreateThread(this.ReceiveThread);
+            this.receiveThread.IsBackground = true;
+            this.receiveThread.Name = $"Toastify_{nameof(AuthHttpServer)}_ReceiveThread_{RuntimeHelpers.GetHashCode(this)}";
             this.receiveThread.Start();
         }
 
         public Task Stop()
         {
-            return this.webHost.StopAsync();
+            return this.webHost.StopAsync(this.cts.Token);
         }
 
-        private void ReceiveThread()
+        private async void ReceiveThread()
         {
             try
             {
-                this.pipe.WaitForConnection();
+                await this.pipe.WaitForConnectionAsync(this.cts.Token).ConfigureAwait(false);
+                if (this.cts.IsCancellationRequested)
+                    return;
 
                 StringStream ss = new StringStream(this.pipe);
                 string responseString = ss.ReadString();
@@ -69,26 +75,44 @@ private void ReceiveThread()
                 string state = response.Get("state");
                 string error = response.Get("error");
 
-                this.pipe.Close();
-
                 this.OnAuthorizationFinished(code, state, error);
             }
-            catch
+            finally
             {
-                // ignore
+                this.pipe.Close();
             }
         }
 
+        private void OnAuthorizationFinished(string code, string state, string error)
+        {
+            this.AuthorizationFinished?.Invoke(this, new AuthEventArgs(code, state, error));
+        }
+
+        #region Dispose
+
         public void Dispose()
         {
-            this.receiveThread?.Abort();
-            this.pipe?.Dispose();
-            this.webHost?.Dispose();
+            this.Dispose(TimeSpan.FromSeconds(1));
         }
 
-        private void OnAuthorizationFinished(string code, string state, string error)
+        public void Dispose(TimeSpan timeout)
         {
-            this.AuthorizationFinished?.Invoke(this, new AuthEventArgs(code, state, error));
+            try
+            {
+                this.cts.Cancel();
+                this.receiveThread.Join(timeout);
+            }
+            catch
+            {
+                // ignore
+            }
+
+            this.pipe?.Dispose();
+            this.webHost?.Dispose();
+
+            this.cts.Dispose();
         }
+
+        #endregion
     }
 }

Toastify/src/Core/Auth/ToastifyWebAuth.cs

@@ -19,8 +19,9 @@ public class ToastifyWebAuth : BaseSpotifyWebAuth
     {
         private static readonly ILog logger = LogManager.GetLogger(typeof(ToastifyWebAuth));
 
-        private AuthHttpServer authHttpServer;
+        private readonly ManualResetEvent abortAuthEvent;
 
+        private AuthHttpServer authHttpServer;
         private WindowThread<WebView> webViewWindowThread;
 
         #region Non-Public Properties
@@ -47,6 +48,7 @@ public ToastifyWebAuth(Scope scopes, string state, bool showDialog)
             this.ShowDialog = showDialog;
 
             this.authHttpServer = new AuthHttpServer();
+            this.abortAuthEvent = new ManualResetEvent(false);
         }
 
         protected override void Authorize()
@@ -66,7 +68,7 @@ protected override void Authorize()
                         AuthorizationCodeFlow.Authorize(url => window.NavigateTo(url), this.Scopes, this.State, this.ShowDialog, "en");
                     }));
                 },
-                OnWindowClosingAction = windowThread => windowThread.Abort()
+                OnWindowClosingAction = window => this.abortAuthEvent.Set()
             };
 
             this.webViewWindowThread = ThreadManager.Instance.CreateWindowThread(ApartmentState.STA, windowThreadOptions);
@@ -87,34 +89,52 @@ protected override IToken CreateToken(SpotifyTokenResponse spotifyTokenResponse)
 
         protected override Task<bool> ShouldAbortAuthorization()
         {
-            bool shouldAbortAuthorization = App.ShutdownEvent.WaitOne(100);
-            return Task.FromResult(shouldAbortAuthorization);
-        }
-
-        public override void Dispose()
-        {
-            this.authHttpServer?.Dispose();
-            this.authHttpServer = null;
-
-            this.webViewWindowThread?.Dispose();
-            this.webViewWindowThread = null;
+            try
+            {
+                bool shouldAbortAuthorization = this.abortAuthEvent.WaitOne(20) || App.ShutdownEvent.WaitOne(20);
+                return Task.FromResult(shouldAbortAuthorization);
+            }
+            catch
+            {
+                return Task.FromResult(true);
+            }
         }
 
         protected override void AuthHttpServer_AuthorizationFinished(object sender, AuthEventArgs e)
         {
             try
             {
                 base.AuthHttpServer_AuthorizationFinished(sender, e);
+                this.DisposeWebViewWindow(TimeSpan.FromSeconds(2));
             }
             catch (Exception ex)
             {
                 logger.Error($"Unhandled error in {nameof(this.AuthHttpServer_AuthorizationFinished)}", ex);
             }
-            finally
-            {
-                this.webViewWindowThread?.Dispose();
-                this.webViewWindowThread = null;
-            }
         }
+
+        #region Dispose
+
+        public override void Dispose()
+        {
+            TimeSpan timeout = TimeSpan.FromSeconds(2);
+            this.abortAuthEvent.Set();
+            this.DisposeAuthHttpServer(timeout);
+            this.DisposeWebViewWindow(timeout);
+        }
+
+        private void DisposeAuthHttpServer(TimeSpan timeout)
+        {
+            this.authHttpServer?.Dispose(timeout);
+            this.authHttpServer = null;
+        }
+
+        private void DisposeWebViewWindow(TimeSpan timeout)
+        {
+            this.webViewWindowThread?.Dispose(timeout);
+            this.webViewWindowThread = null;
+        }
+
+        #endregion
     }
 }