iframe-proxy | Sunbelt Computer Software

299 lines (256 loc) · 8.75 KB
﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using uFrame.Attributes;
using uFrame.IOC;
using UniRx;
namespace uFrame.Kernel
    public class uFrameKernel : MonoBehaviour
        private static UFrameContainer _container;
        private static IEventAggregator _eventAggregator;
        private static bool _isKernelLoaded;
        private List<ISystemService> _services;
        private List<ISystemLoader> _systemLoaders;
        public static IEnumerator InstantiateSceneAsyncAdditively(string sceneName)
            var asyncOperation = Application.LoadLevelAdditiveAsync(sceneName);
            float lastProgress = -1;
            while (!asyncOperation.isDone)
                if (lastProgress != asyncOperation.progress)
                    EventAggregator.Publish(new SceneLoaderEvent()
                        State = SceneState.Instantiating,
                        Name = sceneName,
                        Progress = asyncOperation.progress
                    lastProgress = asyncOperation.progress;
                yield return new WaitForSeconds(0.1f);
        public static bool IsKernelLoaded
            get { return _isKernelLoaded; }
            set { _isKernelLoaded = value; }
        public static uFrameKernel Instance { get; set; }
        public static IUFrameContainer Container
                if (_container == null)
                    _container = new UFrameContainer();
                    _container.RegisterInstance<IUFrameContainer>(_container);
                    _container.RegisterInstance<IEventAggregator>(EventAggregator);
                return _container;
        public static IEventAggregator EventAggregator
            get { return _eventAggregator ?? (_eventAggregator = new EventAggregator()); }
            set { _eventAggregator = value; }
        public List<ISystemLoader> SystemLoaders
            get { return _systemLoaders ?? (_systemLoaders = new List<ISystemLoader>()); }
        public List<ISystemService> Services
            get { return _services ?? (_services = new List<ISystemService>()); }
        private void Awake()
            if (Instance != null)
                throw new Exception("Loading Kernel twice is not a good practice!");
            else
                Instance = this;
                //if (this.gameObject.GetComponent<MainThreadDispatcher>() == null)
                //    this.gameObject.AddComponent<MainThreadDispatcher>();
                DontDestroyOnLoad(gameObject);
                StartCoroutine(Startup());
        private IEnumerator Startup()
            var attachedSystemLoaders =
                gameObject.GetComponentsInChildren(typeof (ISystemLoader)).OfType<ISystemLoader>();
            foreach (var systemLoader in attachedSystemLoaders)
                this.Publish(new SystemLoaderEvent() {State = SystemState.Loading, Loader = systemLoader});
                systemLoader.Container = Container;
                systemLoader.EventAggregator = EventAggregator;
                systemLoader.Load();
                SystemLoaders.Add(systemLoader);
                this.Publish(new SystemLoaderEvent() {State = SystemState.Loaded, Loader = systemLoader});
            var attachedServices = gameObject.GetComponentsInChildren(typeof (SystemServiceMonoBehavior))
                .OfType<SystemServiceMonoBehavior>()
                .Where(_ => _.enabled)
                .ToArray();
            foreach (var service in attachedServices)
                Container.RegisterService(service);
                Services.Add(service);
            Container.InjectAll();
            var allServices = Container.ResolveAll<ISystemService>().ToArray();
            foreach (var service in allServices)
                this.Publish(new ServiceLoaderEvent() {State = ServiceState.Loading, Service = service});
                service.Setup();
                var setupAsync = service.SetupAsync();
                if(setupAsync!= null) yield return StartCoroutine(setupAsync);
                this.Publish(new ServiceLoaderEvent() {State = ServiceState.Loaded, Service = service});
            this.Publish(new SystemsLoadedEvent()
                Kernel = this
            _isKernelLoaded = true;
            this.Publish(new KernelLoadedEvent()
                Kernel = this
            yield return new WaitForEndOfFrame(); //Ensure that everything is bound
            yield return new WaitForEndOfFrame();
            this.Publish(new GameReadyEvent());
        public void OnDestroy()
            _container = null;
            IsKernelLoaded = false;
            Services.Clear();
            SystemLoaders.Clear();
            EventAggregator = null;
            Instance = null;
        public void ResetKernel()
            DestroyImmediate(Instance.gameObject);
            _container = null;
            IsKernelLoaded = false;
            Services.Clear();
            SystemLoaders.Clear();
            EventAggregator = null;
            Instance = null;
        public static void DestroyKernel(string levelToLoad = null)
            Instance.ResetKernel();
            if (levelToLoad != null)
                Application.LoadLevel(levelToLoad);
    public class SystemsLoadedEvent
        public uFrameKernel Kernel;
    /// <summary>
    /// </summary>
    [uFrameEvent("Kernel Loaded")]
    public class KernelLoadedEvent
        public uFrameKernel Kernel;
    /// <summary>
    /// </summary>
    [uFrameEvent("Game Ready")]
    public class GameReadyEvent
    /// <summary>
    /// </summary>
    public class LoadSceneCommand
        public string SceneName { get; set; }
        public ISceneSettings Settings { get; set; }
        public bool RestrictToSingleScene { get; set; }
    public class UnloadSceneCommand
        public string SceneName { get; set; }
    public class SystemLoaderEvent
        public SystemState State { get; set; }
        public ISystemLoader Loader { get; set; }
    public class ServiceLoaderEvent
        public ServiceState State { get; set; }
        public ISystemService Service { get; set; }
    public class SceneLoaderEvent
        public SceneState State { get; set; }
        public IScene SceneRoot { get; set; }
        public float Progress { get; set; }
        public string ProgressMessage { get; set; }
        public string Name { get; set; }
    public enum SceneState
        Loading,
        Update,
        Loaded,
        Unloading,
        Unloaded,
        Instantiating,
        Instantiated,
        Destructed
    public enum ServiceState
        Loading,
        Loaded,
        Unloaded,
    public enum SystemState
        Loading,
        Loaded,
        Unloaded,
    public static class uFrameKernelExtensions
        public static void RegisterService(this IUFrameContainer container, ISystemService service)
            container.RegisterInstance<ISystemService>(service, service.GetType().Name);
            //container.RegisterInstance(typeof(TService), service, false);
            container.RegisterInstance(service.GetType(), service);
        public static void RegisterService<TService>(this IUFrameContainer container, ISystemService service)
            container.RegisterInstance<ISystemService>(service, service.GetType().Name);
            container.RegisterInstance(typeof (TService), service);
        public static void RegisterSceneLoader(this IUFrameContainer container, ISceneLoader sceneLoader)
            container.RegisterInstance<ISceneLoader>(sceneLoader, sceneLoader.GetType().Name, false);
            //container.RegisterInstance(typeof(TService), service, false);
            container.RegisterInstance(sceneLoader.GetType(), sceneLoader, false);
        public static void Publish(this uFrameKernel mvvmKernel, object evt)
            uFrameKernel.EventAggregator.Publish(evt);
        public static IObservable<T> OnEvent<T>(this uFrameKernel mvvmKernel)
            return uFrameKernel.EventAggregator.GetEvent<T>();
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

uFrameKernel.cs

Latest commit

History

uFrameKernel.cs

File metadata and controls
