Fix issues with closing patcher

Author: witcher112

src/Assets/Scripts/Patcher.cs

@@ -23,6 +23,8 @@ public enum UserDecision
             StartApp
         }
 
+        #region Private fields
+
         private static readonly DebugLogger DebugLogger = new DebugLogger(typeof(Patcher));
 
         public static Patcher Instance { get; private set; }
@@ -35,7 +37,9 @@ public enum UserDecision
 
         private App _app;
 
-        private bool _hasBeenDestroyed;
+        private bool _keepThreadAlive;
+
+        private bool _isThreadBeingDestroyed;
 
         private UserDecision _userDecision = UserDecision.None;
 
@@ -49,10 +53,9 @@ public enum UserDecision
 
         private CancellationTokenSource _cancellationTokenSource;
 
-        public PatcherData Data
-        {
-            get { return _data; }
-        }
+        #endregion
+
+        #region Events
 
         public event Action<OverallStatus> UpdateAppStatusChanged;
 
@@ -66,23 +69,21 @@ public PatcherData Data
 
         public event Action<bool> CanCheckInternetConnectionChanged;
 
+        #endregion
+
+        #region Public fields
+
         public string EditorAppSecret;
 
         public int EditorOverrideLatestVersionId;
 
         public PatcherConfiguration DefaultConfiguration;
 
-        private PatcherState _state = PatcherState.None;
+        #endregion
 
-        public PatcherState State
-        {
-            get { return _state; }
-            set
-            {
-                _state = value;
-                OnStateChanged(_state);
-            }
-        }
+        #region Public properties
+
+        #region Decisions availability
 
         private bool _canUpdateApp;
 
@@ -123,9 +124,29 @@ public bool CanCheckInternetConnection
             }
         }
 
-        private PatcherError _error;
+        #endregion
+
+        private PatcherState _state = PatcherState.None;
+
+        public PatcherState State
+        {
+            get { return _state; }
+            set
+            {
+                _state = value;
+                OnStateChanged(_state);
+            }
+        }
+
         private PatcherData _data;
 
+        public PatcherData Data
+        {
+            get { return _data; }
+        }
+
+        private PatcherError _error;
+
         public PatcherError Error
         {
             get { return _error; }
@@ -136,6 +157,10 @@ public PatcherError Error
             }
         }
 
+        #endregion
+
+        #region Public methods
+
         public void SetUserDecision(UserDecision userDecision)
         {
             DebugLogger.Log("Setting user deicision.");
@@ -181,6 +206,10 @@ public void Cancel()
             }
         }
 
+        #endregion
+
+        #region Logging operations
+
         private void LogSystemInfo()
         {
             DebugLogger.LogVariable(Environment.Version, "Environment.Version");
@@ -204,16 +233,21 @@ private void LogPatcherInfo()
             DebugLogger.Log(string.Format("Patcher version - {0}", GetPatcherVersion()));
         }
 
