Merge pull request #2981 from SimonDarksideJ/mrtk_development_SerializationFix

David Kline · web-flow · commit 5f397e592296 · 2018-10-26T10:06:45.000-07:00
Mrtk development serialization fix
diff --git a/Assets/MixedRealityToolkit-SDK/Profiles/DefaultMixedRealityToolkitConfigurationProfile.asset b/Assets/MixedRealityToolkit-SDK/Profiles/DefaultMixedRealityToolkitConfigurationProfile.asset
@@ -12,13 +12,6 @@ MonoBehaviour:
   m_Name: DefaultMixedRealityToolkitConfigurationProfile
   m_EditorClassIdentifier: 
   isCustomProfile: 0
-  initialServiceTypes:
-  - reference: Microsoft.MixedReality.Toolkit.SDK.Teleportation.MixedRealityTeleportManager,
-      Microsoft.MixedReality.Toolkit.SDK
-  - reference: Microsoft.MixedReality.Toolkit.SDK.BoundarySystem.MixedRealityBoundaryManager,
-      Microsoft.MixedReality.Toolkit.SDK
-  - reference: Microsoft.MixedReality.Toolkit.SDK.Input.MixedRealityInputManager,
-      Microsoft.MixedReality.Toolkit.SDK
   targetExperienceScale: 3
   enableCameraProfile: 1
   cameraProfile: {fileID: 11400000, guid: 8089ccfdd4494cd38f676f9fc1f46a04, type: 2}
diff --git a/Assets/MixedRealityToolkit/_Core/Definitions/MixedRealityToolkitConfigurationProfile.cs b/Assets/MixedRealityToolkit/_Core/Definitions/MixedRealityToolkitConfigurationProfile.cs
@@ -21,13 +21,10 @@ namespace Microsoft.MixedReality.Toolkit.Core.Definitions
     /// Configuration profile settings for the Mixed Reality Toolkit.
     /// </summary>
     [CreateAssetMenu(menuName = "Mixed Reality Toolkit/Mixed Reality Toolkit Configuration Profile", fileName = "MixedRealityToolkitConfigurationProfile", order = (int)CreateProfileMenuItemIndices.Configuration)]
-    public class MixedRealityToolkitConfigurationProfile : BaseMixedRealityProfile, ISerializationCallbackReceiver
+    public class MixedRealityToolkitConfigurationProfile : BaseMixedRealityProfile
     {
         #region Service Registry properties
 
-        [SerializeField]
-        private SystemType[] initialServiceTypes = null;
-
         /// <summary>
         /// Dictionary list of active Systems used by the Mixed Reality Toolkit at runtime
         /// </summary>
@@ -238,33 +235,5 @@ public SystemType DiagnosticsSystemSystemType
         public MixedRealityRegisteredServiceProvidersProfile RegisteredServiceProvidersProfile => registeredServiceProvidersProfile;
 
         #endregion Mixed Reality Toolkit configurable properties
-
-        #region ISerializationCallbackReceiver Implementation
-
-        /// <inheritdoc />
-        void ISerializationCallbackReceiver.OnBeforeSerialize()
-        {
-            var count = ActiveServices.Count;
-            initialServiceTypes = new SystemType[count];
-
-            foreach (var service in ActiveServices)
-            {
-                --count;
-                initialServiceTypes[count] = new SystemType(service.Value.GetType());
-            }
-        }
-
-        /// <inheritdoc />
-        void ISerializationCallbackReceiver.OnAfterDeserialize()
-        {
-            if (ActiveServices.Count == 0)
-            {
-                for (int i = 0; i < initialServiceTypes?.Length; i++)
-                {
-                    ActiveServices.Add(initialServiceTypes[i], Activator.CreateInstance(initialServiceTypes[i]) as IMixedRealityService);
-                }
-            }
-        }
     }
-    #endregion  ISerializationCallbackReceiver Implementation
 }
