public InitializableHandler(
            [InjectOptional]
            List<IInitializable> initializables,
            [InjectOptional]
            List<Tuple<Type, int>> priorities,
            DiContainer container)
        {
            var priorityMap = priorities.ToDictionary(x => x.First, x => x.Second);

            if (Assert.IsEnabled)
            {
                WarnForMissingBindings(initializables, container);
            }

            foreach (var initializable in initializables)
            {
                int priority;
                bool success = priorityMap.TryGetValue(initializable.GetType(), out priority);

                if (!success)
                {
                    //Debug.LogWarning(
                        //String.Format("IInitializable with type '{0}' does not have a priority assigned", //initializable.GetType()));
                }

                _initializables.Add(
                    new InitializableInfo(initializable, success ? (int?)priority : null));
            }
        }
        public DisposablesHandler(
            [InjectOptional]
            List<IDisposable> disposables,
            [InjectOptional]
            List<Tuple<Type, int>> priorities,
            DiContainer container)
        {
            _container = container;
            var priorityMap = priorities.ToDictionary(x => x.First, x => x.Second);

            foreach (var disposable in disposables)
            {
                int priority;
                bool success = priorityMap.TryGetValue(disposable.GetType(), out priority);

                if (!success)
                {
                    //Log.Warn(
                        //String.Format("IDisposable with type '{0}' does not have a priority assigned", //disposable.GetType()));
                }

                _disposables.Add(
                    new DisposableInfo(disposable, success ? (int?)priority : null));
            }

            Log.DebugFormat("Loaded {0} IDisposables to DisposablesHandler", _disposables.Count());
        }
        internal static void Inject(DiContainer container, object injectable, IEnumerable<object> additional, bool shouldUseAll, ZenjectTypeInfo typeInfo)
        {
            Assert.IsEqual(typeInfo.TypeAnalyzed, injectable.GetType());
            Assert.That(injectable != null);

            var additionalCopy = additional.ToList();

            foreach (var injectInfo in typeInfo.FieldInjectables.Concat(typeInfo.PropertyInjectables))
            {
                bool didInject = InjectFromExtras(injectInfo, injectable, additionalCopy);

                if (!didInject)
                {
                    InjectFromResolve(injectInfo, container, injectable);
                }
            }

            if (shouldUseAll && !additionalCopy.IsEmpty())
            {
                throw new ZenjectResolveException(
                    "Passed unnecessary parameters when injecting into type '{0}'. \nExtra Parameters: {1}\nObject graph:\n{2}"
                        .With(injectable.GetType().Name(), String.Join(",", additionalCopy.Select(x => x.GetType().Name()).ToArray()), DiContainer.GetCurrentObjectGraph()));
            }

            foreach (var methodInfo in typeInfo.PostInjectMethods)
            {
                using (ProfileBlock.Start("{0}.{1}()".With(injectable.GetType(), methodInfo.Name)))
                {
                    methodInfo.Invoke(injectable, new object[0]);
                }
            }
        }
Exemple #4
0
 public GenericBinder(
     DiContainer container, Type contractType, SingletonProviderMap singletonMap)
     : base(container, contractType)
 {
     Assert.That(contractType.IsOpenGenericType(), "Expected open generic type in GenericBinder");
     _singletonMap = singletonMap;
 }
Exemple #5
0
 public Binder(
     DiContainer container,
     Type contractType)
 {
     _container = container;
     _contractType = contractType;
 }
 public static void InjectGameObject(DiContainer container, GameObject gameObj)
 {
     foreach (var monoBehaviour in gameObj.GetComponents<MonoBehaviour>())
     {
         InjectMonoBehaviour(container, monoBehaviour);
     }
 }
