/// <summary>
/// Callback invoked internally by an instance when it has completed initialization.
/// </summary>
/// <param name="instance">Instance that completed.</param>
private void InstanceInitialized(IInitializable instance)
{
#if METRICS_ENABLED && INCLUDE_DEV_METRICS
Metrics.End("Initialize:" + instance.GetType().Name);
#endif
try {
if (_progressCallback != null)
{
_progressCallback(_instances[_instanceIdx], _instanceCount, _instanceIdx);
}
++_instanceIdx;
if (Debug.isDebugBuild)
{
LogProgress();
}
if (_remainingCount <= 0)
{
Success();
}
else if (_chained)
{
Initialize(_instances[_instanceIdx]);
}
// Swallow exception to prevent firing _failedCallback as a result of exception in InstanceInitialized/_successCallback
} catch (Exception e) {
this.LogError("Exception in InstanceInitialized() at index " + _instanceIdx + ": " + e.ToString());
}
}
internal static void RegisterComponent(Component cmp)
{
LifecycleEvent(cmp, "Consider for awake");
if (cmp is IInitializable)
{
IInitializable init = cmp as IInitializable;
if (!cmp.isPrefab || (cmp.isPrefab && init.ShouldPrefabsBeInitialized()))
{
init.Initialize(assetHelper);
}
}
if (cmp.gameObject != null && !cmp.isPrefab)
{
LifecycleEvent(cmp, "Add to objects");
objects.Add(cmp.GetInstanceID(), cmp);
if (!cmp.isPrefab)
{
LifecycleEvent(cmp, "Add to start");
componentsToStart.Enqueue(cmp);
}
if (!objects.ContainsKey(cmp.gameObject.GetInstanceID()))
{
objects.Add(cmp.gameObject.GetInstanceID(), cmp.gameObject);
}
if (!cmp.isPrefab && typeCaps.HasCaps(cmp.GetType(), TypeSet.TypeCapabilities.Awake))
{
componentsToAwake.Enqueue(cmp);
}
}
}
private IEnumerator WaitForGroupToFinishInitializing()
{
bool fullyInitialized;
do
{
fullyInitialized = true;
var enumerator = this._initializableObjects.GetEnumerator();
while (enumerator.MoveNext())
{
IInitializable initializable = enumerator.Current.GetComponent <IInitializable>();
if (!initializable.IsFullyInitialized)
{
fullyInitialized = false;
break;
}
}
if (!fullyInitialized)
{
yield return(null);
}
} while (!fullyInitialized);
this.IsFullyInitialized = true;
}
private IEnumerator InitializeGroup()
{
if (this._initializableObjects == null)
{
yield break;
}
var enumerator = this._initializableObjects.GetEnumerator();
while (enumerator.MoveNext())
{
if (enumerator.Current == null)
{
TimiDebug.LogErrorColor("Initializable object list in group " + this._groupName + " has a null object", LogColor.red);
continue;
}
IInitializable initializable = enumerator.Current.GetComponent <IInitializable>();
if (initializable == null)
{
TimiDebug.LogErrorColor(enumerator.Current.name + " has no " + typeof(IInitializable).Name, LogColor.red);
continue;
}
TimiDebug.LogColor("Initializing " + enumerator.Current.name, LogColor.green);
initializable.StartInitialize();
if (this._serialLoad)
{
while (!initializable.IsFullyInitialized)
{
yield return(null);
}
}
}
}
private IEnumerator WaitForGroupToFinishInitializing()
{
float startTimeInSeconds = Time.fixedTime;
bool fullyInitialized;
do
{
fullyInitialized = true;
var enumerator = this._initializables.GetEnumerator();
while (enumerator.MoveNext())
{
IInitializable initializable = enumerator.Current;
if (!initializable.IsFullyInitialized)
{
fullyInitialized = false;
break;
}
}
if (!fullyInitialized)
{
if ((Time.fixedTime - startTimeInSeconds) > this._timeoutSeconds)
{
DebugLog.LogErrorColor("Initialization timed out waiting for: " + this.GetName, LogColor.red);
break;
}
yield return(null);
}
} while (!fullyInitialized);
this.IsFullyInitialized = true;
}
public static void Init(IInitializable initializable)
{
if (initializable != null)
{
initializable.Init();
}
}
public void Loaded(
IInitializable <TState> loadedCurrentState,
IReadOnlyDictionary <TState, TState> loadedHistoryStates,
IReadOnlyCollection <EventInformation <TEvent> > events)
{
this.apiExtension.Loaded(this.stateMachineInformation, loadedCurrentState, loadedHistoryStates, events);
}
public bool OnMouseLeftMove(Point mouse, Keys modifiers, Point imageLocation, float imageZoom)
{
if (metadata == null || screenToolManager == null)
{
return(false);
}
bool handled = false;
ImageToViewportTransformer transformer = new ImageToViewportTransformer(imageLocation, imageZoom);
PointF imagePoint = transformer.Untransform(mouse);
if (screenToolManager.IsUsingHandTool)
{
// TODO: handle magnifier.
handled = screenToolManager.HandTool.OnMouseMove(metadata, imagePoint, Point.Empty, modifiers);
}
else
{
// Setting second point of a drawing.
IInitializable drawing = metadata.HitDrawing as IInitializable;
if (drawing != null)
{
drawing.InitializeMove(imagePoint, modifiers);
}
}
return(handled);
}
public virtual void Loaded(
IStateMachineInformation <TState, TEvent> stateMachineInformation,
IInitializable <TState> loadedCurrentState,
IReadOnlyDictionary <TState, TState> loadedHistoryStates,
IReadOnlyCollection <EventInformation <TEvent> > events)
{
}
public void FinishInitialization(GameObject go)
{
var controller = go.GetComponent <IInitializable>();
controller.InitializationFinished -= FinishInitialization;
var currentIndex = Array.IndexOf(ObjectsToInit, go);
currentIndex++;
if (currentIndex < ObjectsToInit.Length)
{
var newGO = ObjectsToInit[currentIndex];
newGO.SetActive(true);
var newController = newGO.GetComponent <IInitializable>();
newController.InitializationFinished += FinishInitialization;
_controllerToStart = newController;
_framesToSkip = 0;
}
else
{
SpatialMappingControl.Instance.DrawVisualMeshes = false;
SpatialMappingControl.Instance.SetDefaultUpdateTime();
GetComponent <MainController>().Ready();
Destroy(this);
}
}
public static void Init(IInitializable initializable)
{
if (initializable != null)
{
initializable.Init();
}
}
public override void Loaded(
IStateMachineInformation <State, Event> stateMachineInformation,
IInitializable <State> loadedCurrentState,
IReadOnlyDictionary <State, State> loadedHistoryStates)
{
this.LoadedCurrentState.Add(loadedCurrentState);
}
private void InitializeTask(Task task)
{
RuntimeTask rt = null;
if (task is Wait)
{
rt = Initialize_Wait(task);
}
else
{
rt = new RuntimeTask(task, task.targetMethod);
MonoBehaviour comp = GetEqualTypeComponent(task.targetScript.GetType()) as MonoBehaviour;
if (comp == null)
{
comp = gameObject.AddComponent(task.targetScript.GetType()) as MonoBehaviour;
IInitializable initializable = comp as IInitializable;
initializable.Initialize();
}
if (task.isCoroutine)
{
rt.comp = comp;
}
else
{
Func <IDisposable> tempFunc = Delegate.CreateDelegate(typeof(Func <IDisposable>), comp, task.targetMethod) as Func <IDisposable>;
rt.taskFunc = tempFunc;
}
}
_runtimeTasks.Add(task, rt);
}
public void InitializeCommit(VideoFrame videoFrame, PointF point)
{
magnifier.InitializeCommit(point);
IInitializable initializable = hitDrawing as IInitializable;
if (initializable == null || !initializable.Initializing)
{
return;
}
string key = initializable.InitializeCommit(point);
if (string.IsNullOrEmpty(key))
{
return;
}
ITrackable trackable = hitDrawing as ITrackable;
if (trackable != null)
{
trackabilityManager.AddPoint(trackable, videoFrame, key, point);
}
}
/// <summary>
/// Initialize the specified instance. All exceptions from the invocation of instance.Initialize() will be swallowed.
/// </summary>
/// <param name="instance">Instance to intialize.</param>
private bool Initialize(IInitializable instance)
{
string instanceName = instance.GetType().Name;
try {
this.LogTrace("Initializing " + instanceName, LogCategory.INITIALIZATION);
#if METRICS_ENABLED && INCLUDE_DEV_METRICS
Metrics.Start("Initialize:" + instanceName);
#endif
instance.Initialize(InstanceInitialized);
} catch (Exception e) {
#if METRICS_ENABLED && INCLUDE_DEV_METRICS
Metrics.End("Initialize:" + instanceName);
#endif
// An exception was thrown, so we will never complete. Invoke failedCallback.
this.LogError("Exception initializing " + (instance != null ? instance.ToString() : "null instance") + ": " + e.ToString());
Failure(e.ToString());
// Stop initialization of any future instances
return(false);
}
// Continue initialization
return(true);
}
public virtual Task Loaded(
IInitializable <TState> loadedCurrentState,
IReadOnlyDictionary <TState, TState> loadedHistoryStates,
IReadOnlyCollection <EventInformation <TEvent> > events,
IReadOnlyCollection <EventInformation <TEvent> > priorityEvents)
{
return(TaskEx.Completed);
}
public Task Loaded(
IInitializable <TState> loadedCurrentState,
IReadOnlyDictionary <TState, TState> loadedHistoryStates,
IReadOnlyCollection <EventInformation <TEvent> > events,
IReadOnlyCollection <EventInformation <TEvent> > priorityEvents)
{
return(this.apiExtension.Loaded(this.stateMachineInformation, loadedCurrentState, loadedHistoryStates, events, priorityEvents));
}
private void Start()
{
for (int i = 0; i < ScriptsToInitialiseReferences.Length; i++)
{
IInitializable init = (IInitializable)ScriptsToInitialiseReferences[i];
init.Init();
}
}
public void RegisterInitializable(IInitializable initializable)
{
if (_initializables.Contains(initializable))
{
return;
}
_initializables.Add(initializable);
}
public void AddInitializable(IInitializable initializable)
{
_initializables?.Push(initializable);
if (_hasBeenInitialized)
{
initializable.Init();
}
}
internal static void TryInitialize(this object obj, object application)
{
IInitializable initializable = obj as IInitializable;
if (initializable != null)
{
initializable.Initialize(application);
}
}
public override Task Loaded(
IStateMachineInformation <State, Event> stateMachineInformation,
IInitializable <State> loadedCurrentState,
IReadOnlyDictionary <State, State> loadedHistoryStates,
IReadOnlyCollection <EventInformation <Event> > events,
IReadOnlyCollection <EventInformation <Event> > priorityEvents)
{
this.LoadedCurrentState.Add(loadedCurrentState);
return(Task.CompletedTask);
}
/// <summary>
/// Activates a <see cref="IInitializable"/>
/// </summary>
/// <param name="obj"></param>
public static void Activate(IInitializable obj)
{
if (!obj.IsInitialized)
{
obj.Initialization();
obj.IsInitialized = true;
}
obj.Activate();
}
/// <summary>
/// Registers the specified instance for invocation during the initialization
/// process; should be called in individual classes' constructors.
/// </summary>
/// <param name="instance">The initializable instance to be invoked.</param>
/// <param name="suppressEvents">
/// A value indicating whether initialization events (i.e., initializing and
/// initialized) should be suppressed.
/// </param>
/// <param name="message">
/// An optional message to be sent to the initialization event receivers.
/// </param>
/// <param name="data">
/// An optional dictionary of data values to be sent to the initialization event
/// receivers.
/// </param>
public void Register(
IInitializable instance,
bool suppressEvents,
string message,
IDictionary <string, object> data)
{
this.initializableInstances.Add(
new InitializableInstanceWrapper(
instance, suppressEvents, message, data));
}
public void EnsureCreated()
{
bool isCreated = context.Database.EnsureCreated();
if (isCreated)
{
IInitializable initializable = context as IInitializable;
initializable?.Init(databaseInitializer);
}
}
/// <summary>
/// Registers the specified instance for invocation during the initialization
/// process; should be called in individual classes' constructors.
/// </summary>
/// <param name="instance">The initializable instance to be invoked.</param>
/// <param name="suppressEvents">
/// A value indicating whether initialization events (i.e., initializing and
/// initialized) should be suppressed.
/// </param>
/// <param name="message">
/// An optional message to be sent to the initialization event receivers.
/// </param>
/// <param name="data">
/// An optional dictionary of data values to be sent to the initialization event
/// receivers.
/// </param>
public void Register(
IInitializable instance,
bool suppressEvents,
string message,
IDictionary <string, object> data)
{
ArgumentValidator.EnsureArgumentNotNull(instance, nameof(instance));
this.ValidateParameters(suppressEvents, message, data);
this.invocableInitializer.Register(
instance, suppressEvents, message, data);
}
void Awake()
{
foreach (Object i in this.initializeTargets)
{
if (i is IInitializable)
{
IInitializable ini = i as IInitializable;
ini.ResetAsInitialization();
}
}
}
public void InitOwner()
{
foreach (RecordableProperty property in Properties)
{
if (property is IInitializable)
{
IInitializable initializable = property as IInitializable;
initializable.InitToObject(Owner);
}
}
}
private IInitializable GetIInitalizable(Type type)
{
IInitializable initializable = _container.Resolve(type) as IInitializable;
if (initializable == null)
{
_logger.Log(string.Format("Unable to cast type \"{0}\" as IInitializable.", type.Name), LogMessageSeverity.Error);
}
return(initializable);
}
public void AddInitializable(IInitializable initializable)
{
if (initializable != null)
{
this._initializables.Add(initializable);
}
else
{
DebugLog.LogWarningColor("Trying to add null initializable to " + this.GetName, LogColor.orange);
}
}
private void LateUpdate()
{
if (_controllerToStart != null && _framesToSkip > 10)
{
var control = _controllerToStart;
_controllerToStart = null;
control.StartInitialization();
}
_framesToSkip++;
}
public Initializer(IInitializable toInit)
{
Helper.GuardNotNull(toInit);
_toInit = toInit;
_toInit.BeginInit();
}
public void AddEntry(IInitializable entry)
{
m_initializables.Add(entry);
}
public void Initialize(IInitializable initializable)
{
initializable.Initialize(_database);
}
public ServiceInitializerWrapper(IInitializable service)
{
_service = service;
}
public void Initialize(IInitializable initializable)
{
throw new NotImplementedException();
}
public InitializableInfo(IInitializable initializable, int priority)
{
Initializable = initializable;
Priority = priority;
}