diff --git a/Assets/MixedRealityToolkit/_Core/Services/MixedRealityToolkit.cs b/Assets/MixedRealityToolkit/_Core/Services/MixedRealityToolkit.cs
@@ -177,9 +177,8 @@ private void Initialize()
                 Utilities.Editor.InputMappingAxisUtility.CheckUnityInputManagerMappings(Definitions.Devices.ControllerMappingLibrary.UnityInputManagerAxes);
 #endif
 
-                RegisterService(typeof(IMixedRealityInputSystem), Activator.CreateInstance(ActiveProfile.InputSystemType) as IMixedRealityInputSystem);
-
-                if (InputSystem == null)
+                if (!RegisterService(typeof(IMixedRealityInputSystem), Activator.CreateInstance(ActiveProfile.InputSystemType) as IMixedRealityInputSystem) ||
+                    InputSystem == null)
                 {
                     Debug.LogError("Failed to start the Input System!");
                 }
@@ -188,9 +187,8 @@ private void Initialize()
             // If the Boundary system has been selected for initialization in the Active profile, enable it in the project
             if (ActiveProfile.IsBoundarySystemEnabled)
             {
-                RegisterService(typeof(IMixedRealityBoundarySystem), Activator.CreateInstance(ActiveProfile.BoundarySystemSystemType) as IMixedRealityBoundarySystem);
-
-                if (BoundarySystem == null)
+                if (!RegisterService(typeof(IMixedRealityBoundarySystem), Activator.CreateInstance(ActiveProfile.BoundarySystemSystemType) as IMixedRealityBoundarySystem) ||
+                    BoundarySystem == null)
                 {
                     Debug.LogError("Failed to start the Boundary System!");
                 }
@@ -200,19 +198,17 @@ private void Initialize()
             // If the Teleport system has been selected for initialization in the Active profile, enable it in the project
             if (ActiveProfile.IsTeleportSystemEnabled)
             {
-                RegisterService(typeof(IMixedRealityTeleportSystem), Activator.CreateInstance(ActiveProfile.TeleportSystemSystemType) as IMixedRealityTeleportSystem);
-
-                if (TeleportSystem == null)
+                if (!RegisterService(typeof(IMixedRealityTeleportSystem), Activator.CreateInstance(ActiveProfile.TeleportSystemSystemType) as IMixedRealityTeleportSystem) ||
+                    TeleportSystem == null)
                 {
                     Debug.LogError("Failed to start the Teleport System!");
                 }
             }
 
             if (ActiveProfile.IsDiagnosticsSystemEnabled)
             {
-                RegisterService(typeof(IMixedRealityDiagnosticsSystem), Activator.CreateInstance(ActiveProfile.DiagnosticsSystemSystemType) as IMixedRealityDiagnosticsSystem);
-
-                if (DiagnosticsSystem == null)
+                if (!RegisterService(typeof(IMixedRealityDiagnosticsSystem), Activator.CreateInstance(ActiveProfile.DiagnosticsSystemSystemType) as IMixedRealityDiagnosticsSystem) ||
+                    DiagnosticsSystem == null)
                 {
                     Debug.LogError("Failed to start the Diagnostics System!");
                 }
@@ -231,7 +227,10 @@ private void Initialize()
                     {
                         if (configuration.ComponentType.Type != null)
                         {
-                            RegisterService(typeof(IMixedRealityExtensionService), Activator.CreateInstance(configuration.ComponentType, configuration.ComponentName, configuration.Priority) as IMixedRealityExtensionService);
+                            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!");
+                            }
                         }
                     }
                 }
@@ -489,50 +488,54 @@ private void OnDestroy()
         /// </summary>
         /// <param name="type">The interface type for the system to be managed.  E.G. InputSystem, BoundarySystem</param>
         /// <param name="service">The Instance of the service class to register</param>
