Ported updated build tools form xrtk

Author: StephenHodgson

Assets/MixedRealityToolkit/Extensions/ProcessExtensions.cs

@@ -2,11 +2,12 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 #if UNITY_EDITOR || !UNITY_WSA
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities;
-using Debug = UnityEngine.Debug;
 
 namespace Microsoft.MixedReality.Toolkit.Core.Extensions
 {
@@ -22,8 +23,9 @@ public static class ProcessExtensions
         /// <param name="fileName">The process executable to run.</param>
         /// <param name="args">The Process arguments.</param>
         /// <param name="showDebug">Should output debug code to Editor Console?</param>
+        /// <param name="cancellationToken"></param>
         /// <returns><see cref="Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities.ProcessResult"/></returns>
-        public static async Task<ProcessResult> StartProcessAsync(this Process process, string fileName, string args, bool showDebug = false)
+        public static async Task<ProcessResult> StartProcessAsync(this Process process, string fileName, string args, bool showDebug = false, CancellationToken cancellationToken = default)
         {
             return await StartProcessAsync(process, new ProcessStartInfo
             {
@@ -33,7 +35,7 @@ public static async Task<ProcessResult> StartProcessAsync(this Process process,
                 RedirectStandardOutput = true,
                 RedirectStandardError = true,
                 Arguments = args
-            }, showDebug);
+            }, showDebug, cancellationToken);
         }
 
         /// <summary>
@@ -43,8 +45,9 @@ public static async Task<ProcessResult> StartProcessAsync(this Process process,
         /// <param name="process">This Process.</param>
         /// <param name="startInfo">The Process start info.</param>
         /// <param name="showDebug">Should output debug code to Editor Console?</param>
+        /// <param name="cancellationToken"></param>
         /// <returns><see cref="Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities.ProcessResult"/></returns>
-        public static async Task<ProcessResult> StartProcessAsync(this Process process, ProcessStartInfo startInfo, bool showDebug = false)
+        public static async Task<ProcessResult> StartProcessAsync(this Process process, ProcessStartInfo startInfo, bool showDebug = false, CancellationToken cancellationToken = default)
         {
             Debug.Assert(!startInfo.UseShellExecute, "Process Start Info must not use shell execution.");
             Debug.Assert(startInfo.RedirectStandardOutput, "Process Start Info must redirect standard output.");
@@ -59,51 +62,91 @@ public static async Task<ProcessResult> StartProcessAsync(this Process process,
             var outputCodeResult = new TaskCompletionSource<string[]>();
             var outputList = new List<string>();
 
-            process.Exited += async (sender, args) =>
+            process.Exited += OnProcessExited;
+            process.ErrorDataReceived += OnErrorDataReceived;
+            process.OutputDataReceived += OnOutputDataReceived;
+
+            async void OnProcessExited(object sender, EventArgs args)
             {
                 processResult.TrySetResult(new ProcessResult(process.ExitCode, await errorCodeResult.Task, await outputCodeResult.Task));
                 process.Close();
                 process.Dispose();
-            };
+            }
 
-            process.ErrorDataReceived += (sender, args) =>
+            void OnErrorDataReceived(object sender, DataReceivedEventArgs args)
             {
-                if (!string.IsNullOrEmpty(args.Data))
+                if (args.Data != null)
                 {
                     errorList.Add(args.Data);
-                    if (showDebug) { Debug.LogError(args.Data); }
+
+                    if (!showDebug)
+                    {
+                        return;
+                    }
+
+                    UnityEngine.Debug.LogError(args.Data);
                 }
                 else
                 {
                     errorCodeResult.TrySetResult(errorList.ToArray());
                 }
-            };
+            }
 
-            process.OutputDataReceived += (sender, args) =>
+            void OnOutputDataReceived(object sender, DataReceivedEventArgs args)
             {
-                if (!string.IsNullOrEmpty(args.Data))
+                if (args.Data != null)
                 {
                     outputList.Add(args.Data);
-                    if (showDebug) { Debug.Log(args.Data); }
+
+                    if (!showDebug)
+                    {
+                        return;
+                    }
+
+                    UnityEngine.Debug.Log(args.Data);
                 }
                 else
                 {
                     outputCodeResult.TrySetResult(outputList.ToArray());
                 }
-            };
+            }
 
             if (!process.Start())
             {
                 if (showDebug)
                 {
-                    Debug.LogError("Failed to start process!");
+                    UnityEngine.Debug.LogError("Failed to start process!");
                 }
 
                 processResult.TrySetResult(new ProcessResult(process.ExitCode, new[] { "Failed to start process!" }, null));
             }
+            else
+            {
+                process.BeginOutputReadLine();
+                process.BeginErrorReadLine();
+                CancellationWatcher(process);
+            }
 