+        #endregion
+
+        #region Unity events
+
         private void Awake()
         {
             DebugLogger.Log("Awake Unity event.");
 
-            LogSystemInfo();
-            LogPatcherInfo();
-
             Instance = this;
             Dispatcher.Initialize();
             Application.runInBackground = true;
+
+            LogSystemInfo();
+            LogPatcherInfo();
+
             try
             {
                 LoadPatcherData();
@@ -232,57 +266,116 @@ private void Start()
             DebugLogger.Log("Start Unity event.");
 
             DebugLogger.Log("Starting patcher thread.");
+
+            _keepThreadAlive = true;
             _thread = new Thread(ThreadFunc);
             _thread.Start();
         }
 
+        private void OnApplicationQuit()
+        {
+            DebugLogger.Log("OnApplicationQuit Unity event.");
+
+            if (_thread != null && _thread.IsAlive)
+            {
+                DebugLogger.Log("Cancelling quit because patcher thread is still alive.");
+
+                Application.CancelQuit();
+                StartCoroutine(DestroyPatcherThreadAndQuit());
+            }
+        }
+
         private void OnDestroy()
         {
             DebugLogger.Log("OnDestroy Unity event.");
 
-            if(_app != null)
+            if (_thread != null && _thread.IsAlive)
             {
-                _app.Dispose();
+                DestroyPatcherThread();
             }
+        }
 
-            DebugLogger.Log("Cleaning up thread.");
-
-            _hasBeenDestroyed = true;
+        private void DestroyPatcherThread()
+        {
+            DebugLogger.Log("Destroying patcher thread.");
 
-            if (_thread != null && _thread.IsAlive)
+            while (_thread != null && _thread.IsAlive)
             {
-                while(_thread.IsAlive)
-                {
-                    Cancel();
+                DebugLogger.Log("Trying to safely destroy patcher thread.");
+
+                _keepThreadAlive = false;
+                Cancel();
+                _thread.Interrupt();
 
-                    DebugLogger.Log("Interrupting thread.");
+                _thread.Join(1000);
 
-                    _thread.Interrupt();
-                    
+                if (_thread.IsAlive)
+                {
+                    DebugLogger.Log("Trying to force destroy patcher thread.");
+
+                    _thread.Abort();
                     _thread.Join(1000);
+                }
+            }
 
-                    if (_thread.IsAlive)
-                    {
-                        while (_thread.IsAlive)
-                        {
-                            DebugLogger.Log("Aborting thread.");
+            DebugLogger.Log("Patcher thread has been destroyed.");
+        }
 
-                            _thread.Abort();
-                            _thread.Join(1000);
-                        }
+        private IEnumerator DestroyPatcherThreadAndQuit()
+        {
+            DebugLogger.Log("Destroying patcher thread.");
+
+            if (_isThreadBeingDestroyed)
+            {
+                DebugLogger.Log("Patcher thread is already being destroyed.");
+                yield break;
+            }
+
+            _isThreadBeingDestroyed = true;
+
+            while (_thread != null && _thread.IsAlive)
+            {
+                DebugLogger.Log("Trying to safely destroy patcher thread.");
+
+                _keepThreadAlive = false;
+                Cancel();
+                _thread.Interrupt();
+
+                float startTime = Time.unscaledTime;
+                while (Time.unscaledTime - startTime < 1.0f && _thread.IsAlive)
+                {
+                    yield return null;
+                }
+
+                if (_thread.IsAlive)
+                {
+                    DebugLogger.Log("Trying to force destroy patcher thread.");
+
+                    _thread.Abort();
+                    startTime = Time.unscaledTime;
+                    while (Time.unscaledTime - startTime < 1.0f && _thread.IsAlive)
+                    {
+                        yield return null;
                     }
                 }
             }
+
+            DebugLogger.Log("Patcher thread has been destroyed. Quitting application.");
+            Application.Quit();
         }
 
+        #endregion
+
+        #region Thread
+
         private void ThreadFunc()
         {
             try
             {
                 CheckInternetConnection();
                 LoadPatcherConfiguration();
 
-                while (!_hasBeenDestroyed)
+                while (_keepThreadAlive)
                 {
                     try
                     {
@@ -307,6 +400,7 @@ private void ThreadFunc()
                     }
                     catch (OperationCanceledException)
                     {
+                        DebugLogger.Log("Patcher has been cancelled.");
                     }
                     catch (UnauthorizedAccessException)
                     {
@@ -336,16 +430,25 @@ private void ThreadFunc()
             {
                 DebugLogger.Log("Thread has been interrupted.");
             }
-            catch(ThreadAbortException)
+            catch (ThreadAbortException)
             {
                 DebugLogger.Log("Thread has been aborted.");
             }
-            catch(Exception exception)
+            catch (Exception exception)
             {
                 DebugLogger.LogException(exception);
                 DebugLogger.LogError("Exception in patcher thread.");
                 Quit();
             }
+            finally
+            {
+                if (_app != null)
+                {
+                    _app.Dispose();
+                }
+
+                DebugLogger.Log("Patcher thread has been destroyed.");
+            }
         }
 
         private void LoadPatcherData()
@@ -501,6 +604,10 @@ private void HandleErrorMessage(Exception exception)
             _errorMessageHandled.WaitOne();
         }
 
+        #endregion
+
+        #region Event invokers
+
         protected virtual void OnUpdateAppStatusChanged(OverallStatus obj)
         {
             Dispatcher.Invoke(() =>
@@ -548,5 +655,7 @@ protected virtual void OnCanCheckInternetConnectionChanged(bool obj)
                 if (CanCheckInternetConnectionChanged != null) CanCheckInternetConnectionChanged(obj);
             });
         }
+
+        #endregion
     }
 }