-        public void RegisterService(Type type, IMixedRealityService service)
+        public bool RegisterService(Type type, IMixedRealityService service)
         {
             if (ActiveProfile == null)
             {
                 Debug.LogError($"Unable to add a new {type.Name} Service as the Mixed Reality Toolkit has to Active Profile");
+                return false;
             }
 
             if (type == null)
             {
                 Debug.LogWarning("Unable to add a manager of type null.");
-                return;
+                return false;
             }
             if (service == null)
             {
                 Debug.LogWarning("Unable to add a manager with a null instance.");
-                return;
+                return false;
             }
 
             if (IsCoreSystem(type))
             {
                 IMixedRealityService preExistingService;
-                if (IsCoreSystem(type))
-                {
-                    ActiveProfile.ActiveServices.TryGetValue(type, out preExistingService);
-                }
-                else
-                {
-                    GetService(type, out preExistingService);
-                }
+
+                ActiveProfile.ActiveServices.TryGetValue(type, out preExistingService);
 
                 if (preExistingService == null)
                 {
                     ActiveProfile.ActiveServices.Add(type, service);
+                    return true;
                 }
                 else
                 {
                     Debug.LogError($"There's already a {type.Name} registered.");
+                    return false;
                 }
             }
             else
             {
+                if (!typeof(IMixedRealityExtensionService).IsAssignableFrom(type))
+                {
+                    Debug.LogError($"Unable to register {service}. Concrete type does not implement the IMixedRealityExtensionService implementation.");
+                    return false;
+                }
+
                 MixedRealityComponents.Add(new Tuple<Type, IMixedRealityExtensionService>(type, (IMixedRealityExtensionService)service));
                 if (!isInitializing) { service.Initialize(); }
                 mixedRealityComponentsCount = MixedRealityComponents.Count;
+                return true;
             }
         }
 
@@ -1024,10 +1027,10 @@ private bool IsCoreSystem(Type type)
                 return false;
             }
 
-            return type == typeof(IMixedRealityInputSystem) ||
-                   type == typeof(IMixedRealityTeleportSystem) ||
-                   type == typeof(IMixedRealityBoundarySystem) ||
-                   type == typeof(IMixedRealityDiagnosticsSystem);
+            return typeof(IMixedRealityInputSystem).IsAssignableFrom(type) ||
+                   typeof(IMixedRealityTeleportSystem).IsAssignableFrom(type) ||
+                   typeof(IMixedRealityBoundarySystem).IsAssignableFrom(type) ||
+                   typeof(IMixedRealityDiagnosticsSystem).IsAssignableFrom(type);
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -177,9 +177,8 @@ private void Initialize()`
`177`	`177`	`Utilities.Editor.InputMappingAxisUtility.CheckUnityInputManagerMappings(Definitions.Devices.ControllerMappingLibrary.UnityInputManagerAxes);`
`178`	`178`	`#endif`
`179`	`179`
`180`		`- RegisterService(typeof(IMixedRealityInputSystem), Activator.CreateInstance(ActiveProfile.InputSystemType) as IMixedRealityInputSystem);`
`181`		`-`
`182`		`- if (InputSystem == null)`
	`180`	`+ if (!RegisterService(typeof(IMixedRealityInputSystem), Activator.CreateInstance(ActiveProfile.InputSystemType) as IMixedRealityInputSystem) \|\|`
	`181`	`+ InputSystem == null)`
`183`	`182`	`{`
`184`	`183`	`Debug.LogError("Failed to start the Input System!");`
`185`	`184`	`}`
`@@ -188,9 +187,8 @@ private void Initialize()`
`188`	`187`	`// If the Boundary system has been selected for initialization in the Active profile, enable it in the project`
`189`	`188`	`if (ActiveProfile.IsBoundarySystemEnabled)`
`190`	`189`	`{`
`191`		`- RegisterService(typeof(IMixedRealityBoundarySystem), Activator.CreateInstance(ActiveProfile.BoundarySystemSystemType) as IMixedRealityBoundarySystem);`
`192`		`-`
`193`		`- if (BoundarySystem == null)`
	`190`	`+ if (!RegisterService(typeof(IMixedRealityBoundarySystem), Activator.CreateInstance(ActiveProfile.BoundarySystemSystemType) as IMixedRealityBoundarySystem) \|\|`
	`191`	`+ BoundarySystem == null)`