Exemple #7
0
        public StandardKernel(
            [InjectOptional]
            List<ITickable> tickables,
            [InjectOptional]
            List<Tuple<Type, int>> priorities,
            DiContainer container)
        {
            var priorityMap = priorities.ToDictionary(x => x.First, x => x.Second);

            if (Assert.IsEnabled)
            {
                WarnForMissingBindings(tickables, container);
            }

            foreach (var tickable in tickables)
            {
                int priority;
                bool success = priorityMap.TryGetValue(tickable.GetType(), out priority);

                if (!success)
                {
                    //Debug.LogWarning(
                        //String.Format("Tickable with type '{0}' does not have a tick priority assigned",
                        //tickable.GetType()));
                }

                var tickInfo = (success ? new TickableInfo(tickable, priority) : new TickableInfo(tickable));
                _queuedTasks.Add(tickInfo);
            }
        }
        public static void OutputObjectGraphToFile(DiContainer container, string outputPath)
        {
            #if !UNITY_WEBPLAYER
            // Output the entire object graph to file
            var graph = container.CalculateObjectGraph<IDependencyRoot>();

            var resultStr = "digraph { \n";

            foreach (var entry in graph)
            {
                // ignore these to clean up the graph
                if (entry.Key == typeof(EntryPointInitializer) || entry.Key == typeof(KernelInitializer))
                {
                    continue;
                }

                foreach (var dependencyType in entry.Value)
                {
                    // ignore factory dependency to clean up graph
                    if (dependencyType == typeof(DiContainer))
                    {
                        continue;
                    }

                    resultStr += GetFormattedTypeName(entry.Key) + " -> " + GetFormattedTypeName(dependencyType) + "; \n";
                }
            }

            resultStr += " }";

            System.IO.File.WriteAllText(outputPath, resultStr);
            #endif
        }
Exemple #9
0
        public static void OutputObjectGraphForCurrentScene(
            DiContainer container, IEnumerable<Type> ignoreTypes, IEnumerable<Type> contractTypes)
        {
            string dotFilePath = EditorUtility.SaveFilePanel("Choose the path to export the object graph", "", "ObjectGraph", "dot");

            if (!dotFilePath.IsEmpty())
            {
                ObjectGraphVisualizer.OutputObjectGraphToFile(
                    container, dotFilePath, ignoreTypes, contractTypes);

                var dotExecPath = EditorPrefs.GetString("Zenject.GraphVizDotExePath", "");

                if (dotExecPath.IsEmpty() || !File.Exists(dotExecPath))
                {
                    EditorUtility.DisplayDialog(
                        "GraphViz", "Unable to locate GraphViz.  Please select the graphviz 'dot.exe' file which can be found at [GraphVizInstallDirectory]/bin/dot.exe.  If you do not have GraphViz you can download it at http://www.graphviz.org", "Ok");

                    dotExecPath = EditorUtility.OpenFilePanel("Please select dot.exe from GraphViz bin directory", "", "exe");

                    EditorPrefs.SetString("Zenject.GraphVizDotExePath", dotExecPath);
                }

                if (!dotExecPath.IsEmpty())
                {
                    RunDotExe(dotExecPath, dotFilePath);
                }
            }
        }
 public SingletonLazyCreator(
     DiContainer container, SingletonProviderMap owner, Type instanceType)
 {
     _container = container;
     _owner = owner;
     _instanceType = instanceType;
 }
Exemple #11
0
 // Install basic functionality for most unity apps
 public static void InstallUnityStandard(DiContainer container)
 {
     container.Bind<IKernel>().AsSingleGameObject<UnityKernel>("Kernel");
     container.Bind<EntryPointInitializer>().AsSingle();
     container.Bind<IEntryPoint>().AsSingle<KernelInitializer>();
     container.Bind<ITickable>().AsLookup<UnityEventManager>();
 }
 public static void InjectChildGameObjects(
     DiContainer container, GameObject gameObject, IEnumerable<object> extraArgs)
 {
     foreach (var monoBehaviour in gameObject.GetComponentsInChildren<MonoBehaviour>())
     {
         InjectMonoBehaviour(container, monoBehaviour, extraArgs);
     }
 }
        public static void BindPriority(
            DiContainer container, Type tickableType, int priorityCount)
        {
            Assert.That(tickableType.DerivesFrom<ITickable>(),
                "Expected type '{0}' to derive from ITickable", tickableType.Name());

            container.Bind<Tuple<Type, int>>().To(
                Tuple.New(tickableType, priorityCount)).WhenInjectedInto<StandardKernel>();
        }
        public static void BindPriority(
            DiContainer container, Type initializableType, int priorityCount)
        {
            Assert.That(initializableType.DerivesFrom<IInitializable>(),
                "Expected type '{0}' to derive from IInitializable", initializableType.Name());

            container.Bind<Tuple<Type, int>>().To(
                Tuple.New(initializableType, priorityCount)).WhenInjectedInto<InitializableHandler>();
        }
