Merge branch 'mrtk_development' into vNEXT-Revolution

# Conflicts:
#	Assets/MixedRealityToolkit/_Core/Devices/VoiceInput/WindowsDictationInputDeviceManager.cs
#	Assets/MixedRealityToolkit/_Core/Services/MixedRealityToolkit.cs

Author: StephenHodgson

Assets/MixedRealityToolkit-Examples/Demos/Solvers/Scripts/SwapVolume.cs.meta

@@ -10,47 +10,47 @@ namespace Microsoft.MixedReality.Toolkit.Core.Definitions.InputSystem
     public class MixedRealityInputActionRulesProfile : BaseMixedRealityProfile
     {
         [SerializeField]
-        private InputActionRuleDigital[] inputActionRulesDigital;
+        private InputActionRuleDigital[] inputActionRulesDigital = null;
 
         /// <summary>
         /// All the Input Action Rules for <see cref="bool"/> based <see cref="MixedRealityInputAction"/>s
         /// </summary>
         public InputActionRuleDigital[] InputActionRulesDigital => inputActionRulesDigital;
 
         [SerializeField]
-        private InputActionRuleSingleAxis[] inputActionRulesSingleAxis;
+        private InputActionRuleSingleAxis[] inputActionRulesSingleAxis = null;
 
         /// <summary>
         /// All the Input Action Rules for <see cref="float"/> based <see cref="MixedRealityInputAction"/>s
         /// </summary>
         public InputActionRuleSingleAxis[] InputActionRulesSingleAxis => inputActionRulesSingleAxis;
 
         [SerializeField]
-        private InputActionRuleDualAxis[] inputActionRulesDualAxis;
+        private InputActionRuleDualAxis[] inputActionRulesDualAxis = null;
 
         /// <summary>
         /// All the Input Action Rules for <see cref="Vector2"/> based <see cref="MixedRealityInputAction"/>s
         /// </summary>
         public InputActionRuleDualAxis[] InputActionRulesDualAxis => inputActionRulesDualAxis;
 
         [SerializeField]
-        private InputActionRuleVectorAxis[] inputActionRulesVectorAxis;
+        private InputActionRuleVectorAxis[] inputActionRulesVectorAxis = null;
 
         /// <summary>
         /// All the Input Action Rules for <see cref="Vector3"/> based <see cref="MixedRealityInputAction"/>s
         /// </summary>
         public InputActionRuleVectorAxis[] InputActionRulesVectorAxis => inputActionRulesVectorAxis;
 
         [SerializeField]
-        private InputActionRuleQuaternionAxis[] inputActionRulesQuaternionAxis;
+        private InputActionRuleQuaternionAxis[] inputActionRulesQuaternionAxis = null;
 
         /// <summary>
         /// All the Input Action Rules for <see cref="Quaternion"/> based <see cref="MixedRealityInputAction"/>s
         /// </summary>
         public InputActionRuleQuaternionAxis[] InputActionRulesQuaternionAxis => inputActionRulesQuaternionAxis;
 
         [SerializeField]
-        private InputActionRulePoseAxis[] inputActionRulesPoseAxis;
+        private InputActionRulePoseAxis[] inputActionRulesPoseAxis = null;
 
         /// <summary>
         /// All the Input Action Rules for <see cref="MixedRealityPose"/> based <see cref="MixedRealityInputAction"/>s

Assets/MixedRealityToolkit-SDK/Inspectors/UX/Pointers/MousePointerInspector.cs.meta

@@ -6,7 +6,7 @@
 namespace Microsoft.MixedReality.Toolkit.Core.Definitions.InputSystem
 {
     /// <summary>
-    /// Copy of Unity's XR.WSA.GestureSettings.
+    /// Copy of Unity's <see cref="UnityEngine.XR.WSA.Input.GestureSettings"/>
     /// </summary>
     [Flags]
     public enum WindowsGestureSettings

Assets/MixedRealityToolkit/_Core/Definitions/InputSystem/MixedRealityInputActionRulesProfile.cs

@@ -59,19 +59,7 @@ public SystemType(Type type)
 
         void ISerializationCallbackReceiver.OnAfterDeserialize()
         {
-            if (!string.IsNullOrEmpty(reference))
-            {
-                type = Type.GetType(reference);
-
-                if (type == null)
-                {
-                    Debug.LogWarning($"'{reference}' was referenced but class or struct type was not found.");
-                }
-            }
-            else
-            {
-                type = null;
-            }
+            type = !string.IsNullOrEmpty(reference) ? Type.GetType(reference) : null;
         }
 
         void ISerializationCallbackReceiver.OnBeforeSerialize() { }

Assets/MixedRealityToolkit/_Core/Definitions/InputSystem/WindowsGestureSettings.cs

@@ -3,7 +3,7 @@
 
 using Microsoft.MixedReality.Toolkit.Core.Interfaces.Devices;
 using Microsoft.MixedReality.Toolkit.Core.Interfaces.InputSystem;
-using Microsoft.MixedReality.Toolkit.Core.Services;
+using Microsoft.MixedReality.Toolkit.Core.Managers;
 using Microsoft.MixedReality.Toolkit.Core.Utilities.Async;
 using System.Text;
 using System.Threading.Tasks;
@@ -16,7 +16,7 @@
 namespace Microsoft.MixedReality.Toolkit.Core.Devices.VoiceInput
 {
 #if UNITY_STANDALONE_WIN || UNITY_WSA || UNITY_EDITOR_WIN
-    public class WindowsDictationInputDeviceManager : BaseDeviceManager, IMixedRealityDictationSystem
+    public class WindowsDictationInputDeviceManager : BaseDeviceManager, IMixedRealityDictationManager
     {
         /// <summary>
         /// Constructor.
@@ -59,20 +59,26 @@ public WindowsDictationInputDeviceManager(string name, uint priority) : base(nam
         /// </summary>
         private AudioClip dictationAudioClip;
 
-        private DictationRecognizer dictationRecognizer;
-        
+        private static DictationRecognizer dictationRecognizer;
+
+        private readonly WaitUntil waitUntilPhraseRecognitionSystemHasStarted = new WaitUntil(() => PhraseRecognitionSystem.Status != SpeechSystemStatus.Stopped);
+        private readonly WaitUntil waitUntilPhraseRecognitionSystemHasStopped = new WaitUntil(() => PhraseRecognitionSystem.Status != SpeechSystemStatus.Running);
+
+        private readonly WaitUntil waitUntilDictationRecognizerHasStarted = new WaitUntil(() => dictationRecognizer.Status != SpeechSystemStatus.Stopped);
+        private readonly WaitUntil waitUntilDictationRecognizerHasStopped = new WaitUntil(() => dictationRecognizer.Status != SpeechSystemStatus.Running);
+
         /// <inheritdoc />
         public override void Enable()
         {
             if (!Application.isPlaying) { return; }
 
-            if (MixedRealityToolkit.InputSystem == null)
+            if (MixedRealityManager.InputSystem == null)
             {
                 Debug.LogWarning("Unable to start Windows Dictation Device Manager. An Input System is required for this feature.");
                 return;
             }
 
-            inputSource = MixedRealityToolkit.InputSystem.RequestNewGenericInputSource("Dictation Recognizer");
+            inputSource = MixedRealityManager.InputSystem.RequestNewGenericInputSource("Dictation Recognizer");
             dictationResult = string.Empty;
 
             if (dictationRecognizer == null)
@@ -89,7 +95,7 @@ public override void Enable()
         /// <inheritdoc />
         public override void Update()
         {
-            if (!Application.isPlaying || MixedRealityToolkit.InputSystem == null) { return; }
+            if (!Application.isPlaying || MixedRealityManager.InputSystem == null) { return; }
 
             if (!isTransitioning && IsListening && !Microphone.IsRecording(deviceName) && dictationRecognizer.Status == SpeechSystemStatus.Running)
             {
@@ -100,7 +106,7 @@ public override void Update()
             if (!hasFailed && dictationRecognizer.Status == SpeechSystemStatus.Failed)
             {
                 hasFailed = true;
-                MixedRealityToolkit.InputSystem.RaiseDictationError(inputSource, "Dictation recognizer has failed!");
+                MixedRealityManager.InputSystem.RaiseDictationError(inputSource, "Dictation recognizer has failed!");
             }
         }
 
@@ -135,7 +141,7 @@ public async void StartRecording(GameObject listener, float initialSilenceTimeou
         /// <inheritdoc />
         public async Task StartRecordingAsync(GameObject listener = null, float initialSilenceTimeout = 5f, float autoSilenceTimeout = 20f, int recordingTime = 10, string micDeviceName = "")
         {
-            if (IsListening || isTransitioning || MixedRealityToolkit.InputSystem == null)
+            if (IsListening || isTransitioning || MixedRealityManager.InputSystem == null || !Application.isPlaying)
             {
                 Debug.LogWarning("Unable to start recording");
                 return;
@@ -148,15 +154,16 @@ public async Task StartRecordingAsync(GameObject listener = null, float initialS
             if (listener != null)
             {
                 hasListener = true;
-                MixedRealityToolkit.InputSystem.PushModalInputHandler(listener);
+                MixedRealityManager.InputSystem.PushModalInputHandler(listener);
             }
 
             if (PhraseRecognitionSystem.Status == SpeechSystemStatus.Running)
             {
                 PhraseRecognitionSystem.Shutdown();
             }
 
-            await new WaitUntil(() => PhraseRecognitionSystem.Status != SpeechSystemStatus.Running);
+            await waitUntilPhraseRecognitionSystemHasStopped;
+            Debug.Assert(PhraseRecognitionSystem.Status == SpeechSystemStatus.Stopped);
 
             // Query the maximum frequency of the default microphone.
             int minSamplingRate; // Not used.
@@ -167,11 +174,12 @@ public async Task StartRecordingAsync(GameObject listener = null, float initialS
             dictationRecognizer.AutoSilenceTimeoutSeconds = autoSilenceTimeout;
             dictationRecognizer.Start();
 
-            await new WaitUntil(() => dictationRecognizer.Status != SpeechSystemStatus.Stopped);
+            await waitUntilDictationRecognizerHasStarted;
+            Debug.Assert(dictationRecognizer.Status == SpeechSystemStatus.Running);
 
             if (dictationRecognizer.Status == SpeechSystemStatus.Failed)
             {
-                MixedRealityToolkit.InputSystem.RaiseDictationError(inputSource, "Dictation recognizer failed to start!");
+                MixedRealityManager.InputSystem.RaiseDictationError(inputSource, "Dictation recognizer failed to start!");
                 return;
             }
 
@@ -190,7 +198,7 @@ public async void StopRecording()
         /// <inheritdoc />
         public async Task<AudioClip> StopRecordingAsync()
         {
-            if (!IsListening || isTransitioning)
+            if (!IsListening || isTransitioning || !Application.isPlaying)
             {
                 Debug.LogWarning("Unable to stop recording");
                 return null;
@@ -201,7 +209,7 @@ public async Task<AudioClip> StopRecordingAsync()
 
             if (hasListener)
             {
-                MixedRealityToolkit.InputSystem.PopModalInputHandler();
+                MixedRealityManager.InputSystem.PopModalInputHandler();
                 hasListener = false;
             }
 
@@ -212,11 +220,13 @@ public async Task<AudioClip> StopRecordingAsync()
                 dictationRecognizer.Stop();
             }
 
-            await new WaitUntil(() => dictationRecognizer.Status != SpeechSystemStatus.Running);
+            await waitUntilDictationRecognizerHasStopped;
+            Debug.Assert(dictationRecognizer.Status == SpeechSystemStatus.Stopped);
 
             PhraseRecognitionSystem.Restart();
 
-            await new WaitUntil(() => PhraseRecognitionSystem.Status == SpeechSystemStatus.Running);
+            await waitUntilPhraseRecognitionSystemHasStarted;
+            Debug.Assert(PhraseRecognitionSystem.Status == SpeechSystemStatus.Running);
 
             isTransitioning = false;
             return dictationAudioClip;
@@ -231,7 +241,7 @@ private void DictationRecognizer_DictationHypothesis(string text)
             // We don't want to append to textSoFar yet, because the hypothesis may have changed on the next event.
             dictationResult = $"{textSoFar} {text}...";
 
-            MixedRealityToolkit.InputSystem.RaiseDictationHypothesis(inputSource, dictationResult);
+            MixedRealityManager.InputSystem.RaiseDictationHypothesis(inputSource, dictationResult);
         }
 
         /// <summary>
@@ -245,7 +255,7 @@ private void DictationRecognizer_DictationResult(string text, ConfidenceLevel co
 
             dictationResult = textSoFar.ToString();
 
-            MixedRealityToolkit.InputSystem.RaiseDictationResult(inputSource, dictationResult);
+            MixedRealityManager.InputSystem.RaiseDictationResult(inputSource, dictationResult);
         }
 
         /// <summary>
@@ -263,7 +273,7 @@ private void DictationRecognizer_DictationComplete(DictationCompletionCause caus
                 dictationResult = "Dictation has timed out. Please try again.";
             }
 
-            MixedRealityToolkit.InputSystem.RaiseDictationComplete(inputSource, dictationResult, dictationAudioClip);
+            MixedRealityManager.InputSystem.RaiseDictationComplete(inputSource, dictationResult, dictationAudioClip);
             textSoFar = null;
             dictationResult = string.Empty;
         }
@@ -277,7 +287,7 @@ private void DictationRecognizer_DictationError(string error, int hresult)
         {
             dictationResult = $"{error}\nHRESULT: {hresult}";
 
-            MixedRealityToolkit.InputSystem.RaiseDictationError(inputSource, dictationResult);
+            MixedRealityManager.InputSystem.RaiseDictationError(inputSource, dictationResult);
             textSoFar = null;
             dictationResult = string.Empty;
         }