Merge branch 'mrtk_development' into vNEXT-TeleportationMove

StephenHodgson · StephenHodgson · commit 91ec449a8e95 · 2018-11-19T13:06:46.000-08:00
diff --git a/Assets/MixedRealityToolkit-SDK/Features/UX/Scripts/Tooltips/ToolTip.cs b/Assets/MixedRealityToolkit-SDK/Features/UX/Scripts/Tooltips/ToolTip.cs
@@ -199,11 +199,11 @@ public string ToolTipText
 
         [SerializeField]
         [Tooltip("The padding around the content (height / width)")]
-        private Vector2 backgroundPadding;
+        private Vector2 backgroundPadding = Vector2.zero;
 
         [SerializeField]
         [Tooltip("The offset of the background (x / y / z)")]
-        private Vector3 backgroundOffset;
+        private Vector3 backgroundOffset = Vector3.zero;
 
         /// <summary>
         /// The offset of the background (x / y / z)
diff --git a/Assets/MixedRealityToolkit/_Core/Services/MixedRealityToolkit.cs b/Assets/MixedRealityToolkit/_Core/Services/MixedRealityToolkit.cs
@@ -172,8 +172,7 @@ private void InitializeServiceLocator()
                 Utilities.Editor.InputMappingAxisUtility.CheckUnityInputManagerMappings(Definitions.Devices.ControllerMappingLibrary.UnityInputManagerAxes);
 #endif
 
-                if (!RegisterService(typeof(IMixedRealityInputSystem), Activator.CreateInstance(ActiveProfile.InputSystemType) as IMixedRealityInputSystem) ||
-                    InputSystem == null)
+                if (!RegisterService<IMixedRealityInputSystem>(ActiveProfile.InputSystemType) || InputSystem == null)
                 {
                     Debug.LogError("Failed to start the Input System!");
                 }