-            process.BeginOutputReadLine();
-            process.BeginErrorReadLine();
+            async void CancellationWatcher(Process _process)
+            {
+                await Task.Run(() =>
+                {
+                    try
+                    {
+                        while (!_process.HasExited)
+                        {
+                            if (cancellationToken.IsCancellationRequested)
+                            {
+                                _process.Kill();
+                            }
+                        }
+                    }
+                    catch
+                    {
+                        // ignored
+                    }
+                });
+            }
 
             return await processResult.Task;
         }

Assets/MixedRealityToolkit/Inspectors/MixedRealityPreferences.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
+using System.Collections.Generic;
 using Microsoft.MixedReality.Toolkit.Core.Utilities.Editor;
 using UnityEditor;
 using UnityEngine;
@@ -11,8 +12,8 @@ internal static class MixedRealityPreferences
     {
         #region Lock Profile Preferences
 
-        private static readonly GUIContent LockContent = new GUIContent("Lock SDK Profiles", "Locks the SDK profiles from being edited.\n\nThis setting only applies to the currently running project.");
-        private const string LockKey = "_LockProfiles";
+        private static readonly GUIContent LockContent = new GUIContent("Lock SDK profiles", "Locks the SDK profiles from being edited.\n\nThis setting only applies to the currently running project.");
+        private const string LOCK_KEY = "LockProfiles";
         private static bool lockPrefLoaded;
         private static bool lockProfiles;
 
@@ -25,24 +26,21 @@ public static bool LockProfiles
             {
                 if (!lockPrefLoaded)
                 {
-                    lockProfiles = EditorPrefsUtility.GetEditorPref(LockKey, true);
+                    lockProfiles = EditorPreferences.Get(LOCK_KEY, true);
                     lockPrefLoaded = true;
                 }
 
                 return lockProfiles;
             }
-            set
-            {
-                EditorPrefsUtility.SetEditorPref(LockKey, lockProfiles = value);
-            }
+            set => EditorPreferences.Set(LOCK_KEY, lockProfiles = value);
         }
 
         #endregion Lock Profile Preferences
 
         #region Ignore startup settings prompt
 
-        private static readonly GUIContent IgnoreContent = new GUIContent("Ignore Settings Prompt on Startup", "Prevents settings dialog pop-up from showing on startup.\n\nThis setting applies to all projects using MRTK.");
-        private const string IgnoreKey = "_MixedRealityToolkit_Editor_IgnoreSettingsPrompts";
+        private static readonly GUIContent IgnoreContent = new GUIContent("Ignore settings prompt on startup", "Prevents settings dialog popup from showing on startup.\n\nThis setting applies to all projects using MRTK.");
+        private const string IGNORE_KEY = "MixedRealityToolkit_Editor_IgnoreSettingsPrompts";
         private static bool ignorePrefLoaded;
         private static bool ignoreSettingsPrompt;
 
@@ -55,24 +53,21 @@ public static bool IgnoreSettingsPrompt
             {
                 if (!ignorePrefLoaded)
                 {
-                    ignoreSettingsPrompt = EditorPrefs.GetBool(IgnoreKey, false);
+                    ignoreSettingsPrompt = EditorPrefs.GetBool(IGNORE_KEY, false);
                     ignorePrefLoaded = true;
                 }
 
                 return ignoreSettingsPrompt;
             }
-            set
-            {
-                EditorPrefs.SetBool(IgnoreKey, ignoreSettingsPrompt = value);
-            }
+            set => EditorPrefs.SetBool(IGNORE_KEY, ignoreSettingsPrompt = value);
         }
 
         #endregion Ignore startup settings prompt
 
         #region Show Canvas Utility Prompt
 
-        private static readonly GUIContent CanvasUtilityContent = new GUIContent("Canvas World Space utility dialogs", "Enable or disable the dialog pop-ups for the world space canvas settings.\n\nThis setting only applies to the currently running project.");
-        private const string CanvasKey = "_EnableCanvasUtilityDialog";
+        private static readonly GUIContent CanvasUtilityContent = new GUIContent("Canvas world space utility dialogs", "Enable or disable the dialog popups for the world space canvas settings.\n\nThis setting only applies to the currently running project.");
+        private const string CANVAS_KEY = "EnableCanvasUtilityDialog";
         private static bool isCanvasUtilityPrefLoaded;
         private static bool showCanvasUtilityPrompt;
 