Exemple #15
0
 public ShipStateFactory(DiContainer container)
 {
     _factories = new IFactory<ShipState>[(int) EShipState.Count]
     {
         new Factory<ShipState, ShipStateMoving>(container),
         new Factory<ShipState, ShipStateDead>(container),
         new Factory<ShipState, ShipStateWaitingToStart>(container),
     };
 }
Exemple #16
0
        public void RegisterBindings(DiContainer container)
        {
            container.Bind<ShipStateMoving.Settings>().AsSingle(settings.shipMoving);
            container.Bind<ShipStateDead.Settings>().AsSingle(settings.shipDead);
            container.Bind<ShipStateWaitingToStart.Settings>().AsSingle(settings.shipStarting);

            container.Bind<AsteroidSpawner.Settings>().AsSingle(settings.asteroidSpawner);
            container.Bind<Asteroid.Settings>().AsSingle(settings.asteroid);
        }
Exemple #17
0
        void InitContainer()
        {
            _container = new DiContainer();
            // Note: This has to go first
            _container.Bind<CompositionRoot>().AsSingle(this);

            // Init default dependencies
            _container.Bind<MonoBehaviourFactory>().AsSingle();

            _container.Bind<UnityEventManager>().AsSingleGameObject();
        }
 public static void InjectMonoBehaviour(
     DiContainer container, MonoBehaviour monoBehaviour, IEnumerable<object> extraArgs)
 {
     // null if monobehaviour link is broken
     if (monoBehaviour != null && monoBehaviour.enabled)
     {
         using (container.PushLookup(monoBehaviour.GetType()))
         {
             FieldsInjecter.Inject(container, monoBehaviour, extraArgs);
         }
     }
 }
        public LookupInProgressAdder(DiContainer container, Type concreteType)
        {
            if (DiContainer.LookupsInProgress.Contains(concreteType))
            {
                Assert.That(false, () => "Circular dependency detected! \nObject graph:\n" + DiContainer.GetCurrentObjectGraph());
            }

            DiContainer.LookupsInProgress.Push(concreteType);

            _container = container;
            _concreteType = concreteType;
        }
Exemple #20
0
        void InitContainer()
        {
            _container = new DiContainer();

            // Note: This has to go first
            _container.Bind<CompositionRoot>().To(this);

            if (_extraBindingLookup != null)
            {
                _extraBindingLookup(_container);
                _extraBindingLookup = null;
            }
        }
        static void InjectFromResolve(
            InjectableInfo injectInfo, DiContainer container, object targetInstance)
        {
            var valueObj = container.Resolve(injectInfo, targetInstance);

            if (valueObj == null && !container.AllowNullBindings)
            {
                // Do not change if optional
                // Since it may have some hard coded value
                Assert.That(injectInfo.Optional); // Should have thrown resolve exception otherwise
            }
            else
            {
                Assert.IsNotNull(injectInfo.Setter);
                injectInfo.Setter(targetInstance, valueObj);
            }
        }
        static Dictionary<Type, List<Type>> CalculateObjectGraph(
            DiContainer container, IEnumerable<Type> contracts)
        {
            var map = new Dictionary<Type, List<Type>>();

            foreach (var contractType in contracts)
            {
                var depends = GetDependencies(container, contractType);

                if (depends.Any())
                {
                    map.Add(contractType, depends);
                }
            }

            return map;
        }
        public static void OutputObjectGraphToFile(
            DiContainer container, string outputPath,
            IEnumerable<Type> externalIgnoreTypes, IEnumerable<Type> contractTypes)
        {
            #if !UNITY_WEBPLAYER

            // Output the entire object graph to file
            var graph = CalculateObjectGraph(container, contractTypes);

            var ignoreTypes = new List<Type>()
            {
                typeof(DiContainer),
                typeof(InitializableHandler),
                typeof(StandardKernel),
            };

            ignoreTypes.AddRange(externalIgnoreTypes);

            var resultStr = "digraph { \n";

            resultStr += "rankdir=LR;\n";

            foreach (var entry in graph)
            {
                if (ShouldIgnoreType(entry.Key, ignoreTypes))
                {
                    continue;
                }

                foreach (var dependencyType in entry.Value)
                {
                    if (ShouldIgnoreType(dependencyType, ignoreTypes))
                    {
                        continue;
                    }

                    resultStr += GetFormattedTypeName(entry.Key) + " -> " + GetFormattedTypeName(dependencyType) + "; \n";
                }
            }

            resultStr += " }";

            System.IO.File.WriteAllText(outputPath, resultStr);
            #endif
        }