`194`	`192`	`{`
`195`	`193`	`Debug.LogError("Failed to start the Boundary System!");`
`196`	`194`	`}`
`@@ -200,19 +198,17 @@ private void Initialize()`
`200`	`198`	`// If the Teleport system has been selected for initialization in the Active profile, enable it in the project`
`201`	`199`	`if (ActiveProfile.IsTeleportSystemEnabled)`
`202`	`200`	`{`
`203`		`- RegisterService(typeof(IMixedRealityTeleportSystem), Activator.CreateInstance(ActiveProfile.TeleportSystemSystemType) as IMixedRealityTeleportSystem);`
`204`		`-`
`205`		`- if (TeleportSystem == null)`
	`201`	`+ if (!RegisterService(typeof(IMixedRealityTeleportSystem), Activator.CreateInstance(ActiveProfile.TeleportSystemSystemType) as IMixedRealityTeleportSystem) \|\|`
	`202`	`+ TeleportSystem == null)`
`206`	`203`	`{`
`207`	`204`	`Debug.LogError("Failed to start the Teleport System!");`
`208`	`205`	`}`
`209`	`206`	`}`
`210`	`207`
`211`	`208`	`if (ActiveProfile.IsDiagnosticsSystemEnabled)`
`212`	`209`	`{`
`213`		`- RegisterService(typeof(IMixedRealityDiagnosticsSystem), Activator.CreateInstance(ActiveProfile.DiagnosticsSystemSystemType) as IMixedRealityDiagnosticsSystem);`
`214`		`-`
`215`		`- if (DiagnosticsSystem == null)`
	`210`	`+ if (!RegisterService(typeof(IMixedRealityDiagnosticsSystem), Activator.CreateInstance(ActiveProfile.DiagnosticsSystemSystemType) as IMixedRealityDiagnosticsSystem) \|\|`
	`211`	`+ DiagnosticsSystem == null)`
`216`	`212`	`{`
`217`	`213`	`Debug.LogError("Failed to start the Diagnostics System!");`
`218`	`214`	`}`
`@@ -231,7 +227,10 @@ private void Initialize()`
`231`	`227`	`{`
`232`	`228`	`if (configuration.ComponentType.Type != null)`
`233`	`229`	`{`
`234`		`- RegisterService(typeof(IMixedRealityExtensionService), Activator.CreateInstance(configuration.ComponentType, configuration.ComponentName, configuration.Priority) as IMixedRealityExtensionService);`
	`230`	`+ if(!RegisterService(typeof(IMixedRealityExtensionService), Activator.CreateInstance(configuration.ComponentType, configuration.ComponentName, configuration.Priority) as IMixedRealityExtensionService))`
	`231`	`+ {`
	`232`	`+ Debug.LogError($"Failed to register the {configuration.ComponentType.Type} Extension Service!");`
	`233`	`+ }`
`235`	`234`	`}`
`236`	`235`	`}`
`237`	`236`	`}`
`@@ -489,50 +488,54 @@ private void OnDestroy()`
`489`	`488`	`/// </summary>`
`490`	`489`	`/// <param name="type">The interface type for the system to be managed. E.G. InputSystem, BoundarySystem</param>`
`491`	`490`	`/// <param name="service">The Instance of the service class to register</param>`
`492`		`- public void RegisterService(Type type, IMixedRealityService service)`
	`491`	`+ public bool RegisterService(Type type, IMixedRealityService service)`
