Added lifetime extensions and other improvements

inc8877 · inc8877 · commit 0dbb0c8eb35c · 2021-09-02T16:38:46.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## v0.1.1
+
+### Added
+
+- LifetimeManagement extensions for base Addressables
+- invoking action when operation with addressables is complete
+- support for adding auto release trigger by asset string key
+
 ## v0.1.0
 
 ### Added
diff --git a/README.md b/README.md
@@ -21,7 +21,9 @@ If you find this project useful, star it, I will be grateful!
   - [Async](#async)
     - [Examples](#examples-1)
   - [Lifetime managment](#lifetime-managment)
-    - [Examples](#examples-2)
+    - [Addressables Extensions](#addressables-extensions)
+      - [Examples](#examples-2)
+    - [Examples](#examples-3)
 - [Credits](#credits)
 
 ## Roadmap
@@ -123,18 +125,30 @@ ManageAddressables.InstantiateAsync(figureAssetRefGO, onCompletion: (go =>
 
 When you load an addressable asset, you should release it as soon as you don't need it anymore, forgetting to do this can lead to many bad processes at runtime. Using the `Addressables Master` you can bind a release to the `GameoObject` that will do it for you automatically as soon as it is destroyed.
 
-Below are methods for working with assets with lifetime management:
+#### Addressables Extensions
 
-`Base methods`
+If you need to use standard operations for working with addressables assets, then you can use the extensions.
 
-> Important! Use base methods below only for assets that instanced via `Addressables Master`.
+```c#
+public static async Task<AsyncOperationHandle<T>> AddAutoRelease<T>(this AsyncOperationHandle<T> operationHandle, GameObject targetGO)
+```
+
+```c#
+public static async Task<AsyncOperationHandle<T>> AddAutoRelease<T>(this AsyncOperationHandle<T> operationHandle, GameObject targetGO, Action onCompletion)
+```
 
 ```c#
-public static void AddAutoReleaseAssetTrigger(AssetReference assetReference, GameObject targetGO)
+public static async Task<AsyncOperationHandle<GameObject>> AddReleaseOnDestroy(this AsyncOperationHandle<GameObject> operationHandle)
 ```
 
+##### Examples
+
 ```c#
-public static void AddAutoReleaseInstanceTrigger(AssetReference assetReference, GameObject targetGO)
+GameObject go = new GameObject("Temp");
+
+assetReferenceMaterial.LoadAssetAsync().AddAutoRelease(go);
+
+figureAssetRefGO.InstantiateAsync().AddReleaseOnDestroy();
 ```
 
 `Sync`
diff --git a/Runtime/AddresssablesExtensions.meta b/Runtime/AddresssablesExtensions.meta
diff --git a/Runtime/AddresssablesExtensions/LifetimeManagement.cs b/Runtime/AddresssablesExtensions/LifetimeManagement.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Threading.Tasks;
+using AddressablesMaster;
+using UnityEngine.ResourceManagement.AsyncOperations;
+
+namespace UnityEngine.AddressableAssets
+{
+    public static class LifetimeManagement
+    {
+
+        /// <summary>
+        /// Binds the release of the <see cref="UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle{T}"/>
+        /// to the OnDestroy of the target GameObject.
+        /// </summary>
+        public static async Task<AsyncOperationHandle<T>> AddAutoRelease<T>(this AsyncOperationHandle<T> operationHandle, GameObject targetGO)
+        {
+            while (!operationHandle.IsDone) await Task.Yield();
+
+            if (operationHandle.Status == AsyncOperationStatus.Failed) return default;
+
+            AddAutoReleaseTrigger(operationHandle, targetGO);
+
+            return operationHandle;
+        }
+
+        /// <summary>
+        /// Binds the release of the <see cref="UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle{T}"/>
+        /// to the OnDestroy of the target GameObject and invokes Action when destroyed.
+        /// </summary>
+        public static async Task<AsyncOperationHandle<T>> AddAutoRelease<T>(this AsyncOperationHandle<T> operationHandle, GameObject targetGO, Action onCompletion)
+        {
+            while (!operationHandle.IsDone) await Task.Yield();
+
+            if (operationHandle.Status == AsyncOperationStatus.Failed) return default;
+            
+            var operation = AddAutoReleaseTrigger(operationHandle, targetGO);
+
+            operation.OnDestroyEvent += onCompletion;
+
+            return operationHandle;
+        }
+        
+        /// <summary>
+        /// Binds the release of the instantiated GameObject to its OnDestroy.
+        /// </summary>
+        public static async Task<AsyncOperationHandle<GameObject>> AddReleaseOnDestroy(this AsyncOperationHandle<GameObject> operationHandle)
+        {
+            while (!operationHandle.IsDone) await Task.Yield();
+
+            if (operationHandle.Status == AsyncOperationStatus.Failed) return default;
+            
+            AddAutoReleaseTrigger(operationHandle, operationHandle.Result);
+
+            return operationHandle;
+        }
+
+        private static ReleaseHandleOnDestroy AddAutoReleaseTrigger(AsyncOperationHandle operationHandle,
+            GameObject targetGO)
+        {
+            _ = targetGO ?? throw new ArgumentNullException(nameof(targetGO));
+            
+            var trigger = targetGO.AddComponent<ReleaseHandleOnDestroy>();
+
+            trigger.OnDestroyEvent += () => Addressables.Release(operationHandle);
+
+            return trigger;
+        }
+    }
+}
diff --git a/Runtime/AddresssablesExtensions/LifetimeManagement.cs.meta b/Runtime/AddresssablesExtensions/LifetimeManagement.cs.meta
diff --git a/Runtime/ManageAddressables.Async.cs b/Runtime/ManageAddressables.Async.cs
@@ -15,7 +15,7 @@ namespace AddressablesMaster
 {
     public static partial class ManageAddressables
     {
-        public static async Task<OperationResult<IResourceLocator>> InitializeAsync()
+        public static async Task<OperationResult<IResourceLocator>> InitializeAsync(Action<OperationResult<IResourceLocator>> onCompletion = null)
         {
             Clear();
 
@@ -25,15 +25,20 @@ public static async Task<OperationResult<IResourceLocator>> InitializeAsync()
                 await operation.Task;
 
                 OnInitializeCompleted(operation);
-                return operation;
+                
+                OperationResult<IResourceLocator> operationResult = operation;
+                
+                onCompletion?.Invoke(operationResult);
+                
+                return operationResult;
             }
             catch (Exception e)
             {
                 throw e;
             }
         }
 
-        public static async Task<OperationResult<object>> LoadLocationsAsync(object key)
+        public static async Task<OperationResult<object>> LoadLocationsAsync(object key, Action<OperationResult<object>> onCompletion = null)
         {
             _ = key ?? throw new InvalidKeyException(key);
             
@@ -43,15 +48,21 @@ public static async Task<OperationResult<object>> LoadLocationsAsync(object key)
                 await operation.Task;
 
                 OnLoadLocationsCompleted(operation, key);
-                return new OperationResult<object>(operation.Status == AsyncOperationStatus.Succeeded, key);
+                
+                var operationResult = new OperationResult<object>(operation.Status == AsyncOperationStatus.Succeeded, key);
+                
+                onCompletion?.Invoke(operationResult);
+                
+                return operationResult;
             }
             catch (Exception e)
             {
                 throw e;
             }
         }
 
-        public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key) where T : Object
+        public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key, Action<T> onCompletion = null)
+            where T : Object
         {
             RuntimeKeyIsValid(key, true);
 
@@ -72,6 +83,7 @@ public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key) where
                 await operation.Task;
 
                 OnLoadAssetCompleted(operation, key, false);
+                onCompletion?.Invoke(operation.Result);
                 return operation;
             }
             catch (Exception e)
@@ -80,7 +92,8 @@ public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key) where
             }
         }
 
-        public static async Task<OperationResult<T>> LoadAssetAsync<T>(AssetReferenceT<T> reference, Action<T> onCompletion = null) where T : Object
+        public static async Task<OperationResult<T>> LoadAssetAsync<T>(AssetReferenceT<T> reference,
+            Action<T> onCompletion = null) where T : Object
         {
             RuntimeKeyIsValid(reference, out var key, true);
 
@@ -230,7 +243,7 @@ public static async Task<OperationResult<SceneInstance>> UnloadSceneAsync(AssetR
         }
         
         public static async Task<OperationResult<GameObject>> InstantiateAsync(string key, Transform parent = null, 
-            bool inWorldSpace = false, bool trackHandle = true)
+            bool inWorldSpace = false, bool trackHandle = true, Action<GameObject> onCompletion = null)
         {
             RuntimeKeyIsValid(key, true);
 
@@ -240,6 +253,7 @@ public static async Task<OperationResult<GameObject>> InstantiateAsync(string ke
                 await operation.Task;
 
                 OnInstantiateCompleted(operation, key, false);
+                onCompletion?.Invoke(operation.Result);
                 return operation;
             }
             catch (Exception e)
@@ -268,20 +282,42 @@ public static async Task<OperationResult<GameObject>> InstantiateAsync(AssetRefe
             }
         }
         
+        /// <summary>
+        /// Instantiates game object on the scene asynchronously and adds a trigger to the instance that
+        /// releases <see cref="AsyncOperationHandle"/> when the instance is destroyed.
+        /// </summary>
+        /// <returns>Instantiated GameObject on the scene.</returns>
+        public static async Task<GameObject> InstantiateAsyncWithAutoRelease(string key, Transform parent = null,
+            bool inWorldSpace = false, Action<GameObject> onCompletion = null)
+        {
+            var operationResult = LoadAssetAsync<GameObject>(key);
+            await operationResult;
+            
+            var instantiatedGO = Object.Instantiate(operationResult.Result.Value, parent, inWorldSpace);
+            AddAutoReleaseAssetTrigger(key, instantiatedGO);
+            
+            onCompletion?.Invoke(instantiatedGO);
+            
+            return instantiatedGO;
+        }
+        
         /// <summary>
         /// Instantiates game object on the scene asynchronously and adds a trigger to the instance that
         /// releases <see cref="AsyncOperationHandle"/> when the instance is destroyed.
         /// </summary>
         /// <returns>Instantiated game object on the scene.</returns>
         public static async Task<GameObject> InstantiateAsyncWithAutoRelease(
-            AssetReference assetReference, Transform parent = null, bool inWorldSpace = false)
+            AssetReference assetReference, Transform parent = null, bool inWorldSpace = false,
+            Action<GameObject> onCompletion = null)
         {
             var operationResult = LoadAssetAsync((AssetReferenceT<GameObject>)assetReference);
             await operationResult;
             
             var instantiatedGO = Object.Instantiate(operationResult.Result.Value, parent, inWorldSpace);
             AddAutoReleaseAssetTrigger(assetReference, instantiatedGO);
             
+            onCompletion?.Invoke(instantiatedGO);
+            
             return instantiatedGO;
         }
 
diff --git a/Runtime/ManageAddressables.BaseMethods.cs b/Runtime/ManageAddressables.BaseMethods.cs
@@ -44,11 +44,9 @@ public static void LoadAsset<T>(string key) where T : Object
 
             if (_assets.ContainsKey(key))
             {
-                if (!(_assets[key] is T))
-                {
-                    if (!SuppressWarningLogs)
-                        Debug.LogWarning(Exceptions.AssetKeyNotInstanceOf<T>(key));
-                }
+                if (_assets[key] is T) return;
+                if (!SuppressWarningLogs)
+                    Debug.LogWarning(Exceptions.AssetKeyNotInstanceOf<T>(key));
 
                 return;
             }
@@ -231,7 +229,19 @@ public static void Instantiate(AssetReference reference,
                 throw e;
             }
         }
-
+        
+        /// <summary>
+        /// USE ONLY IF TARGET LOADED VIA <see cref="ManageAddressables"/>.
+        /// Adds a trigger to the object and releases the target addressable asset when the game object is destroyed.
+        /// </summary>
+        /// <param name="key">Asset provided by a key that will be released upon game object destryed.</param>
+        /// <param name="targetGO">The object to which the trigger will be attached.</param>
+        public static void AddAutoReleaseAssetTrigger(string key, GameObject targetGO)
+        {
+            targetGO.AddComponent<ReleaseHandleOnDestroy>().OnDestroyEvent +=
+                () => ReleaseAsset(key);
+        }
+        
         /// <summary>
         /// USE ONLY IF TARGET LOADED VIA <see cref="ManageAddressables"/>.
         /// Adds a trigger to the object and releases the target addressable asset when the game object is destroyed.
@@ -244,6 +254,19 @@ public static void AddAutoReleaseAssetTrigger(AssetReference assetReference, Gam
                 () => ReleaseAsset(assetReference);
         }
         
+        /// <summary>
+        /// USE ONLY IF TARGET INSTANTIATED VIA <see cref="ManageAddressables"/>.
+        /// Adds a trigger to the object that is invoked when the object is destroyed
+        /// and releases the target asset instance.
+        /// </summary>
+        /// <param name="key">Asset provided by a key that will be released upon game object destryed.</param>
+        /// <param name="targetGO">The object to which the trigger will be attached.</param>
+        public static void AddAutoReleaseInstanceTrigger(string key, GameObject targetGO)
+        {
+            targetGO.AddComponent<ReleaseHandleOnDestroy>().OnDestroyEvent +=
+                () => ReleaseInstance(key, targetGO);
+        }
+
         /// <summary>
         /// USE ONLY IF TARGET INSTANTIATED VIA <see cref="ManageAddressables"/>.
         /// Adds a trigger to the object that is invoked when the object is destroyed
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.inc8877.addressables-master",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "displayName": "AddressablesMaster",
   "description": "Essential Addressables tool",
   "homepage": "https://github.com/inc8877/AddressablesMaster#readme",

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ namespace AddressablesMaster`
`15`	`15`	`{`
`16`	`16`	`public static partial class ManageAddressables`
`17`	`17`	`{`
`18`		`- public static async Task<OperationResult<IResourceLocator>> InitializeAsync()`
	`18`	`+ public static async Task<OperationResult<IResourceLocator>> InitializeAsync(Action<OperationResult<IResourceLocator>> onCompletion = null)`
`19`	`19`	`{`
`20`	`20`	`Clear();`
`21`	`21`
`@@ -25,15 +25,20 @@ public static async Task<OperationResult<IResourceLocator>> InitializeAsync()`
`25`	`25`	`await operation.Task;`
`26`	`26`
`27`	`27`	`OnInitializeCompleted(operation);`
`28`		`- return operation;`
	`28`	`+`
	`29`	`+ OperationResult<IResourceLocator> operationResult = operation;`
	`30`	`+`
	`31`	`+ onCompletion?.Invoke(operationResult);`
	`32`	`+`
	`33`	`+ return operationResult;`
`29`	`34`	`}`
`30`	`35`	`catch (Exception e)`
`31`	`36`	`{`
`32`	`37`	`throw e;`
`33`	`38`	`}`
`34`	`39`	`}`
`35`	`40`
`36`		`- public static async Task<OperationResult<object>> LoadLocationsAsync(object key)`
	`41`	`+ public static async Task<OperationResult<object>> LoadLocationsAsync(object key, Action<OperationResult<object>> onCompletion = null)`
`37`	`42`	`{`
`38`	`43`	`_ = key ?? throw new InvalidKeyException(key);`
`39`	`44`
`@@ -43,15 +48,21 @@ public static async Task<OperationResult<object>> LoadLocationsAsync(object key)`
`43`	`48`	`await operation.Task;`
`44`	`49`
`45`	`50`	`OnLoadLocationsCompleted(operation, key);`
`46`		`- return new OperationResult<object>(operation.Status == AsyncOperationStatus.Succeeded, key);`
	`51`	`+`
	`52`	`+ var operationResult = new OperationResult<object>(operation.Status == AsyncOperationStatus.Succeeded, key);`
	`53`	`+`
	`54`	`+ onCompletion?.Invoke(operationResult);`
	`55`	`+`
	`56`	`+ return operationResult;`
`47`	`57`	`}`
`48`	`58`	`catch (Exception e)`
`49`	`59`	`{`
`50`	`60`	`throw e;`
`51`	`61`	`}`
`52`	`62`	`}`
`53`	`63`
`54`		`- public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key) where T : Object`
	`64`	`+ public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key, Action<T> onCompletion = null)`
	`65`	`+ where T : Object`
`55`	`66`	`{`
`56`	`67`	`RuntimeKeyIsValid(key, true);`
`57`	`68`
`@@ -72,6 +83,7 @@ public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key) where`
`72`	`83`	`await operation.Task;`
`73`	`84`
`74`	`85`	`OnLoadAssetCompleted(operation, key, false);`
	`86`	`+ onCompletion?.Invoke(operation.Result);`
`75`	`87`	`return operation;`
`76`	`88`	`}`
`77`	`89`	`catch (Exception e)`
`@@ -80,7 +92,8 @@ public static async Task<OperationResult<T>> LoadAssetAsync<T>(string key) where`
`80`	`92`	`}`
`81`	`93`	`}`
`82`	`94`
`83`		`- public static async Task<OperationResult<T>> LoadAssetAsync<T>(AssetReferenceT<T> reference, Action<T> onCompletion = null) where T : Object`
	`95`	`+ public static async Task<OperationResult<T>> LoadAssetAsync<T>(AssetReferenceT<T> reference,`
	`96`	`+ Action<T> onCompletion = null) where T : Object`
`84`	`97`	`{`
`85`	`98`	`RuntimeKeyIsValid(reference, out var key, true);`
`86`	`99`
`@@ -230,7 +243,7 @@ public static async Task<OperationResult<SceneInstance>> UnloadSceneAsync(AssetR`
`230`	`243`	`}`
`231`	`244`
`232`	`245`	`public static async Task<OperationResult<GameObject>> InstantiateAsync(string key, Transform parent = null,`
`233`		`- bool inWorldSpace = false, bool trackHandle = true)`
	`246`	`+ bool inWorldSpace = false, bool trackHandle = true, Action<GameObject> onCompletion = null)`
`234`	`247`	`{`
`235`	`248`	`RuntimeKeyIsValid(key, true);`
`236`	`249`
`@@ -240,6 +253,7 @@ public static async Task<OperationResult<GameObject>> InstantiateAsync(string ke`
`240`	`253`	`await operation.Task;`
`241`	`254`
`242`	`255`	`OnInstantiateCompleted(operation, key, false);`
	`256`	`+ onCompletion?.Invoke(operation.Result);`
`243`	`257`	`return operation;`
`244`	`258`	`}`
`245`	`259`	`catch (Exception e)`
`@@ -268,20 +282,42 @@ public static async Task<OperationResult<GameObject>> InstantiateAsync(AssetRefe`
`268`	`282`	`}`
`269`	`283`	`}`
`270`	`284`
	`285`	`+ /// <summary>`
	`286`	`+ /// Instantiates game object on the scene asynchronously and adds a trigger to the instance that`
	`287`	`+ /// releases <see cref="AsyncOperationHandle"/> when the instance is destroyed.`
	`288`	`+ /// </summary>`
	`289`	`+ /// <returns>Instantiated GameObject on the scene.</returns>`
	`290`	`+ public static async Task<GameObject> InstantiateAsyncWithAutoRelease(string key, Transform parent = null,`
	`291`	`+ bool inWorldSpace = false, Action<GameObject> onCompletion = null)`
	`292`	`+ {`
	`293`	`+ var operationResult = LoadAssetAsync<GameObject>(key);`
	`294`	`+ await operationResult;`
	`295`	`+`
	`296`	`+ var instantiatedGO = Object.Instantiate(operationResult.Result.Value, parent, inWorldSpace);`
	`297`	`+ AddAutoReleaseAssetTrigger(key, instantiatedGO);`
	`298`	`+`
	`299`	`+ onCompletion?.Invoke(instantiatedGO);`
	`300`	`+`
	`301`	`+ return instantiatedGO;`
	`302`	`+ }`
	`303`	`+`
