feat: implement IDisposable on ISceneManager and ISceneLoader (#27)

Author: joaoborks

Packages/mygamedevtools-scene-loader/Runtime/Interfaces/ISceneLoader.cs

@@ -1,11 +1,12 @@
+using System;
 using UnityEngine.SceneManagement;
 
 namespace MyGameDevTools.SceneLoading
 {
     /// <summary>
     /// Interface to standardize scene loading operations.
     /// </summary>
-    public interface ISceneLoader
+    public interface ISceneLoader : IDisposable
     {
         /// <summary>
         /// Reference to the <see cref="ISceneManager"/>, responsible for performing the scene loading operations.

Packages/mygamedevtools-scene-loader/Runtime/Interfaces/ISceneManager.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using UnityEngine.SceneManagement;
 
@@ -10,7 +11,7 @@ namespace MyGameDevTools.SceneLoading
     /// <br/>
     /// A scene manager should only keep track of scenes loaded within its own scope.
     /// </summary>
-    public interface ISceneManager
+    public interface ISceneManager : IDisposable
     {
         /// <summary>
         /// Reports that the active scene has changed, passing the <b>previous</b> and <b>current</b> active scene as parameters.
@@ -53,7 +54,9 @@ public interface ISceneManager
         /// <param name="setIndexActive">Index of the desired scene to set active, based on the <paramref name="sceneInfos"/> array.</param>
         /// <param name="progress">Object to report the loading operations progress to, from 0 to 1.</param>
         /// <returns>A <see cref="System.Threading.Tasks.ValueTask{TResult}"/> with all scenes loaded.</returns>
-        ValueTask<Scene[]> LoadScenesAsync(ILoadSceneInfo[] sceneInfos, int setIndexActive = -1, IProgress<float> progress = null);
+        /// <exception cref="ArgumentException">When scene info group is null, empty or the setIndexName is bigger than the scene length.</exception>
+        /// <exception cref="InvalidOperationException">When the provided scene info group fails to produce valid load scene operations.</exception>
+        ValueTask<Scene[]> LoadScenesAsync(ILoadSceneInfo[] sceneInfos, int setIndexActive = -1, IProgress<float> progress = null, CancellationToken token = default);
 
         /// <summary>
         /// Loads a scene referenced by the <paramref name="sceneInfo"/>, optionally enabling it as the active scene.
@@ -63,7 +66,9 @@ public interface ISceneManager
         /// <param name="setActive">Should the loaded scene be enabled as the active scene?</param>
         /// <param name="progress">Object to report the loading operation progress to, from 0 to 1.</param>
         /// <returns>A <see cref="System.Threading.Tasks.ValueTask{TResult}"/> with the loaded scene as the result.</returns>
-        ValueTask<Scene> LoadSceneAsync(ILoadSceneInfo sceneInfo, bool setActive = false, IProgress<float> progress = null);
+        /// <exception cref="ArgumentException">When scene info is null.</exception>
+        /// <exception cref="InvalidOperationException">When the provided scene info fails to produce a valid load scene operation.</exception>
+        ValueTask<Scene> LoadSceneAsync(ILoadSceneInfo sceneInfo, bool setActive = false, IProgress<float> progress = null, CancellationToken token = default);
 
         /// <summary>
         /// Unloads all scenes provided by the <paramref name="sceneInfos"/> array in parallel.
@@ -74,7 +79,9 @@ public interface ISceneManager
         /// <br/>
         /// Note that in some cases, the returned scenes might no longer have a reference to its native representation, hich means its <see cref="Scene.handle"/> will not point anywhere and you won't be able to perform equal comparisons between scenes.
         /// </returns>
-        ValueTask<Scene[]> UnloadScenesAsync(ILoadSceneInfo[] sceneInfos);
+        /// <exception cref="ArgumentException">When scene info group is null or empty.</exception>
+        /// <exception cref="InvalidOperationException">When the provided scene info group fails to produce valid unload scene operations.</exception>
+        ValueTask<Scene[]> UnloadScenesAsync(ILoadSceneInfo[] sceneInfos, CancellationToken token = default);
 
         /// <summary>
         /// Unloads a scene referenced by the <paramref name="sceneInfo"/>.
@@ -85,7 +92,9 @@ public interface ISceneManager
         /// <br/>
         /// Note that in some cases, the returned scene might no longer have a reference to its native representation, which means its <see cref="Scene.handle"/> will not point anywhere and you won't be able to perform equal comparisons between scenes.
         /// </returns>
-        ValueTask<Scene> UnloadSceneAsync(ILoadSceneInfo sceneInfo);
+        /// <exception cref="ArgumentException">When scene info is null.</exception>
+        /// <exception cref="InvalidOperationException">When the provided scene info fails to produce a valid unload scene operation.</exception>
+        ValueTask<Scene> UnloadSceneAsync(ILoadSceneInfo sceneInfo, CancellationToken token = default);
 
         /// <summary>
         /// Gets the current active scene in this <see cref="ISceneManager"/> instance.

Packages/mygamedevtools-scene-loader/Runtime/Managers/SceneManager.cs

@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.SceneManagement;
@@ -28,9 +29,19 @@ public class SceneManager : ISceneManager, ISceneManagerReporter
 
         readonly List<Scene> _unloadingScenes = new List<Scene>();
         readonly List<Scene> _loadedScenes = new List<Scene>();
+        readonly CancellationTokenSource _lifetimeToken = new CancellationTokenSource();
 
         Scene _activeScene;
 
+        public void Dispose()
+        {
+            _lifetimeToken.Cancel();
+            _lifetimeToken.Dispose();
+
+            _unloadingScenes.Clear();
+            _loadedScenes.Clear();
+        }
+
         public void SetActiveScene(Scene scene)
         {
             var validScene = scene.IsValid();
@@ -69,7 +80,89 @@ public Scene GetLoadedSceneByName(string name)
             throw new ArgumentException($"[{GetType().Name}] Could not find any loaded scene with the name '{name}'.", nameof(name));
         }
 
-        public async ValueTask<Scene[]> LoadScenesAsync(ILoadSceneInfo[] sceneInfos, int setIndexActive = -1, IProgress<float> progress = null)
+        public async ValueTask<Scene[]> LoadScenesAsync(ILoadSceneInfo[] sceneInfos, int setIndexActive = -1, IProgress<float> progress = null, CancellationToken token = default)
+        {
+            CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(_lifetimeToken.Token, token);
+            try
+            {
+                return await LoadScenesAsync_Internal(sceneInfos, setIndexActive, progress, linkedSource.Token);
+            }
+            catch (OperationCanceledException cancelException)
+            {
+                Debug.LogWarningFormat("[{0}] LoadScenesAsync was canceled. Exception:\n{1}", GetType().Name, cancelException);
+                throw;
+            }
+            finally
+            {
+                linkedSource.Dispose();
+            }
+        }
+
+        public async ValueTask<Scene> LoadSceneAsync(ILoadSceneInfo sceneInfo, bool setActive = false, IProgress<float> progress = null, CancellationToken token = default)
+        {
+            sceneInfo = sceneInfo ?? throw new NullReferenceException($"[{GetType().Name}] Provided scene info is null.");
+
+            CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(_lifetimeToken.Token, token);
+            Scene[] loadedScenes = null;
+            try
+            {
+                loadedScenes = await LoadScenesAsync_Internal(new ILoadSceneInfo[] { sceneInfo }, setActive ? 0 : -1, progress, linkedSource.Token);
+            }
+            catch (OperationCanceledException cancelException)
+            {
+                Debug.LogWarningFormat("[{0}] LoadSceneAsync was canceled. Exception:\n{1}", GetType().Name, cancelException);
+                throw;
+            }
+            finally
+            {
+                linkedSource.Dispose();
+            }
+
+            return loadedScenes != null && loadedScenes.Length > 0 ? loadedScenes[0] : default;
+        }
+
+        public async ValueTask<Scene[]> UnloadScenesAsync(ILoadSceneInfo[] sceneInfos, CancellationToken token = default)
+        {
+            CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(_lifetimeToken.Token, token);
+            try
+            {
+                return await UnloadScenesAsync_Internal(sceneInfos, linkedSource.Token);
+            }
+            catch (OperationCanceledException cancelException)
+            {
+                Debug.LogWarningFormat("[{0}] UnloadScenesAsync was canceled. Exception:\n{1}", GetType().Name, cancelException);
+                throw;
+            }
+            finally
+            {
+                linkedSource.Dispose();
+            }
+        }
+
+        public async ValueTask<Scene> UnloadSceneAsync(ILoadSceneInfo sceneInfo, CancellationToken token = default)
+        {
+            sceneInfo = sceneInfo ?? throw new ArgumentNullException(nameof(sceneInfo), $"[{GetType().Name}] Provided scene info is null.");
+
+            CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(_lifetimeToken.Token, token);
+            Scene[] unloadedScenes = null;
+            try
+            {
+                unloadedScenes = await UnloadScenesAsync_Internal(new ILoadSceneInfo[] { sceneInfo }, linkedSource.Token);
+            }
+            catch (OperationCanceledException cancelException)
+            {
+                Debug.LogWarningFormat("[{0}] UnloadSceneAsync was canceled. Exception:\n{1}", GetType().Name, cancelException);
+                throw;
+            }
+            finally
+            {
+                linkedSource.Dispose();
+            }
+
+            return unloadedScenes != null && unloadedScenes.Length > 0 ? unloadedScenes[0] : default;
+        }
+
+        async ValueTask<Scene[]> LoadScenesAsync_Internal(ILoadSceneInfo[] sceneInfos, int setIndexActive, IProgress<float> progress, CancellationToken token)
         {
             if (sceneInfos == null || sceneInfos.Length == 0)
                 throw new ArgumentException(nameof(sceneInfos), $"[{GetType().Name}] Provided scene group is null or empty.");
@@ -78,18 +171,20 @@ public async ValueTask<Scene[]> LoadScenesAsync(ILoadSceneInfo[] sceneInfos, int
 
             var operationGroup = GetLoadSceneOperations(sceneInfos, ref setIndexActive);
             if (operationGroup.Operations.Count == 0)
-                return Array.Empty<Scene>();
+                throw new InvalidOperationException($"[{GetType().Name} Provided scene group was not able to generate any valid load scene operations.");
 
-            while (!operationGroup.IsDone)
+            while (!operationGroup.IsDone && !token.IsCancellationRequested)
             {
 #if USE_UNITASK
-                await UniTask.Yield();
+                await UniTask.Yield(token);
 #else
                 await Task.Yield();
 #endif
                 progress?.Report(operationGroup.Progress);
             }
 
+            token.ThrowIfCancellationRequested();
+
             var loadedScenes = GetLastUnityLoadedScenesByInfos(sceneInfos, ref setIndexActive);
 
             _loadedScenes.AddRange(loadedScenes);
@@ -102,23 +197,14 @@ public async ValueTask<Scene[]> LoadScenesAsync(ILoadSceneInfo[] sceneInfos, int
             return loadedScenes;
         }
 
-        public async ValueTask<Scene> LoadSceneAsync(ILoadSceneInfo sceneInfo, bool setActive = false, IProgress<float> progress = null)
-        {
-            sceneInfo = sceneInfo ?? throw new NullReferenceException($"[{GetType().Name}] Provided scene info is null.");
-            var loadedScenes = await LoadScenesAsync(new ILoadSceneInfo[] { sceneInfo }, setActive ? 0 : -1, progress);
-            if (loadedScenes.Length == 0)
-                return default;
-            return loadedScenes[0];
-        }
-
-        public async ValueTask<Scene[]> UnloadScenesAsync(ILoadSceneInfo[] sceneInfos)
+        async ValueTask<Scene[]> UnloadScenesAsync_Internal(ILoadSceneInfo[] sceneInfos, CancellationToken token)
         {
             if (sceneInfos == null || sceneInfos.Length == 0)
                 throw new ArgumentException($"[{GetType().Name}] Provided scene group is null or empty.", nameof(sceneInfos));
 
             var loadedScenes = GetLastLoadedScenesByInfos(sceneInfos, out var unloadingIndexes);
             if (loadedScenes.Count == 0)
-                return Array.Empty<Scene>();
+                throw new InvalidOperationException($"[{GetType().Name} Provided scene group was not able to generate any valid unload scene operations.");
 
             int unloadingLength = unloadingIndexes.Length;
             var unloadingScenes = new Scene[unloadingLength];
@@ -137,12 +223,16 @@ public async ValueTask<Scene[]> UnloadScenesAsync(ILoadSceneInfo[] sceneInfos)
                 _unloadingScenes.Add(scene);
             }
 
-            while (!operationGroup.IsDone)
+            while (!operationGroup.IsDone && !token.IsCancellationRequested)
+            {
 #if USE_UNITASK
-                await UniTask.Yield();
+                await UniTask.Yield(token);
 #else
                 await Task.Yield();
 #endif
+            }
+
+            token.ThrowIfCancellationRequested();
 
             foreach (var scene in loadedScenes)
             {
@@ -154,7 +244,7 @@ public async ValueTask<Scene[]> UnloadScenesAsync(ILoadSceneInfo[] sceneInfos)
 
             var tasks = new Task[unloadingLength];
             for (i = 0; i < unloadingLength; i++)
-                tasks[i] = WaitForSceneUnload(unloadingScenes[i]).AsTask();
+                tasks[i] = WaitForSceneUnload(unloadingScenes[i], token).AsTask();
 
             await Task.WhenAll(tasks);
 
@@ -163,23 +253,16 @@ public async ValueTask<Scene[]> UnloadScenesAsync(ILoadSceneInfo[] sceneInfos)
             return loadedScenes.ToArray();
         }
 
-        public async ValueTask<Scene> UnloadSceneAsync(ILoadSceneInfo sceneInfo)
-        {
-            sceneInfo = sceneInfo ?? throw new ArgumentNullException(nameof(sceneInfo), $"[{GetType().Name}] Provided scene info is null.");
-            var unloadedScenes = await UnloadScenesAsync(new ILoadSceneInfo[] { sceneInfo });
-            if (unloadedScenes.Length == 0)
-                return default;
-            return unloadedScenes[0];
-        }
-
-        async ValueTask<Scene> WaitForSceneUnload(Scene scene)
+        async ValueTask<Scene> WaitForSceneUnload(Scene scene, CancellationToken token)
         {
 #if USE_UNITASK
-            await UniTask.WaitUntil(() => !_unloadingScenes.Contains(scene));
+            await UniTask.WaitUntil(() => !_unloadingScenes.Contains(scene), cancellationToken: token);
 #else
-            while (_unloadingScenes.Contains(scene))
+            while (_unloadingScenes.Contains(scene) && !token.IsCancellationRequested)
                 await Task.Yield();
 #endif
+            token.ThrowIfCancellationRequested();
+
             return scene;
         }