[WIP] Zenject 対応

Assets/Scripts/CAFU/Routing/Data/DataStore/SceneDataStore.cs

@@ -1,23 +1,24 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using CAFU.Core.Data.DataStore;
-using CAFU.Core.Utility;
 using CAFU.Routing.Data.Entity;
 using UniRx;
 using UnityEngine;
 using UnityEngine.SceneManagement;
+// ReSharper disable UseStringInterpolation
 
 namespace CAFU.Routing.Data.DataStore {
 
-    public interface ISceneDataStore : IDataStore {
+    public interface ISceneDataStore : ISingletonDataStore {
 
-        IObservable<SceneEntity> LoadSceneAsObservable(string sceneName, LoadSceneMode loadSceneMode);
+        UniRx.IObservable<SceneEntity> LoadSceneAsObservable(string sceneName, LoadSceneMode loadSceneMode);
 
-        IObservable<SceneEntity> UnloadSceneAsObservable(string sceneName);
+        UniRx.IObservable<SceneEntity> UnloadSceneAsObservable(string sceneName);
 
     }
 
     // FIXME: Scenes in Build 版と AssetBundle 版とでクラスを分ける
-    public class SceneDataStore : ISceneDataStore, ISingleton {
+    public class SceneDataStore : ISceneDataStore {
 
         public class Factory : DefaultDataStoreFactory<SceneDataStore> {
 
@@ -32,14 +33,11 @@ private Dictionary<string, SceneEntity> SceneEntityCacheMap {
                 }
                 return this.sceneEntityCacheMap;
             }
-            set {
-                this.sceneEntityCacheMap = value;
-            }
         }
 
-        public IObservable<SceneEntity> LoadSceneAsObservable(string sceneName, LoadSceneMode loadSceneMode) {
+        public UniRx.IObservable<SceneEntity> LoadSceneAsObservable(string sceneName, LoadSceneMode loadSceneMode) {
             if (this.SceneEntityCacheMap.ContainsKey(sceneName)) {
-                return Observable.Throw<SceneEntity>(new System.ArgumentException(string.Format("Scene '{0}' already has loaded.", sceneName)));
+                return Observable.Throw<SceneEntity>(new ArgumentException(string.Format("Scene '{0}' already has loaded.", sceneName)));
             }
             return SceneManager.LoadSceneAsync(sceneName, loadSceneMode)
                 .AsObservable()
@@ -55,11 +53,11 @@ public IObservable<SceneEntity> LoadSceneAsObservable(string sceneName, LoadScen
                 );
         }
 
-        public IObservable<SceneEntity> UnloadSceneAsObservable(string sceneName) {
+        public UniRx.IObservable<SceneEntity> UnloadSceneAsObservable(string sceneName) {
             if (!this.SceneEntityCacheMap.ContainsKey(sceneName)) {
                 // エディタ実行でない場合には「読み込まれていない」旨を Exception として Throw する
                 if (!Application.isEditor) {
-                    return Observable.Throw<SceneEntity>(new System.ArgumentException(string.Format("Scene '{0}' has not loaded yet.", sceneName)));
+                    return Observable.Throw<SceneEntity>(new ArgumentException(string.Format("Scene '{0}' has not loaded yet.", sceneName)));
                 }
                 // エディタ実行の場合のみ、初期シーンの直接読み込みを考慮して値を疑似構築する
                 this.SceneEntityCacheMap[sceneName] = new SceneEntity() {

Assets/Scripts/CAFU/Routing/Domain/Repository/RoutingRepository.cs

@@ -1,10 +1,19 @@
 using CAFU.Core.Domain.Repository;
 using CAFU.Routing.Data.DataStore;
 using UniRx;
+using Zenject;
 
 namespace CAFU.Routing.Domain.Repository {
 
-    public class RoutingRepository : IRepository {
+    public interface IRoutingRepository : IRepository {
+
+        IObservable<Data.Entity.SceneEntity> LoadSceneAsObservable(string sceneName, UnityEngine.SceneManagement.LoadSceneMode loadSceneMode);
+
+        IObservable<Data.Entity.SceneEntity> UnloadSceneAsObservable(string sceneName);
+
+    }
+
+    public class RoutingRepository : IRoutingRepository {
 
         public class Factory : DefaultRepositoryFactory<RoutingRepository> {
 
@@ -15,6 +24,7 @@ protected override void Initialize(RoutingRepository instance) {
 
         }
 
+        [Inject]
         private ISceneDataStore SceneDataStore { get; set; }
 
         public IObservable<Data.Entity.SceneEntity> LoadSceneAsObservable(string sceneName, UnityEngine.SceneManagement.LoadSceneMode loadSceneMode) {
@@ -27,4 +37,4 @@ protected override void Initialize(RoutingRepository instance) {
 
     }
 
-}
+}

Assets/Scripts/CAFU/Routing/Domain/Translator/RoutingTranslator.cs

@@ -7,7 +7,11 @@
 
 namespace CAFU.Routing.Domain.Translator {
 
-    public class RoutingTranslator : IAsyncModelTranslator<SceneEntity, SceneModel> {
+    public interface IRoutingTranslator : IAsyncModelTranslator<SceneEntity, SceneModel> {
+
+    }
+
+    public class RoutingTranslator : IRoutingTranslator {
 
         public class Factory : DefaultTranslatorFactory<RoutingTranslator> {
 

Assets/Scripts/CAFU/Routing/Domain/UseCase/RoutingUseCase.cs

@@ -4,27 +4,49 @@
 using CAFU.Routing.Domain.Translator;
 using UniRx;
 using UnityEngine.SceneManagement;
+using Zenject;
 
 namespace CAFU.Routing.Domain.UseCase {
 
-    public class RoutingUseCase : ISingletonUseCase {
+    public interface IRoutingUseCase : ISingletonUseCase {
+
+        void LoadScene(string sceneName, LoadSceneMode loadSceneMode);
+
+        void UnloadScene(string sceneName);
+
+        IObservable<SceneModel> LoadSceneAsObservable(string sceneName, LoadSceneMode loadSceneMode);
+
+        IObservable<SceneModel> UnloadSceneAsObservable(string sceneName);
+
+        IObservable<SceneModel> OnLoadSceneAsObservable();
+
+        IObservable<SceneModel> OnLoadSceneAsObservable(string sceneName);
+
+        IObservable<SceneModel> OnUnloadSceneAsObservable();
+
+        IObservable<SceneModel> OnUnloadSceneAsObservable(string sceneName);
+
+    }
+
+    public class RoutingUseCase : IRoutingUseCase {
 
         // FIXME: Use Zenject
         public class Factory : DefaultUseCaseFactory<RoutingUseCase> {
 
             protected override void Initialize(RoutingUseCase instance) {
                 base.Initialize(instance);
-                instance.LoadSceneSubject = new Subject<SceneModel>();
-                instance.UnloadSceneSubject = new Subject<SceneModel>();
                 instance.RoutingRepository = new RoutingRepository.Factory().Create();
                 instance.RoutingTranslator = new RoutingTranslator.Factory().Create();
+                instance.Initialize();
             }
 
         }
 
-        private RoutingRepository RoutingRepository { get; set; }
+        [Inject]
+        private IRoutingRepository RoutingRepository { get; set; }
 
-        private RoutingTranslator RoutingTranslator { get; set; }
+        [Inject]
+        private IRoutingTranslator RoutingTranslator { get; set; }
 
         private Subject<SceneModel> LoadSceneSubject { get; set; }
 
@@ -82,6 +104,12 @@ public IObservable<SceneModel> OnUnloadSceneAsObservable(string sceneName) {
             return this.OnUnloadSceneAsObservable().Where(x => x.Name == sceneName).AsObservable();
         }
 
+        [Inject]
+        private void Initialize() {
+            this.LoadSceneSubject = new Subject<SceneModel>();
+            this.UnloadSceneSubject = new Subject<SceneModel>();
+        }
+
     }
 
 }

Assets/Scripts/CAFU/Routing/Presentation/Presenter/RoutingPresenter.cs

@@ -0,0 +1,12 @@
+using CAFU.Core.Presentation.Presenter;
+using CAFU.Routing.Domain.UseCase;
+
+namespace CAFU.Routing.Presentation.Presenter {
+
+    public interface IRoutingPresenter : IPresenter {
+
+        IRoutingUseCase RoutingUseCase { get; }
+
+    }
+
+}

Assets/Scripts/CAFU/Routing/RoutingInstaller.cs

@@ -0,0 +1,21 @@
+using CAFU.Routing.Data.DataStore;
+using CAFU.Routing.Domain.Repository;
+using CAFU.Routing.Domain.Translator;
+using CAFU.Routing.Domain.UseCase;
+using Zenject;
+// ReSharper disable ClassNeverInstantiated.Global
+
+namespace Modules.Scripts.CAFU.Routing {
+
+    public class RoutingInstaller : Installer<RoutingInstaller> {
+
+        public override void InstallBindings() {
+            this.Container.Bind<IRoutingUseCase>().To<RoutingUseCase>().AsSingle();
+            this.Container.Bind<IRoutingRepository>().To<RoutingRepository>().AsTransient();
+            this.Container.Bind<IRoutingTranslator>().To<RoutingTranslator>().AsTransient();
+            this.Container.Bind<ISceneDataStore>().To<SceneDataStore>().AsCached();
+        }
+
+    }
+
+}