Exemple #24
0
        // This method can be used to load the given scene and perform injection on its contents
        // Note that the scene we're loading can have [Inject] flags however it should not have
        // its own composition root
        public static IEnumerator LoadSceneAdditiveWithContainer(
            string levelName, DiContainer parentContainer)
        {
            var rootObjectsBeforeLoad = GameObject.FindObjectsOfType<Transform>().Where(x => x.parent == null).ToList();

            Application.LoadLevelAdditive(levelName);

            // Wait one frame for objects to be added to the scene heirarchy
            yield return null;

            var rootObjectsAfterLoad = GameObject.FindObjectsOfType<Transform>().Where(x => x.parent == null).ToList();

            foreach (var newObject in rootObjectsAfterLoad.Except(rootObjectsBeforeLoad).Select(x => x.gameObject))
            {
                Assert.That(newObject.GetComponent<CompositionRoot>() == null,
                    "LoadSceneAdditiveWithContainer does not expect a container to exist in the loaded scene");

                InjectionHelper.InjectChildGameObjects(parentContainer, newObject);
            }
        }
Exemple #25
0
        public void RegisterBindings(DiContainer container)
        {
            InstallerUtil.InstallUnityStandard(container);

            container.Bind<IDependencyRoot>().AsSingle<GameRoot>();

            container.Bind<Camera>().AsSingle(mainCamera);
            container.Bind<LevelHelper>().AsSingle();

            container.Bind<ITickable>().AsSingle<AsteroidSpawner>();
            container.Bind<AsteroidSpawner>().AsSingle();

            container.Bind<GuiHandler>().AsSingle(gui);

            container.Bind<IFactory<Asteroid>>().AsSingle<GameObjectFactory<Asteroid>>();
            container.Bind<GameObject>().AsSingle(asteroidTemplate).WhenInjectedInto<GameObjectFactory<Asteroid>>();

            container.Bind<IEntryPoint>().AsSingle<GameController>();
            container.Bind<ITickable>().AsSingle<GameController>();
            container.Bind<GameController>().AsSingle();

            container.Bind<Ship>().AsSingle(ship);
            container.Bind<ShipStateFactory>().AsSingle();
        }
Exemple #26
0
        static IEnumerable<ZenjectResolveException> ValidateInstallers(CompositionRoot compRoot)
        {
            var container = new DiContainer();
            container.Bind<CompositionRoot>().ToSingle(compRoot);

            var allInstallers = new List<IInstaller>();

            foreach (var installer in compRoot.Installers)
            {
                if (installer == null)
                {
                    yield return new ZenjectResolveException(
                        "Found null installer in properties of Composition Root");
                    yield break;
                }

                if (installer.enabled)
                {
                    installer.Container = container;
                    container.Bind<IInstaller>().To(installer);
                }

                allInstallers.AddRange(container.InstallInstallers());

                Assert.That(!container.HasBinding<IInstaller>());
            }

            foreach (var error in container.ValidateResolve<IDependencyRoot>())
            {
                yield return error;
            }

            // Also make sure we can fill in all the dependencies in the built-in scene
            foreach (var monoBehaviour in compRoot.GetComponentsInChildren<MonoBehaviour>())
            {
                if (monoBehaviour == null)
                {
                    // Be nice to give more information here
                    Log.Warn("Found null MonoBehaviour in scene");
                    continue;
                }

                foreach (var error in container.ValidateObjectGraph(monoBehaviour.GetType()))
                {
                    yield return error;
                }
            }

            // Validate dynamically created object graphs
            foreach (var installer in allInstallers)
            {
                foreach (var error in installer.ValidateSubGraphs())
                {
                    yield return error;
                }
            }
        }
