Added

Author: Guillemsc

Runtime/Loading/Process.meta

@@ -0,0 +1,16 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Juce.CoreUnity.Loading.Process
+{
+    public interface ILoadingProcess
+    {
+        event Action OnCompleted;
+
+        ILoadingProcess NewChild();
+
+        Task StartLoading(CancellationToken cancellationToken);
+        Task CompletedLoading(CancellationToken cancellationToken);
+    }
+}

Runtime/Loading/Process/ILoadingProcess.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Juce.CoreUnity.Loading.Process
+{
+    public sealed class LoadingProcess : ILoadingProcess
+    {
+        private readonly IReadOnlyList<Func<CancellationToken, Task>> beforeLoad = Array.Empty<Func<CancellationToken, Task>>();
+        private readonly IReadOnlyList<Func<CancellationToken, Task>> afterLoad = Array.Empty<Func<CancellationToken, Task>>();
+
+        public event Action OnCompleted;
+
+        private LoadingProcess()
+        {
+          
+        }
+
+        private LoadingProcess(
+            IReadOnlyList<Func<CancellationToken, Task>> beforeLoad,
+            IReadOnlyList<Func<CancellationToken, Task>> afterLoad
+            )
+        {
+            this.beforeLoad = beforeLoad;
+            this.afterLoad = afterLoad;
+        }
+
+        public static ILoadingProcess New(
+            IReadOnlyList<Func<CancellationToken, Task>> beforeLoad,
+            IReadOnlyList<Func<CancellationToken, Task>> afterLoad
+            )
+        {
+            return new LoadingProcess(beforeLoad, afterLoad);
+        }
+
+        public ILoadingProcess NewChild()
+        {
+            return new LoadingProcess();
+        }
+
+        public async Task StartLoading(CancellationToken cancellationToken)
+        {
+            foreach(Func<CancellationToken, Task> before in beforeLoad)
+            {
+                await before?.Invoke(cancellationToken);
+            }
+        }
+
+        public async Task CompletedLoading(CancellationToken cancellationToken)
+        {
+            foreach (Func<CancellationToken, Task> after in afterLoad)
+            {
+                await after?.Invoke(cancellationToken);
+            }
+
+            OnCompleted?.Invoke();
+        }
+    }
+}

Runtime/Loading/Process/ILoadingProcess.cs.meta

@@ -1,11 +1,15 @@
 using Juce.Core.Loading.Process;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Juce.CoreUnity.Loading.Services
 {
     public interface ILoadingService
     {
-        bool IsLoading { get; }
+        void AddBeforeLoading(Func<CancellationToken, Task> func);
+        void AddAfterLoading(Func<CancellationToken, Task> func);
 
-        bool TryStartLoading(out ILoadingProcess loadingProcess);
+        bool TryGetNewProcess(out ILoadingProcess loadingProcess);
     }
 }

Runtime/Loading/Process/LoadingProcess.cs

@@ -1,22 +1,39 @@
 using Juce.Core.Loading.Process;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Juce.CoreUnity.Loading.Services
 {
     public class LoadingService : ILoadingService
     {
-        public bool IsLoading { get; private set; }
+        private readonly List<Func<CancellationToken, Task>> beforeLoad = new List<Func<CancellationToken, Task>>();
+        private readonly List<Func<CancellationToken, Task>> afterLoad = new List<Func<CancellationToken, Task>>();
 
-        public bool TryStartLoading(out ILoadingProcess loadingProcess)
+        private bool isLoading;
+
+        public void AddAfterLoading(Func<CancellationToken, Task> func)
+        {
+            beforeLoad.Add(func);
+        }
+
+        public void AddBeforeLoading(Func<CancellationToken, Task> func)
+        {
+            afterLoad.Add(func);
+        }
+
+        public bool TryGetNewProcess(out ILoadingProcess loadingProcess)
         {
-            if(IsLoading)
+            if(isLoading)
             {
                 loadingProcess = default;
                 return false;
             }
 
-            IsLoading = true;
+            isLoading = true;
 
-            loadingProcess = LoadingProcess.New();
+            loadingProcess = LoadingProcess.New(beforeLoad, afterLoad);
 
             loadingProcess.OnCompleted += OnLoadingProcessCompleted;
 
@@ -25,7 +42,7 @@ public bool TryStartLoading(out ILoadingProcess loadingProcess)
 
         private void OnLoadingProcessCompleted()
         {
-            IsLoading = false;
+            isLoading = false;
         }
     }
 }