`493`	`492`	`{`
`494`	`493`	`if (ActiveProfile == null)`
`495`	`494`	`{`
`496`	`495`	`Debug.LogError($"Unable to add a new {type.Name} Service as the Mixed Reality Toolkit has to Active Profile");`
	`496`	`+ return false;`
`497`	`497`	`}`
`498`	`498`
`499`	`499`	`if (type == null)`
`500`	`500`	`{`
`501`	`501`	`Debug.LogWarning("Unable to add a manager of type null.");`
`502`		`- return;`
	`502`	`+ return false;`
`503`	`503`	`}`
`504`	`504`	`if (service == null)`
`505`	`505`	`{`
`506`	`506`	`Debug.LogWarning("Unable to add a manager with a null instance.");`
`507`		`- return;`
	`507`	`+ return false;`
`508`	`508`	`}`
`509`	`509`
`510`	`510`	`if (IsCoreSystem(type))`
`511`	`511`	`{`
`512`	`512`	`IMixedRealityService preExistingService;`
`513`		`- if (IsCoreSystem(type))`
`514`		`- {`
`515`		`- ActiveProfile.ActiveServices.TryGetValue(type, out preExistingService);`
`516`		`- }`
`517`		`- else`
`518`		`- {`
`519`		`- GetService(type, out preExistingService);`
`520`		`- }`
	`513`	`+`
	`514`	`+ ActiveProfile.ActiveServices.TryGetValue(type, out preExistingService);`
`521`	`515`
`522`	`516`	`if (preExistingService == null)`
`523`	`517`	`{`
`524`	`518`	`ActiveProfile.ActiveServices.Add(type, service);`
	`519`	`+ return true;`
`525`	`520`	`}`
`526`	`521`	`else`
`527`	`522`	`{`
`528`	`523`	`Debug.LogError($"There's already a {type.Name} registered.");`
	`524`	`+ return false;`
`529`	`525`	`}`
`530`	`526`	`}`
`531`	`527`	`else`
`532`	`528`	`{`
	`529`	`+ if (!typeof(IMixedRealityExtensionService).IsAssignableFrom(type))`
	`530`	`+ {`
	`531`	`+ Debug.LogError($"Unable to register {service}. Concrete type does not implement the IMixedRealityExtensionService implementation.");`
	`532`	`+ return false;`
	`533`	`+ }`
	`534`	`+`
`533`	`535`	`MixedRealityComponents.Add(new Tuple<Type, IMixedRealityExtensionService>(type, (IMixedRealityExtensionService)service));`
`534`	`536`	`if (!isInitializing) { service.Initialize(); }`
`535`	`537`	`mixedRealityComponentsCount = MixedRealityComponents.Count;`
	`538`	`+ return true;`
`536`	`539`	`}`
`537`	`540`	`}`
`538`	`541`
`@@ -1024,10 +1027,10 @@ private bool IsCoreSystem(Type type)`
`1024`	`1027`	`return false;`
`1025`	`1028`	`}`
`1026`	`1029`
`1027`		`- return type == typeof(IMixedRealityInputSystem) \|\|`
`1028`		`- type == typeof(IMixedRealityTeleportSystem) \|\|`
`1029`		`- type == typeof(IMixedRealityBoundarySystem) \|\|`
`1030`		`- type == typeof(IMixedRealityDiagnosticsSystem);`
	`1030`	`+ return typeof(IMixedRealityInputSystem).IsAssignableFrom(type) \|\|`
	`1031`	`+ typeof(IMixedRealityTeleportSystem).IsAssignableFrom(type) \|\|`
	`1032`	`+ typeof(IMixedRealityBoundarySystem).IsAssignableFrom(type) \|\|`
	`1033`	`+ typeof(IMixedRealityDiagnosticsSystem).IsAssignableFrom(type);`
`1031`	`1034`	`}`
`1032`	`1035`
`1033`	`1036`	`/// <summary>`