Exemple #27
0
 internal SaberFactory(DiContainer container)
 {
     _container = container;
 }
 public static void Inject(DiContainer container, object injectable, IEnumerable<object> additional, bool shouldUseAll)
 {
     Inject(container, injectable, additional, shouldUseAll, TypeAnalyzer.GetInfo(injectable.GetType()));
 }
 public static void Inject(DiContainer container, object injectable)
 {
     Inject(container, injectable, Enumerable.Empty<object>());
 }
 public static void Bind(DiContainer container, IEnumerable <string> systemNamespaces)
 {
     new BindSystemsInNamespace(container, systemNamespaces).Bind();
 }
Exemple #31
0
 static void InstallFoo2(DiContainer container)
 {
     container.Bind <Foo>().AsSingle();
     container.BindSignal <DoSomethingSignal>().To <Bar>(x => x.Execute).AsSingle();
 }
Exemple #32
0
 public ArenasFactory(PrefabArenaData prefabArenaData, DiContainer diContainer)
 {
     _prefabArenasData = prefabArenaData;
     _diContainer      = diContainer;
 }
Exemple #33
0
        public override void PostBindings(DiContainer container)
        {
            var eventBus = container.Resolve <EventBus>();

            var poolStorageController =
                container.Resolve <PoolStorageController>();

            eventBus.On((int)
                        Events.GameLevelLoad, poolStorageController.OnLevelLoad);

            var btnController =
                container.Resolve <BtnController>();

            eventBus.On((int)
                        Events.BtnClick, btnController.OnClick);

            var showableController =
                container.Resolve <ShowableController>();

            eventBus.On((int)
                        Events.ShowableShow, showableController.OnShow);
            eventBus.On((int)
                        Events.ShowablePreShow, showableController.OnPreShow);

            var activityIndicatorController =
                container.Resolve <ActivityIndicatorController>();

            eventBus.On((int)Events.ServerRequest,
                        activityIndicatorController.OnServerRequest);
            eventBus.On((int)Events.ServerResponse,
                        activityIndicatorController.OnServerResponse);

            var errorController =
                container.Resolve <ErrorController>();

            eventBus.On((int)
                        Events.ServerResponse, errorController.OnServerResponse);

            var gameController = container.Resolve <GameController>();

            eventBus.On((int)Events.LevelGeneratorLevelGenerate,
                        gameController.OnLevelGenerate);
            var levelStartScreen = container.Resolve <LevelStartScreenView>()
                                   .GetComponent <ShowableView>();

            levelStartScreen.OnHide += gameController.OnLevelStartScreenHide;
            var gameOverScreen         = container.Resolve <GameOverScreenView>();
            var gameOverScreenShowable =
                gameOverScreen.GetComponent <ShowableView>();

            gameOverScreenShowable.OnShow +=
                gameController.OnGameOverScreenShow;
            gameOverScreenShowable.OnHide +=
                gameController.OnGameOverScreenHide;
            var tutorialScreen = container.Resolve <TutorialScreenView>()
                                 .GetComponent <ShowableView>();

            tutorialScreen.OnPreShow += gameController.OnTutorialPreShow;
            tutorialScreen.OnHide    += gameController.OnTutorialHide;

            var everyplayController = container.Resolve <EveryplayController>();

            eventBus.On((int)
                        Events.GameLevelUnload, everyplayController.OnLevelUnload);
            eventBus.On((int)
                        Events.GamePreLevelLoad, everyplayController.OnPreLevelLoad);
            eventBus.On((int)Events.PlayerResurrect,
                        everyplayController.OnPlayerResurrect);
            eventBus.On((int)Events.PlayerManagerPreLevelComplete,
                        everyplayController.OnPreLevelComplete);
            gameOverScreenShowable.OnShow +=
                everyplayController.OnGameOverScreenShow;
            levelStartScreen.OnShow +=
                everyplayController.OnLevelStartScreenShow;
            var levelCompleteScreen =
                container.Resolve <LevelCompleteScreenView>();

            levelCompleteScreen.GetComponent <ShowableView>().OnShow +=
                everyplayController.OnLevelCompleteScreenShow;

            var analyticsController = container.Resolve <AnalyticsController>();

            eventBus.On((int)Events.PlayerManagerPreLevelComplete,
                        analyticsController.OnPreLevelComplete);
            eventBus.On((int)Events.PlayerDeath,
                        analyticsController.OnPlayerDeath);
            eventBus.On((int)Events.PlayerResurrect,
                        analyticsController.OnPlayerResurrect);
            eventBus.On((int)Events.PlayerConstruct,
                        analyticsController.OnPlayerConstruct);
            eventBus.On((int)Events.AppStart,
                        analyticsController.OnAppStart);
            eventBus.On((int)Events.SkillListItemLearnBtnClick,
                        analyticsController.OnSkillListItemLearnBtnClick);
            var mainScreen = container.Resolve <MainScreenView>();

            mainScreen.FeedbackBtn.onClick.AddListener(
                analyticsController.OnMainScreenFeedbackBtnClick);
            mainScreen.StartBtn.onClick.AddListener(
                analyticsController.OnMainScreenStartBtnClick);
            mainScreen.LeaderboardBtn.onClick.AddListener(
                analyticsController.OnMainScreenLeaderboardBtnClick);
            mainScreen.AchievementsBtn.onClick.AddListener(
                analyticsController.OnMainScreenAchievementsBtnClick);
            mainScreen.ReplaysBtn.onClick.AddListener(
                analyticsController.OnMainScreenReplaysBtnClick);
            mainScreen.ExitBtn.onClick.AddListener(
                analyticsController.OnMainScreenExitBtnClick);
            mainScreen.SkillsBtn.onClick.AddListener(
                analyticsController.OnMainScreenSkillsBtnClick);
            gameOverScreen.ExitBtn.onClick.AddListener(
                analyticsController.OnGameOverScreenExitBtnClick);
            gameOverScreen.RestartBtn.onClick.AddListener(
                analyticsController.OnGameOverScreenRestartBtnClick);
            levelCompleteScreen.ShareBtn.onClick.AddListener(
                analyticsController.OnLevelCompleteScreenShareBtnClick);
            var ad = container.Resolve <Ad>();

            ad.OnView += analyticsController.OnAdView;
            var authManager = container.Resolve <AuthManager>();

            authManager.OnLoginSuccess += analyticsController.OnLogin;

            var uiBlockerController = container.Resolve <UIBlockerController>();

            eventBus.On((int)Events.ServerRequest,
                        uiBlockerController.OnServerRequest);
            eventBus.On((int)Events.ServerResponse,
                        uiBlockerController.OnServerResponse);
        }
