Merge pull request #3488 from davidkline-ms/disposePattern

update dispose pattern implementation, spatial mesh observer now uses dispose

Author: David Kline

Assets/MixedRealityToolkit.Providers/WindowsMixedReality/WindowsMixedRealitySpatialMeshObserver.cs

@@ -69,26 +69,24 @@ private void ReadProfile()
 
         #region IMixedRealityToolkit implementation
 
+#if UNITY_WSA
+
         /// <inheritdoc />
         public override void Initialize()
         {
             // Only initialize if the Spatial Awareness system has been enabled in the configuration profile.
             if (!MixedRealityToolkit.Instance.ActiveProfile.IsSpatialAwarenessSystemEnabled) { return; }
 
-#if UNITY_WSA
             CreateObserver();
 
             // Apply the initial observer volume settings.
             ConfigureObserverVolume();
-#endif // UNITY_WSA
         }
 
         /// <inheritdoc />
         public override void Reset()
         {
-#if UNITY_WSA
             CleanupObserver();
-#endif // UNITY_WSA
             Initialize();
         }
 
@@ -101,9 +99,7 @@ public override void Enable()
         /// <inheritdoc />
         public override void Update()
         {
-#if UNITY_WSA
             UpdateObserver();
-#endif // UNITY_WSA
         }
 
         /// <inheritdoc />
@@ -115,11 +111,11 @@ public override void Disable()
         /// <inheritdoc />
         public override void Destroy()
         {
-#if UNITY_WSA
             CleanupObserver();
-#endif // UNITY_WSA
         }
 
+#endif // UNITY_WSA
+
         #endregion IMixedRealityToolkit implementation
 
         #region IMixedRealitySpatialAwarenessObserver implementation
@@ -140,6 +136,28 @@ public override void Destroy()
         private IMixedRealitySpatialAwarenessSystem SpatialAwarenessSystem => spatialAwarenessSystem ?? (spatialAwarenessSystem = MixedRealityToolkit.SpatialAwarenessSystem);
 
 #if UNITY_WSA
+        /// <inheritdoc />
+        protected override void Dispose(bool disposing)
+        {
+            if (disposed) { return; }
+
+            base.Dispose(disposing);
+
+            if (IsRunning)
+            {
+                Suspend();
+            }
+
+            if (disposing)
+            {
+                CleanupObservedObjects();
+            }
+
+            DisposeObserver();
+
+            disposed = true;
+        }
+
         /// <summary>
         /// The surface observer providing the spatial data.
         /// </summary>
@@ -292,24 +310,23 @@ private void CreateObserver()
         /// </summary>
         private void CleanupObserver()
         {
-            if (observer != null)
-            {
-                if (IsRunning)
-                {
-                    Suspend();
-                }
-                observer.Dispose();
-                observer = null;
-            }
+            // Destroys all observed objects and the observer.
+            Dispose(true);
+        }
 
+        /// <summary>
+        /// Cleans up the objects created during observation.
+        /// </summary>
+        private void CleanupObservedObjects()
+        {
             if (Application.isPlaying)
             {
                 // Cleanup the scene objects are managing
                 if (observedObjectParent != null)
                 {
                     observedObjectParent.transform.DetachChildren();
                 }
-                
+
                 foreach (SpatialAwarenessMeshObject meshObject in meshes.Values)
                 {
                     if (meshObject != null)
@@ -338,6 +355,18 @@ private void CleanupObserver()
             }
         }
 
+        /// <summary>
+        /// Implements proper cleanup of the SurfaceObserver.
+        /// </summary>
+        private void DisposeObserver()
+        {
+            if (observer != null)
+            {
+                observer.Dispose();
+                observer = null;
+            }
+        }
+
         /// <summary>
         /// Requests updates from the surface observer.
         /// </summary>

Assets/MixedRealityToolkit/Services/BaseService.cs

@@ -40,23 +40,42 @@ public virtual void Destroy() { }
 
         #region IDisposable Implementation
 
-        private bool disposed;
-
+        /// <summary>
+        /// Value indicating if the object has completed disposal.
+        /// </summary>
+        /// <remarks>
+        /// Set by derived classes to indicate that disposal has been completed.
+        /// </remarks>
+        protected bool disposed = false;
+
+        /// <summary>
+        /// Finalizer
+        /// </summary>
         ~BaseService()
         {
-            OnDispose(true);
+            Dispose();
         }
 
+        /// <summary>
+        /// Cleanup resources used by this object.
+        /// </summary>
         public void Dispose()
         {
-            if (disposed) { return; }
-            disposed = true;
+            // Clean up our resources (managed and unmanaged resources)
+            Dispose(true);
+
+            // Suppress finalization as the  the finalizer also calls our cleanup code.
             GC.SuppressFinalize(this);
-            OnDispose(false);
         }
 
-        protected virtual void OnDispose(bool finalizing) { }
-
+        /// <summary>
+        /// Cleanup resources used by the object
+        /// </summary>
+        /// <param name="disposing">Are we fully disposing the object? 
+        /// True will release all managed resources, unmanaged resources are always released.
+        /// </param>
+        protected virtual void Dispose(bool disposing) { }
+    
         #endregion IDisposable Implementation
     }
 }