`271`	`304`	`/// <summary>`
`272`	`305`	`/// Instantiates game object on the scene asynchronously and adds a trigger to the instance that`
`273`	`306`	`/// releases <see cref="AsyncOperationHandle"/> when the instance is destroyed.`
`274`	`307`	`/// </summary>`
`275`	`308`	`/// <returns>Instantiated game object on the scene.</returns>`
`276`	`309`	`public static async Task<GameObject> InstantiateAsyncWithAutoRelease(`
`277`		`- AssetReference assetReference, Transform parent = null, bool inWorldSpace = false)`
	`310`	`+ AssetReference assetReference, Transform parent = null, bool inWorldSpace = false,`
	`311`	`+ Action<GameObject> onCompletion = null)`
`278`	`312`	`{`
`279`	`313`	`var operationResult = LoadAssetAsync((AssetReferenceT<GameObject>)assetReference);`
`280`	`314`	`await operationResult;`
`281`	`315`
`282`	`316`	`var instantiatedGO = Object.Instantiate(operationResult.Result.Value, parent, inWorldSpace);`
`283`	`317`	`AddAutoReleaseAssetTrigger(assetReference, instantiatedGO);`
`284`	`318`
	`319`	`+ onCompletion?.Invoke(instantiatedGO);`
	`320`	`+`
`285`	`321`	`return instantiatedGO;`
`286`	`322`	`}`
`287`	`323`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "com.inc8877.addressables-master",`
`3`		`- "version": "0.1.0",`
	`3`	`+ "version": "0.1.1",`
`4`	`4`	`"displayName": "AddressablesMaster",`
`5`	`5`	`"description": "Essential Addressables tool",`
`6`	`6`	`"homepage": "https://github.com/inc8877/AddressablesMaster#readme",`