Exemple #34
0
 public SimpleBulletFactory(DiContainer container, [Inject(Id = WeaponInstaller.ID_BulletsContainer)] Transform parent)
 {
     _parent    = parent;
     _container = container;
 }
Exemple #35
0
        public override void InitBindings(DiContainer container)
        {
            Server finalServer = server;

            if (UnityEngine.Debug.isDebugBuild && isServerStubbed)
            {
                finalServer = serverStub;
            }

            container.Bind <Server>().ToSingleMethod((InjectContext context) => {
                context.Container.Inject(finalServer);
                return(finalServer);
            });
            container.Bind <AuthManager>().ToSingle();
            container.Bind <EventBus>().ToSingle();
            container.Bind <Translator>().ToSingle();
            container.Bind <Game>().ToSingle();
            container.Bind <PoolStorageController>().ToSingle();
            container.Bind <ActivityIndicatorController>().ToSingle();
            container.Bind <Ad>().ToSingle();
            container.Bind <BtnController>().ToSingle();
            container.Bind <ShowableController>().ToSingle();
            container.Bind <ErrorController>().ToSingle();
            container.Bind <GameController>().ToSingle();
            container.Bind <EveryplayController>().ToSingle();
            container.Bind <AnalyticsController>().ToSingle();
            container.Bind <UIBlockerController>().ToSingle();
            container.Bind <PoolStorageView>().ToInstance(poolStorage);
            container.Bind <UIView>().ToInstance(ui);
            container.Bind <CoroutineManagerView>().ToInstance(coroutineManager);
            container.Bind <ScreenSpacePopupManagerView>()
            .ToInstance(screenSpacePopupManager);
            container.Bind <ActivityIndicatorView>()
            .ToInstance(activityIndicator);
            container.Bind <Camera>("MainCamera").ToInstance(mainCamera);
            container.Bind <AudioManager>()
            .ToSingleMethod((InjectContext context) => {
                context.Container.Inject(audioManager);
                return(audioManager);
            });
            container.Bind <UIBlockerView>().ToInstance(uiBlocker);
            container.Bind <WorldSpacePopupManagerView>()
            .ToInstance(worldSpacePopupManager);
            container.Bind <Stopwatch>("PlayStopwatch")
            .ToInstance(new Stopwatch());
            container.Bind <TutorialScreenView>().ToInstance(tutorialScreen);
            container.Bind <string>("EmptyScene").ToInstance(emptyScene);
            container.Bind <string>("FeedbackEmail").ToInstance(feedbackEmail);
            container.Bind <string>("ErrorMsg").ToInstance(errorMsg);
            container.Bind <int>("ErrorPopupType").ToInstance(errorPopupType);
            container.Bind <int>("CommonPopupType").ToInstance(commonPopupType);
            container.Bind <byte[]>("SecretKey")
            .ToInstance(Encoding.UTF8.GetBytes(secretKey));
            container.Bind <int>("EffectsHighPrioAudioChannel")
            .ToInstance(effectsHighPrioAudioChannel);
            container.Bind <int>("EffectsLowPrioAudioChannel")
            .ToInstance(effectsLowPrioAudioChannel);
            container.Bind <int>("UIHighPrioAudioChannel")
            .ToInstance(uiHighPrioAudioChannel);
            container.Bind <int>("UILowPrioAudioChannel")
            .ToInstance(uiLowPrioAudioChannel);
            container.Bind <int>("PlayerHighPrioAudioChannel")
            .ToInstance(playerHighPrioAudioChannel);
            container.Bind <int>("PlayerMidPrioAudioChannel")
            .ToInstance(playerMidPrioAudioChannel);
            container.Bind <int>("PlayerLowPrioAudioChannel")
            .ToInstance(playerLowPrioAudioChannel);
        }