@@ -182,8 +181,7 @@ private void InitializeServiceLocator()
             // If the Boundary system has been selected for initialization in the Active profile, enable it in the project
             if (ActiveProfile.IsBoundarySystemEnabled)
             {
-                if (!RegisterService(typeof(IMixedRealityBoundarySystem), Activator.CreateInstance(ActiveProfile.BoundarySystemSystemType) as IMixedRealityBoundarySystem) ||
-                    BoundarySystem == null)
+                if (!RegisterService<IMixedRealityBoundarySystem>(ActiveProfile.BoundarySystemSystemType) || BoundarySystem == null)
                 {
                     Debug.LogError("Failed to start the Boundary System!");
                 }
@@ -192,8 +190,7 @@ private void InitializeServiceLocator()
             // If the Spatial Awareness system has been selected for initialization in the Active profile, enable it in the project
             if (ActiveProfile.IsSpatialAwarenessSystemEnabled)
             {
-                if (!RegisterService(typeof(IMixedRealitySpatialAwarenessSystem), Activator.CreateInstance(ActiveProfile.SpatialAwarenessSystemSystemType) as IMixedRealitySpatialAwarenessSystem) ||
-                    SpatialAwarenessSystem == null)
+                if (!RegisterService<IMixedRealitySpatialAwarenessSystem>(ActiveProfile.SpatialAwarenessSystemSystemType) || SpatialAwarenessSystem == null)
                 {
                     Debug.LogError("Failed to start the Spatial Awareness System!");
                 }
@@ -202,17 +199,15 @@ private void InitializeServiceLocator()
             // If the Teleport system has been selected for initialization in the Active profile, enable it in the project
             if (ActiveProfile.IsTeleportSystemEnabled)
             {
-                if (!RegisterService(typeof(IMixedRealityTeleportSystem), Activator.CreateInstance(ActiveProfile.TeleportSystemSystemType) as IMixedRealityTeleportSystem) ||
-                    TeleportSystem == null)
+                if (!RegisterService<IMixedRealityTeleportSystem>(ActiveProfile.TeleportSystemSystemType) || TeleportSystem == null)
                 {
                     Debug.LogError("Failed to start the Teleport System!");
                 }
             }
 
             if (ActiveProfile.IsDiagnosticsSystemEnabled)
             {
-                if (!RegisterService(typeof(IMixedRealityDiagnosticsSystem), Activator.CreateInstance(ActiveProfile.DiagnosticsSystemSystemType) as IMixedRealityDiagnosticsSystem) ||
-                    DiagnosticsSystem == null)
+                if (!RegisterService<IMixedRealityDiagnosticsSystem>(ActiveProfile.DiagnosticsSystemSystemType) || DiagnosticsSystem == null)
                 {
                     Debug.LogError("Failed to start the Diagnostics System!");
                 }
@@ -229,12 +224,9 @@ private void InitializeServiceLocator()
                     if (Application.platform.IsPlatformSupported(configuration.RuntimePlatform))
 #endif
                     {
-                        if (configuration.ComponentType.Type != null)
+                        if (!RegisterService<IMixedRealityExtensionService>(configuration.ComponentType, configuration.ComponentName, configuration.Priority))
                         {
-                            if (!RegisterService(typeof(IMixedRealityExtensionService), Activator.CreateInstance(configuration.ComponentType, configuration.ComponentName, configuration.Priority) as IMixedRealityExtensionService))
-                            {
-                                Debug.LogError($"Failed to register the {configuration.ComponentType.Type} Extension Service!");
-                            }
+                            Debug.LogError($"Failed to register the {configuration.ComponentType.Type} Extension Service!");
                         }
                     }
                 }
@@ -535,7 +527,7 @@ private void OnDestroy()
         /// <summary>
         /// Add a new service to the Mixed Reality Toolkit active service registry.
         /// </summary>
-        /// <param name="type">The interface type for the system to be managed.  E.G. InputSystem, BoundarySystem</param>
+        /// <param name="type">The interface type for the system to be registered.  E.G. InputSystem, BoundarySystem</param>
         /// <param name="service">The Instance of the service class to register</param>
         public bool RegisterService(Type type, IMixedRealityService service)
         {
@@ -547,40 +539,89 @@ public bool RegisterService(Type type, IMixedRealityService service)
 
             if (type == null)
             {
-                Debug.LogWarning("Unable to add a manager of type null.");
+                Debug.LogWarning("Unable to add a service of type null.");
                 return false;
             }
 
             if (service == null)
             {
-                Debug.LogWarning("Unable to add a manager with a null instance.");
+                Debug.LogWarning("Unable to add a service with a null instance.");
                 return false;
             }
 
-            if (IsCoreSystem(type))
+            return RegisterServiceInternal(type, service);
+        }
+
+        /// <summary>
+        /// Add a new service to the Mixed Reality Toolkit active service registry.
+        /// </summary>
+        /// <typeparam name="T">The interface type for the system to be registered.</typeparam>
+        /// <param name="concreteType">The concrete type to instantiate.</param>
+        /// <param name="args">Optional arguments used when instantiating the concrete type.</param>
+        /// <returns>True, if the service was successfully registered.</returns>
+        public bool RegisterService<T>(Type concreteType, params object[] args)
+        {
+            if (ActiveProfile == null) { return false; }
+
+            if (concreteType == null)
+            {
+                Debug.LogError("Unable to register a service with a null concrete type.");
+                return false;
+            }
+
+            if (!typeof(IMixedRealityService).IsAssignableFrom(concreteType))
+            {
+                Debug.LogError($"Unable to register the {concreteType} service. It does not implement the IMixedRealityService interface.");
+                return false;
+            }
+
+            T serviceInstance;
+
+            try
+            {
+                serviceInstance = (T)Activator.CreateInstance(concreteType, args);
+            }
+            catch (Exception e)
+            {
+                Debug.LogError($"Unable to register the {concreteType} service: {e.GetType()} - {e.Message}");
+                return false;
+            }
+
+            return RegisterServiceInternal(typeof(T), serviceInstance as IMixedRealityService);
+        }
+
+        /// <summary>
+        /// Internal service registration.
+        /// </summary>
+        /// <param name="interfaceType">The interface type for the system to be registered.</param>
+        /// <param name="serviceInstance">Instance of the service.</param>
+        /// <returns>True if registration is successful, false otherwise.</returns>
+        private bool RegisterServiceInternal(Type interfaceType, IMixedRealityService serviceInstance)
+        {
+            if (IsCoreSystem(interfaceType))
             {
                 IMixedRealityService preExistingService;
 
-                ActiveProfile.ActiveServices.TryGetValue(type, out preExistingService);
+                ActiveProfile.ActiveServices.TryGetValue(interfaceType, out preExistingService);
 
                 if (preExistingService == null)
                 {
-                    ActiveProfile.ActiveServices.Add(type, service);
+                    ActiveProfile.ActiveServices.Add(interfaceType, serviceInstance);
                     return true;
                 }
 
-                Debug.LogError($"There's already a {type.Name} registered.");
+                Debug.LogError($"There's already a {interfaceType.Name} registered.");
                 return false;
             }
 
-            if (!typeof(IMixedRealityExtensionService).IsAssignableFrom(type))
+            if (!typeof(IMixedRealityExtensionService).IsAssignableFrom(interfaceType))
             {
-                Debug.LogError($"Unable to register {type}. Concrete type does not implement the IMixedRealityExtensionService implementation.");
+                Debug.LogError($"Unable to register {interfaceType}. Concrete type does not implement the IMixedRealityExtensionService implementation.");
                 return false;
             }
 
-            MixedRealityComponents.Add(new Tuple<Type, IMixedRealityExtensionService>(type, (IMixedRealityExtensionService)service));
-            if (!isInitializing) { service.Initialize(); }
+            MixedRealityComponents.Add(new Tuple<Type, IMixedRealityExtensionService>(interfaceType, serviceInstance as IMixedRealityExtensionService));
+            if (!isInitializing) { serviceInstance.Initialize(); }
             mixedRealityComponentsCount = MixedRealityComponents.Count;
             return true;
         }
@@ -624,7 +665,7 @@ public IMixedRealityService GetService(Type type, bool showLogs = true)
 
             if (type == null)
             {
-                Debug.LogError("Unable to get null manager type.");
+                Debug.LogError("Unable to get null service type.");
                 return null;
             }
 
@@ -669,13 +710,13 @@ public IMixedRealityService GetService(Type type, string serviceName, bool showL
 
             if (type == null)
             {
-                Debug.LogError("Unable to get null manager type.");
+                Debug.LogError("Unable to get null service type.");
                 return null;
             }
 
             if (string.IsNullOrEmpty(serviceName))
             {
-                Debug.LogError("Unable to get manager by name without the name being specified.");
+                Debug.LogError("Unable to get service by name without the name being specified.");
                 return null;
             }
 
@@ -712,7 +753,7 @@ public void UnregisterService(Type type)
 
             if (type == null)
             {
-                Debug.LogError("Unable to remove null manager type.");
+                Debug.LogError("Unable to remove null service type.");
                 return;
             }
 
@@ -748,13 +789,13 @@ public void UnregisterService(Type type, string serviceName)
 
             if (type == null)
             {
-                Debug.LogError("Unable to remove null manager type.");
+                Debug.LogError("Unable to remove null service type.");
                 return;
             }
 
             if (string.IsNullOrEmpty(serviceName))
             {
-                Debug.LogError("Unable to remove manager by name without the name being specified.");
+                Debug.LogError("Unable to remove service by name without the name being specified.");
                 return;
             }
 
@@ -781,7 +822,7 @@ public void DisableService(Type type)
         {
             if (type == null)
             {
-                Debug.LogError("Unable to disable null manager type.");
+                Debug.LogError("Unable to disable null service type.");
                 return;
             }
 
@@ -809,13 +850,13 @@ public void DisableService(Type type, string serviceName)
         {
             if (type == null)
             {
-                Debug.LogError("Unable to disable null manager type.");
+                Debug.LogError("Unable to disable null service type.");
                 return;
             }
 
             if (string.IsNullOrEmpty(serviceName))
             {
-                Debug.LogError("Unable to disable manager by name without the name being specified.");
+                Debug.LogError("Unable to disable service by name without the name being specified.");
                 return;
             }
 
@@ -842,7 +883,7 @@ public void EnableService(Type type)
         {
             if (type == null)
             {
-                Debug.LogError("Unable to enable null manager type.");
+                Debug.LogError("Unable to enable null service type.");
                 return;
             }
 
@@ -870,13 +911,13 @@ public void EnableService(Type type, string serviceName)
         {
             if (type == null)
             {
-                Debug.LogError("Unable to enable null manager type.");
+                Debug.LogError("Unable to enable null service type.");
                 return;
             }
 
             if (string.IsNullOrEmpty(serviceName))
             {
-                Debug.LogError("Unable to enable manager by name without the name being specified.");
+                Debug.LogError("Unable to enable service by name without the name being specified.");
                 return;
             }
 
@@ -908,7 +949,7 @@ public List<IMixedRealityService> GetActiveServices(Type type)
         {
             if (type == null)
             {
-                Debug.LogWarning("Unable to get managers with a type of null.");
+                Debug.LogWarning("Unable to get services with a type of null.");
                 return new List<IMixedRealityService>();
             }
 
@@ -931,7 +972,7 @@ public List<IMixedRealityService> GetActiveServices(Type type, string serviceNam
 
             if (type == null)
             {
-                Debug.LogWarning("Unable to get managers with a type of null.");
+                Debug.LogWarning("Unable to get services with a type of null.");
                 return new List<IMixedRealityService>();
             }
 
@@ -1096,7 +1137,7 @@ private static bool IsCoreSystem(Type type)
         {
             if (type == null)
             {
-                Debug.LogWarning("Null cannot be a core manager.");
+                Debug.LogWarning("Null cannot be a core system.");
                 return false;
             }
 
diff --git a/ProjectSettings/ProjectVersion.txt b/ProjectSettings/ProjectVersion.txt
@@ -1 +1 @@
-m_EditorVersion: 2018.2.14f1
+m_EditorVersion: 2018.2.16f1

Original file line number	Diff line number	Diff line change
`@@ -172,8 +172,7 @@ private void InitializeServiceLocator()`
`172`	`172`	`Utilities.Editor.InputMappingAxisUtility.CheckUnityInputManagerMappings(Definitions.Devices.ControllerMappingLibrary.UnityInputManagerAxes);`
`173`	`173`	`#endif`
`174`	`174`
`175`		`- if (!RegisterService(typeof(IMixedRealityInputSystem), Activator.CreateInstance(ActiveProfile.InputSystemType) as IMixedRealityInputSystem) \|\|`
`176`		`- InputSystem == null)`
	`175`	`+ if (!RegisterService<IMixedRealityInputSystem>(ActiveProfile.InputSystemType) \|\| InputSystem == null)`
`177`	`176`	`{`
`178`	`177`	`Debug.LogError("Failed to start the Input System!");`
`179`	`178`	`}`
`@@ -182,8 +181,7 @@ private void InitializeServiceLocator()`
`182`	`181`	`// If the Boundary system has been selected for initialization in the Active profile, enable it in the project`
`183`	`182`	`if (ActiveProfile.IsBoundarySystemEnabled)`
`184`	`183`	`{`
`185`		`- if (!RegisterService(typeof(IMixedRealityBoundarySystem), Activator.CreateInstance(ActiveProfile.BoundarySystemSystemType) as IMixedRealityBoundarySystem) \|\|`
`186`		`- BoundarySystem == null)`
	`184`	`+ if (!RegisterService<IMixedRealityBoundarySystem>(ActiveProfile.BoundarySystemSystemType) \|\| BoundarySystem == null)`
`187`	`185`	`{`
`188`	`186`	`Debug.LogError("Failed to start the Boundary System!");`
`189`	`187`	`}`
`@@ -192,8 +190,7 @@ private void InitializeServiceLocator()`
`192`	`190`	`// If the Spatial Awareness system has been selected for initialization in the Active profile, enable it in the project`
`193`	`191`	`if (ActiveProfile.IsSpatialAwarenessSystemEnabled)`
`194`	`192`	`{`
`195`		`- if (!RegisterService(typeof(IMixedRealitySpatialAwarenessSystem), Activator.CreateInstance(ActiveProfile.SpatialAwarenessSystemSystemType) as IMixedRealitySpatialAwarenessSystem) \|\|`
`196`		`- SpatialAwarenessSystem == null)`
	`193`	`+ if (!RegisterService<IMixedRealitySpatialAwarenessSystem>(ActiveProfile.SpatialAwarenessSystemSystemType) \|\| SpatialAwarenessSystem == null)`
`197`	`194`	`{`
`198`	`195`	`Debug.LogError("Failed to start the Spatial Awareness System!");`
`199`	`196`	`}`
`@@ -202,17 +199,15 @@ private void InitializeServiceLocator()`
`202`	`199`	`// If the Teleport system has been selected for initialization in the Active profile, enable it in the project`
`203`	`200`	`if (ActiveProfile.IsTeleportSystemEnabled)`
`204`	`201`	`{`
`205`		`- if (!RegisterService(typeof(IMixedRealityTeleportSystem), Activator.CreateInstance(ActiveProfile.TeleportSystemSystemType) as IMixedRealityTeleportSystem) \|\|`
`206`		`- TeleportSystem == null)`
	`202`	`+ if (!RegisterService<IMixedRealityTeleportSystem>(ActiveProfile.TeleportSystemSystemType) \|\| TeleportSystem == null)`
`207`	`203`	`{`
`208`	`204`	`Debug.LogError("Failed to start the Teleport System!");`
`209`	`205`	`}`
`210`	`206`	`}`
`211`	`207`
`212`	`208`	`if (ActiveProfile.IsDiagnosticsSystemEnabled)`
`213`	`209`	`{`
`214`		`- if (!RegisterService(typeof(IMixedRealityDiagnosticsSystem), Activator.CreateInstance(ActiveProfile.DiagnosticsSystemSystemType) as IMixedRealityDiagnosticsSystem) \|\|`
`215`		`- DiagnosticsSystem == null)`
	`210`	`+ if (!RegisterService<IMixedRealityDiagnosticsSystem>(ActiveProfile.DiagnosticsSystemSystemType) \|\| DiagnosticsSystem == null)`
`216`	`211`	`{`
`217`	`212`	`Debug.LogError("Failed to start the Diagnostics System!");`
`218`	`213`	`}`
`@@ -229,12 +224,9 @@ private void InitializeServiceLocator()`
`229`	`224`	`if (Application.platform.IsPlatformSupported(configuration.RuntimePlatform))`
`230`	`225`	`#endif`
`231`	`226`	`{`
`232`		`- if (configuration.ComponentType.Type != null)`
	`227`	`+ if (!RegisterService<IMixedRealityExtensionService>(configuration.ComponentType, configuration.ComponentName, configuration.Priority))`
`233`	`228`	`{`
`234`		`- if (!RegisterService(typeof(IMixedRealityExtensionService), Activator.CreateInstance(configuration.ComponentType, configuration.ComponentName, configuration.Priority) as IMixedRealityExtensionService))`
`235`		`- {`
`236`		`- Debug.LogError($"Failed to register the {configuration.ComponentType.Type} Extension Service!");`
`237`		`- }`
	`229`	`+ Debug.LogError($"Failed to register the {configuration.ComponentType.Type} Extension Service!");`
`238`	`230`	`}`
`239`	`231`	`}`
`240`	`232`	`}`
`@@ -535,7 +527,7 @@ private void OnDestroy()`
`535`	`527`	`/// <summary>`
`536`	`528`	`/// Add a new service to the Mixed Reality Toolkit active service registry.`
`537`	`529`	`/// </summary>`
`538`		`- /// <param name="type">The interface type for the system to be managed. E.G. InputSystem, BoundarySystem</param>`
	`530`	`+ /// <param name="type">The interface type for the system to be registered. E.G. InputSystem, BoundarySystem</param>`
`539`	`531`	`/// <param name="service">The Instance of the service class to register</param>`
`540`	`532`	`public bool RegisterService(Type type, IMixedRealityService service)`
`541`	`533`	`{`
`@@ -547,40 +539,89 @@ public bool RegisterService(Type type, IMixedRealityService service)`
`547`	`539`
`548`	`540`	`if (type == null)`
`549`	`541`	`{`
`550`		`- Debug.LogWarning("Unable to add a manager of type null.");`
	`542`	`+ Debug.LogWarning("Unable to add a service of type null.");`
`551`	`543`	`return false;`
`552`	`544`	`}`
`553`	`545`
`554`	`546`	`if (service == null)`
`555`	`547`	`{`
`556`		`- Debug.LogWarning("Unable to add a manager with a null instance.");`
	`548`	`+ Debug.LogWarning("Unable to add a service with a null instance.");`
`557`	`549`	`return false;`
`558`	`550`	`}`
`559`	`551`
`560`		`- if (IsCoreSystem(type))`
	`552`	`+ return RegisterServiceInternal(type, service);`
	`553`	`+ }`
	`554`	`+`
	`555`	`+ /// <summary>`
	`556`	`+ /// Add a new service to the Mixed Reality Toolkit active service registry.`
	`557`	`+ /// </summary>`
	`558`	`+ /// <typeparam name="T">The interface type for the system to be registered.</typeparam>`
	`559`	`+ /// <param name="concreteType">The concrete type to instantiate.</param>`
	`560`	`+ /// <param name="args">Optional arguments used when instantiating the concrete type.</param>`
	`561`	`+ /// <returns>True, if the service was successfully registered.</returns>`
	`562`	`+ public bool RegisterService<T>(Type concreteType, params object[] args)`
	`563`	`+ {`
	`564`	`+ if (ActiveProfile == null) { return false; }`
	`565`	`+`
	`566`	`+ if (concreteType == null)`
	`567`	`+ {`
	`568`	`+ Debug.LogError("Unable to register a service with a null concrete type.");`
	`569`	`+ return false;`
	`570`	`+ }`
	`571`	`+`
	`572`	`+ if (!typeof(IMixedRealityService).IsAssignableFrom(concreteType))`
	`573`	`+ {`
	`574`	`+ Debug.LogError($"Unable to register the {concreteType} service. It does not implement the IMixedRealityService interface.");`
	`575`	`+ return false;`
	`576`	`+ }`
	`577`	`+`
	`578`	`+ T serviceInstance;`
	`579`	`+`
	`580`	`+ try`
	`581`	`+ {`
	`582`	`+ serviceInstance = (T)Activator.CreateInstance(concreteType, args);`
	`583`	`+ }`
	`584`	`+ catch (Exception e)`
	`585`	`+ {`
	`586`	`+ Debug.LogError($"Unable to register the {concreteType} service: {e.GetType()} - {e.Message}");`
	`587`	`+ return false;`
	`588`	`+ }`
	`589`	`+`
	`590`	`+ return RegisterServiceInternal(typeof(T), serviceInstance as IMixedRealityService);`
	`591`	`+ }`
	`592`	`+`
	`593`	`+ /// <summary>`
	`594`	`+ /// Internal service registration.`
	`595`	`+ /// </summary>`
	`596`	`+ /// <param name="interfaceType">The interface type for the system to be registered.</param>`
	`597`	`+ /// <param name="serviceInstance">Instance of the service.</param>`
	`598`	`+ /// <returns>True if registration is successful, false otherwise.</returns>`
	`599`	`+ private bool RegisterServiceInternal(Type interfaceType, IMixedRealityService serviceInstance)`
	`600`	`+ {`
	`601`	`+ if (IsCoreSystem(interfaceType))`
`561`	`602`	`{`
`562`	`603`	`IMixedRealityService preExistingService;`
`563`	`604`
`564`		`- ActiveProfile.ActiveServices.TryGetValue(type, out preExistingService);`
	`605`	`+ ActiveProfile.ActiveServices.TryGetValue(interfaceType, out preExistingService);`
`565`	`606`
`566`	`607`	`if (preExistingService == null)`
`567`	`608`	`{`
`568`		`- ActiveProfile.ActiveServices.Add(type, service);`
	`609`	`+ ActiveProfile.ActiveServices.Add(interfaceType, serviceInstance);`
`569`	`610`	`return true;`
`570`	`611`	`}`
`571`	`612`
`572`		`- Debug.LogError($"There's already a {type.Name} registered.");`
	`613`	`+ Debug.LogError($"There's already a {interfaceType.Name} registered.");`
`573`	`614`	`return false;`
`574`	`615`	`}`
`575`	`616`
`576`		`- if (!typeof(IMixedRealityExtensionService).IsAssignableFrom(type))`
	`617`	`+ if (!typeof(IMixedRealityExtensionService).IsAssignableFrom(interfaceType))`
`577`	`618`	`{`
`578`		`- Debug.LogError($"Unable to register {type}. Concrete type does not implement the IMixedRealityExtensionService implementation.");`
	`619`	`+ Debug.LogError($"Unable to register {interfaceType}. Concrete type does not implement the IMixedRealityExtensionService implementation.");`
`579`	`620`	`return false;`
`580`	`621`	`}`
`581`	`622`
`582`		`- MixedRealityComponents.Add(new Tuple<Type, IMixedRealityExtensionService>(type, (IMixedRealityExtensionService)service));`
`583`		`- if (!isInitializing) { service.Initialize(); }`
	`623`	`+ MixedRealityComponents.Add(new Tuple<Type, IMixedRealityExtensionService>(interfaceType, serviceInstance as IMixedRealityExtensionService));`
	`624`	`+ if (!isInitializing) { serviceInstance.Initialize(); }`
`584`	`625`	`mixedRealityComponentsCount = MixedRealityComponents.Count;`
`585`	`626`	`return true;`
`586`	`627`	`}`
`@@ -624,7 +665,7 @@ public IMixedRealityService GetService(Type type, bool showLogs = true)`
`624`	`665`
`625`	`666`	`if (type == null)`
`626`	`667`	`{`
`627`		`- Debug.LogError("Unable to get null manager type.");`
	`668`	`+ Debug.LogError("Unable to get null service type.");`
`628`	`669`	`return null;`
`629`	`670`	`}`
`630`	`671`
`@@ -669,13 +710,13 @@ public IMixedRealityService GetService(Type type, string serviceName, bool showL`
`669`	`710`
`670`	`711`	`if (type == null)`
`671`	`712`	`{`
`672`		`- Debug.LogError("Unable to get null manager type.");`
	`713`	`+ Debug.LogError("Unable to get null service type.");`
`673`	`714`	`return null;`
`674`	`715`	`}`
`675`	`716`
`676`	`717`	`if (string.IsNullOrEmpty(serviceName))`
`677`	`718`	`{`
`678`		`- Debug.LogError("Unable to get manager by name without the name being specified.");`
	`719`	`+ Debug.LogError("Unable to get service by name without the name being specified.");`
`679`	`720`	`return null;`
`680`	`721`	`}`
`681`	`722`
`@@ -712,7 +753,7 @@ public void UnregisterService(Type type)`
`712`	`753`
`713`	`754`	`if (type == null)`
`714`	`755`	`{`
`715`		`- Debug.LogError("Unable to remove null manager type.");`
	`756`	`+ Debug.LogError("Unable to remove null service type.");`
`716`	`757`	`return;`
`717`	`758`	`}`
`718`	`759`
`@@ -748,13 +789,13 @@ public void UnregisterService(Type type, string serviceName)`
`748`	`789`
`749`	`790`	`if (type == null)`
`750`	`791`	`{`
`751`		`- Debug.LogError("Unable to remove null manager type.");`
	`792`	`+ Debug.LogError("Unable to remove null service type.");`
`752`	`793`	`return;`
`753`	`794`	`}`
`754`	`795`
`755`	`796`	`if (string.IsNullOrEmpty(serviceName))`
`756`	`797`	`{`
`757`		`- Debug.LogError("Unable to remove manager by name without the name being specified.");`
	`798`	`+ Debug.LogError("Unable to remove service by name without the name being specified.");`
`758`	`799`	`return;`
`759`	`800`	`}`
`760`	`801`
`@@ -781,7 +822,7 @@ public void DisableService(Type type)`
`781`	`822`	`{`
`782`	`823`	`if (type == null)`
`783`	`824`	`{`
`784`		`- Debug.LogError("Unable to disable null manager type.");`
	`825`	`+ Debug.LogError("Unable to disable null service type.");`
`785`	`826`	`return;`
`786`	`827`	`}`
`787`	`828`
`@@ -809,13 +850,13 @@ public void DisableService(Type type, string serviceName)`
`809`	`850`	`{`
`810`	`851`	`if (type == null)`
`811`	`852`	`{`
`812`		`- Debug.LogError("Unable to disable null manager type.");`
	`853`	`+ Debug.LogError("Unable to disable null service type.");`
`813`	`854`	`return;`
`814`	`855`	`}`
`815`	`856`
`816`	`857`	`if (string.IsNullOrEmpty(serviceName))`
`817`	`858`	`{`
`818`		`- Debug.LogError("Unable to disable manager by name without the name being specified.");`
	`859`	`+ Debug.LogError("Unable to disable service by name without the name being specified.");`
`819`	`860`	`return;`
`820`	`861`	`}`
`821`	`862`
`@@ -842,7 +883,7 @@ public void EnableService(Type type)`
`842`	`883`	`{`
`843`	`884`	`if (type == null)`
`844`	`885`	`{`
`845`		`- Debug.LogError("Unable to enable null manager type.");`
	`886`	`+ Debug.LogError("Unable to enable null service type.");`
`846`	`887`	`return;`
`847`	`888`	`}`
`848`	`889`
`@@ -870,13 +911,13 @@ public void EnableService(Type type, string serviceName)`
`870`	`911`	`{`
`871`	`912`	`if (type == null)`
`872`	`913`	`{`
`873`		`- Debug.LogError("Unable to enable null manager type.");`
	`914`	`+ Debug.LogError("Unable to enable null service type.");`
`874`	`915`	`return;`
`875`	`916`	`}`
`876`	`917`
`877`	`918`	`if (string.IsNullOrEmpty(serviceName))`
`878`	`919`	`{`
`879`		`- Debug.LogError("Unable to enable manager by name without the name being specified.");`
	`920`	`+ Debug.LogError("Unable to enable service by name without the name being specified.");`
`880`	`921`	`return;`
`881`	`922`	`}`
`882`	`923`
`@@ -908,7 +949,7 @@ public List<IMixedRealityService> GetActiveServices(Type type)`
`908`	`949`	`{`
`909`	`950`	`if (type == null)`
`910`	`951`	`{`
`911`		`- Debug.LogWarning("Unable to get managers with a type of null.");`
	`952`	`+ Debug.LogWarning("Unable to get services with a type of null.");`
`912`	`953`	`return new List<IMixedRealityService>();`
`913`	`954`	`}`
`914`	`955`
`@@ -931,7 +972,7 @@ public List<IMixedRealityService> GetActiveServices(Type type, string serviceNam`
`931`	`972`
`932`	`973`	`if (type == null)`
`933`	`974`	`{`
`934`		`- Debug.LogWarning("Unable to get managers with a type of null.");`
	`975`	`+ Debug.LogWarning("Unable to get services with a type of null.");`
`935`	`976`	`return new List<IMixedRealityService>();`
`936`	`977`	`}`
`937`	`978`
`@@ -1096,7 +1137,7 @@ private static bool IsCoreSystem(Type type)`
`1096`	`1137`	`{`
`1097`	`1138`	`if (type == null)`
`1098`	`1139`	`{`
`1099`		`- Debug.LogWarning("Null cannot be a core manager.");`
	`1140`	`+ Debug.LogWarning("Null cannot be a core system.");`
`1100`	`1141`	`return false;`
`1101`	`1142`	`}`
`1102`	`1143`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-m_EditorVersion: 2018.2.14f1`
	`1`	`+m_EditorVersion: 2018.2.16f1`