@@ -85,58 +80,82 @@ public static bool ShowCanvasUtilityPrompt
             {
                 if (!isCanvasUtilityPrefLoaded)
                 {
-                    showCanvasUtilityPrompt = EditorPrefsUtility.GetEditorPref("_EnableCanvasUtilityDialog", true);
+                    showCanvasUtilityPrompt = EditorPreferences.Get(CANVAS_KEY, true);
                     isCanvasUtilityPrefLoaded = true;
                 }
 
                 return showCanvasUtilityPrompt;
             }
-            set
-            {
-                EditorPrefsUtility.SetEditorPref(CanvasKey, showCanvasUtilityPrompt = value);
-            }
+            set => EditorPreferences.Set(CANVAS_KEY, showCanvasUtilityPrompt = value);
         }
 
         #endregion Show Canvas Utility Prompt
 
-        [PreferenceItem("Mixed Reality Toolkit")]
-        private static void Preferences()
+        [SettingsProvider]
+        private static SettingsProvider Preferences()
         {
-            EditorGUI.BeginChangeCheck();
-            lockProfiles = EditorGUILayout.Toggle(LockContent, LockProfiles);
-
-            // Save the preference
-            if (EditorGUI.EndChangeCheck())
+            var provider = new SettingsProvider("Project/MRTK")
             {
-                LockProfiles = lockProfiles;
-            }
+                label = "MRTK",
 
-            if (!LockProfiles)
-            {
-                EditorGUILayout.HelpBox("This is only to be used to update the default SDK profiles. If any edits are made, and not checked into the MRTK's GitHub, the changes may be lost next time you update your local copy.", MessageType.Warning);
-            }
+                guiHandler = GUIHandler,
 
-            EditorGUI.BeginChangeCheck();
-            ignoreSettingsPrompt = EditorGUILayout.Toggle(IgnoreContent, IgnoreSettingsPrompt);
+                keywords = new HashSet<string>(new[] { "Mixed", "Reality", "Toolkit" })
+            };
 
-            // Save the preference
-            if (EditorGUI.EndChangeCheck())
+            void GUIHandler(string searchContext)
             {
-                IgnoreSettingsPrompt = ignoreSettingsPrompt;
-            }
+                var prevLabelWidth = EditorGUIUtility.labelWidth;
+                EditorGUIUtility.labelWidth = 200f;
 
-            EditorGUI.BeginChangeCheck();
-            showCanvasUtilityPrompt = EditorGUILayout.Toggle(CanvasUtilityContent, ShowCanvasUtilityPrompt);
+                EditorGUI.BeginChangeCheck();
+                lockProfiles = EditorGUILayout.Toggle(LockContent, LockProfiles);
 
-            if (EditorGUI.EndChangeCheck())
-            {
-                ShowCanvasUtilityPrompt = showCanvasUtilityPrompt;
-            }
+                // Save the preference
+                if (EditorGUI.EndChangeCheck())
+                {
+                    LockProfiles = lockProfiles;
+                }
 
-            if (!ShowCanvasUtilityPrompt)
-            {
-                EditorGUILayout.HelpBox("Be aware that if a Canvas needs to receive input events it is required to have the CanvasUtility attached or the Focus Provider's UIRaycast Camera assigned to the canvas' camera reference.", MessageType.Warning);
+                if (!LockProfiles)
+                {
+                    EditorGUILayout.HelpBox("This is only to be used to update the default SDK profiles. If any edits are made, and not checked into the MRTK's Github, the changes may be lost next time you update your local copy.", MessageType.Warning);
+                }
+
+                EditorGUI.BeginChangeCheck();
+                ignoreSettingsPrompt = EditorGUILayout.Toggle(IgnoreContent, IgnoreSettingsPrompt);
+
+                // Save the preference
+                if (EditorGUI.EndChangeCheck())
+                {
+                    IgnoreSettingsPrompt = ignoreSettingsPrompt;
+                }
+
+                EditorGUI.BeginChangeCheck();
+                showCanvasUtilityPrompt = EditorGUILayout.Toggle(CanvasUtilityContent, ShowCanvasUtilityPrompt);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    ShowCanvasUtilityPrompt = showCanvasUtilityPrompt;
+                }
+
+                if (!ShowCanvasUtilityPrompt)
+                {
+                    EditorGUILayout.HelpBox("Be aware that if a Canvas needs to receive input events it is required to have the CanvasUtility attached or the Focus Provider's UIRaycast Camera assigned to the canvas' camera reference.", MessageType.Warning);
+                }
+
+                EditorGUI.BeginChangeCheck();
+                var scriptLock = EditorGUILayout.Toggle("Is Script Reloading locked?", EditorAssemblyReloadManager.LockReloadAssemblies);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    EditorAssemblyReloadManager.LockReloadAssemblies = scriptLock;
+                }
+
+                EditorGUIUtility.labelWidth = prevLabelWidth;
             }
+
+            return provider;
         }
     }
 }