Exemple #36
0
        public void Install()
        {
            Assert.That(!_hasInstalled);
            _hasInstalled = true;

            Assert.IsNull(_container);

            var parents = GetParentContainers();

            Assert.That(!parents.IsEmpty());
            Assert.That(parents.All(x => x.IsValidating == parents.First().IsValidating));

            _container = new DiContainer(parents, parents.First().IsValidating);

            // Do this after creating DiContainer in case it's needed by the pre install logic
            if (PreInstall != null)
            {
                PreInstall();
            }

            if (OnPreInstall != null)
            {
                OnPreInstall.Invoke();
            }

            Assert.That(_decoratorContexts.IsEmpty());
            _decoratorContexts.AddRange(LookupDecoratorContexts());

            if (_parentNewObjectsUnderSceneContext)
            {
                _container.DefaultParent = transform;
            }
            else
            {
                _container.DefaultParent = null;
            }

            // Record all the injectable components in the scene BEFORE installing the installers
            // This is nice for cases where the user calls InstantiatePrefab<>, etc. in their installer
            // so that it doesn't inject on the game object twice
            // InitialComponentsInjecter will also guarantee that any component that is injected into
            // another component has itself been injected
            var injectableMonoBehaviours = new List <MonoBehaviour>();

            GetInjectableMonoBehaviours(injectableMonoBehaviours);
            foreach (var instance in injectableMonoBehaviours)
            {
                _container.QueueForInject(instance);
            }

            foreach (var decoratorContext in _decoratorContexts)
            {
                decoratorContext.Initialize(_container);
            }

            _container.IsInstalling = true;

            try
            {
                InstallBindings(injectableMonoBehaviours);
            }
            finally
            {
                _container.IsInstalling = false;
            }

            if (PostInstall != null)
            {
                PostInstall();
            }

            if (OnPostInstall != null)
            {
                OnPostInstall.Invoke();
            }
        }
