Cherry-picking global input source for speech for 2.7 (#9892)

* Introduced the concept of a global input source and enabled it with speech (#9770)

* introduced the concept of a global input source and made the speech provider use a global input source

* Update Assets/MRTK/Providers/Windows/WindowsSpeechInputProvider.cs

Co-authored-by: Kurtis <[email protected]>

* Update Assets/MRTK/Core/Providers/BaseGlobalInputSource.cs

Co-authored-by: Kurtis <[email protected]>

* removed redundant code, undid public signature changes

* added unit tests for the global input source

* added test case where the focus listener uses the events after recieving them

Co-authored-by: Kurtis <[email protected]>

* initialize global input source variable (#9889)

Co-authored-by: Kurtis <[email protected]>

Author: RogPodge

Assets/MRTK/Core/Interfaces/InputSystem/IMixedRealityInputSystem.cs

@@ -132,6 +132,8 @@ public interface IMixedRealityInputSystem : IMixedRealityEventSystem
 
         IMixedRealityInputSource RequestNewGenericInputSource(string name, IMixedRealityPointer[] pointers = null, InputSourceType sourceType = InputSourceType.Other);
 
+        BaseGlobalInputSource RequestNewGlobalInputSource(string name, IMixedRealityFocusProvider focusProvider = null, InputSourceType sourceType = InputSourceType.Other);
+
         /// <summary>
         /// Raise the event that the Input Source was detected.
         /// </summary>

Assets/MRTK/Core/Interfaces/InputSystem/IMixedRealityPointer.cs

@@ -48,7 +48,7 @@ public interface IMixedRealityPointer : IEqualityComparer
         bool IsInteractionEnabled { get; }
 
         /// <summary>
-        /// Controls whether the pointer dispatches input..
+        /// Controls whether the pointer dispatches input.
         /// </summary>
         bool IsActive { get; set; }
 

Assets/MRTK/Core/Providers/BaseGlobalInputSource.cs

@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections;
+using System.Linq;
+
+namespace Microsoft.MixedReality.Toolkit.Input
+{
+    /// <summary>
+    /// Base class for input sources whose pointers are all active pointers in the scene.
+    /// </summary>
+    /// <remarks>
+    /// <para>This base class is intended to represent input sources which raise events to all active pointers found by the FocusProvider in a scene.</para>
+    /// </remarks>
+    public class BaseGlobalInputSource : IMixedRealityInputSource, IDisposable
+    {
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        public BaseGlobalInputSource(string name, IMixedRealityFocusProvider focusProvider, InputSourceType sourceType = InputSourceType.Other)
+        {
+            SourceId = (CoreServices.InputSystem != null) ? CoreServices.InputSystem.GenerateNewSourceId() : 0;
+            SourceName = name;
+            FocusProvider = focusProvider;
+            SourceType = sourceType;
+
+            UpdateActivePointers();
+        }
+
+        /// <inheritdoc />
+        public uint SourceId { get; }
+
+        /// <inheritdoc />
+        public string SourceName { get; }
+
+        /// <inheritdoc />
+        public virtual IMixedRealityPointer[] Pointers { get; set; }
+
+        /// <inheritdoc />
+        public InputSourceType SourceType { get; set; }
+
+        private IMixedRealityFocusProvider FocusProvider;
+
+        public void UpdateActivePointers()
+        {
+            Pointers = FocusProvider.GetPointers<IMixedRealityPointer>().Where(x => x.IsActive).ToArray();
+        }
+
+        #region IEquality Implementation
+
+        public static bool Equals(IMixedRealityInputSource left, IMixedRealityInputSource right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <inheritdoc />
+        bool IEqualityComparer.Equals(object left, object right)
+        {
+            return left.Equals(right);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) { return false; }
+            if (ReferenceEquals(this, obj)) { return true; }
+            if (obj.GetType() != GetType()) { return false; }
+
+            return Equals((IMixedRealityInputSource)obj);
+        }
+
+        private bool Equals(IMixedRealityInputSource other)
+        {
+            return other != null && SourceId == other.SourceId && string.Equals(SourceName, other.SourceName);
+        }
+
+        /// <inheritdoc />
+        int IEqualityComparer.GetHashCode(object obj)
+        {
+            return obj.GetHashCode();
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = 0;
+                hashCode = (hashCode * 397) ^ (int)SourceId;
+                hashCode = (hashCode * 397) ^ (SourceName != null ? SourceName.GetHashCode() : 0);
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// Dispose.
+        /// </summary>
+        public virtual void Dispose() { }
+
+        #endregion IEquality Implementation
+    }
+}

Assets/MRTK/Core/Providers/BaseGlobalInputSource.cs.meta

@@ -61,13 +61,18 @@ public WindowsSpeechInputProvider(
         /// <summary>
         /// The Input Source for Windows Speech Input.
         /// </summary>
-        public IMixedRealityInputSource InputSource = null;
+        public IMixedRealityInputSource InputSource => globalInputSource;
 
         /// <summary>
         /// The minimum confidence level for the recognizer to fire an event.
         /// </summary>
         public RecognitionConfidenceLevel RecognitionConfidenceLevel { get; set; }
 
+        /// <summary>
+        /// The global input source used by the the speech input provider to raise events.
+        /// </summary>
+        private BaseGlobalInputSource globalInputSource = null;
+
         /// <inheritdoc />
         public bool IsRecognitionActive =>
 #if UNITY_STANDALONE_WIN || UNITY_WSA || UNITY_EDITOR_WIN
@@ -152,7 +157,7 @@ private void InitializeKeywordRecognizer()
                 return;
             }
 
-            InputSource = Service?.RequestNewGenericInputSource("Windows Speech Input Source", sourceType: InputSourceType.Voice);
+            globalInputSource = Service?.RequestNewGlobalInputSource("Windows Speech Input Source", sourceType: InputSourceType.Voice);
 
             var newKeywords = new string[Commands.Length];
 
@@ -243,6 +248,8 @@ private void OnPhraseRecognized(ConfidenceLevel confidence, TimeSpan phraseDurat
                 {
                     if (Commands[i].LocalizedKeyword == text)
                     {
+                        globalInputSource.UpdateActivePointers();
+
                         Service?.RaiseSpeechCommandRecognized(InputSource, (RecognitionConfidenceLevel)confidence, phraseDuration, phraseStartTime, Commands[i]);
                         break;
                     }

Assets/MRTK/Providers/Windows/WindowsSpeechInputProvider.cs

@@ -874,6 +874,14 @@ public IMixedRealityInputSource RequestNewGenericInputSource(string name, IMixed
             return new BaseGenericInputSource(name, pointers, sourceType);
         }
 
+        /// <inheritdoc />
+        public BaseGlobalInputSource RequestNewGlobalInputSource(string name, IMixedRealityFocusProvider focusProvider = null, InputSourceType sourceType = InputSourceType.Other)
+        {
+            var inputSourceFocusProvider = focusProvider.IsNull() ? FocusProvider : focusProvider;
+            return new BaseGlobalInputSource(name, inputSourceFocusProvider, sourceType);
+        }
+
+
         #region Input Source State Events
 
         private static readonly ProfilerMarker RaiseSourceDetectedPerfMarker = new ProfilerMarker("[MRTK] MixedRealityInputSystem.RaiseSourceDetected");

Assets/MRTK/Services/InputSystem/MixedRealityInputSystem.cs

@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.MixedReality.Toolkit.Input;
+using Microsoft.MixedReality.Toolkit.Utilities;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.Tests
+{
+    // For InputSystemGlobalListener
+#pragma warning disable 0618
+    [AddComponentMenu("Scripts/MRTK/Tests/TestInputFocusListener")]
+    internal class TestInputFocusListener : MonoBehaviour, IMixedRealityFocusHandler, IMixedRealityPointerHandler, IMixedRealitySpeechHandler
+    {
+        // Parameters, which are set by child classes
+        public bool useEventDataOnReception = false;
+
+        // Values changed by class to validate event receiving
+        public int pointerDownCount = 0;
+        public int pointerDraggedCount = 0;
+        public int pointerUpCount = 0;
+        public int pointerClickedCount = 0;
+
+        public int focusGainedCount = 0;
+        public int focusLostCount = 0;
+        public List<string> speechCommandsReceived = new List<string>();
+
+        protected void Start()
+        {
+            pointerDownCount = 0;
+            pointerDraggedCount = 0;
+            pointerUpCount = 0;
+            pointerClickedCount = 0;
+
+            focusGainedCount = 0;
+            focusLostCount = 0;
+            speechCommandsReceived = new List<string>();
+        }
+
+        public void OnPointerDown(MixedRealityPointerEventData eventData)
+        {
+            pointerDownCount++;
+
+            if (useEventDataOnReception)
+            {
+                eventData.Use();
+            }
+        }
+
+        public void OnPointerDragged(MixedRealityPointerEventData eventData)
+        {
+            pointerDraggedCount++;
+
+            if (useEventDataOnReception)
+            {
+                eventData.Use();
+            }
+        }
+
+        public void OnPointerUp(MixedRealityPointerEventData eventData)
+        {
+            pointerUpCount++;
+
+            if (useEventDataOnReception)
+            {
+                eventData.Use();
+            }
+        }
+
+        public virtual void OnPointerClicked(MixedRealityPointerEventData eventData)
+        {
+            pointerClickedCount++;
+
+            if (useEventDataOnReception)
+            {
+                eventData.Use();
+            }
+        }
+
+        public void OnSpeechKeywordRecognized(SpeechEventData eventData)
+        {
+            speechCommandsReceived.Add(eventData.Command.Keyword);
+
+            if(useEventDataOnReception)
+            {
+                eventData.Use();
+            }
+        }
+
+        public void OnFocusEnter(FocusEventData eventData)
+        {
+            focusGainedCount++;
+
+            if (useEventDataOnReception)
+            {
+                eventData.Use();
+            }
+        }
+
+        public void OnFocusExit(FocusEventData eventData)
+        {
+            focusLostCount++;
+
+            if (useEventDataOnReception)
+            {
+                eventData.Use();
+            }
+        }
+    }
+#pragma warning restore 0618
+}