Exemple #37
0
 public void Setup()
 {
     _container = new DiContainer();
 }
 public GameLoader(ZenjectSceneLoader sceneLoader, DiContainer container)
 {
     this.sceneLoader = sceneLoader;
     this.container   = container;
 }
 public WeaponFactory(DiContainer diContainer)
 {
     this.diContainer = diContainer;
 }
Exemple #40
0
 static void InstallFoo(DiContainer container)
 {
     container.Bind <Foo>().AsSingle();
     container.DeclareSignal <DoSomethingSignal>();
 }
Exemple #41
0
        private static FactoryToChoiceIdBinder <GameObject, Type, T> BindUiFactory <T, TFactory>(DiContainer container)
        {
            var bindStatement = container.StartBinding();
            var bindInfo      = bindStatement.SpawnBindInfo();

            bindInfo.ContractTypes.Add(typeof(TFactory));
            var factoryBindInfo = new FactoryBindInfo(typeof(TFactory));

            bindStatement.SetFinalizer(new PlaceholderFactoryBindingFinalizer <T>(bindInfo, factoryBindInfo));
            return(new FactoryToChoiceIdBinder <GameObject, Type, T>(container, bindInfo, factoryBindInfo));
        }
 /// <summary>
 /// Get the adapter for the specified <see cref="DiContainer"/>.
 /// </summary>
 public static IContainer GetAdapter(DiContainer container)
 => container
 switch
 {
 public AlertFactory(DiContainer diContainer)
 {
     _diContainer = diContainer;
 }
Exemple #44
0
 public CustomFooFactory(DiContainer container)
 {
     _container = container;
 }
Exemple #45
0
 public FactoryToChoiceBinder(
     DiContainer bindContainer, BindInfo bindInfo, FactoryBindInfo factoryBindInfo)
     : base(bindContainer, bindInfo, factoryBindInfo)
 {
 }
 public BindSystemsInNamespace(DiContainer container, IEnumerable <string> systemNamespaces)
 {
     Container        = container;
     SystemNamespaces = systemNamespaces;
 }
Exemple #47
0
 public virtual void Destroy()
 {
     _container = null;
 }
Exemple #48
0
 void InstallQux(DiContainer subContainer)
 {
     subContainer.Bind <Qux>().AsSingle();
 }
Exemple #49
0
        private static SaberProvider GetProvider(DiContainer container)
        {
            var provider = container.TryResolve <SaberProvider>();

            return(provider);
        }
 public CommandBinder(
     DiContainer container, string identifier, SingletonProviderCreator singletonProviderFactory)
     : base(container, identifier, singletonProviderFactory)
 {
 }
 public void TestInitialize()
 {
     container = new DiContainer();
 }
 public CommandBinderBase(
     DiContainer container, string identifier, SingletonProviderCreator singletonProviderFactory)
     : base(container, typeof(TCommand), identifier)
 {
     _singletonProviderFactory = singletonProviderFactory;
 }
 public static void Inject(DiContainer container, object injectable, IEnumerable<object> additional)
 {
     Inject(container, injectable, additional, false);
 }
Exemple #54
0
 public VisualFactoryRef(DiContainer container) : base(container)
 {
 }
Exemple #55
0
        public void Setup()
        {
            _container = new DiContainer();

            _container.Bind <TaskUpdater <ITickable> >().FromInstance(new TickablesTaskUpdater());
        }
Exemple #56
0
 public GameObjectFactory(DiContainer container,
                          ISceneHelper sceneHelper)
 {
     this.container   = container;
     this.sceneHelper = sceneHelper;
 }
 public override void Install(DiContainer container)
 {
     container
     .BindInterfacesTo <MmfBasedMessageIo>()
     .AsCached();
 }
Exemple #58
0
 public TowerFactory(DiContainer container, TowerTypeMap typeMap)
 {
     _container = container;
     _typeMap   = typeMap;
 }
Exemple #59
0
 public ConcreteIdBinderNonGeneric(
     DiContainer bindContainer, BindInfo bindInfo,
     BindStatement bindStatement)
     : base(bindContainer, bindInfo, bindStatement)
 {
 }
 public ContainerBindingTests()
 {
     _container = new DiContainer();
 }