Dictation update

Author: Stephen Hodgson

Assets/HoloToolkit/Input/Scripts/InputEvents/DictationEventData.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace HoloToolkit.Unity.InputModule
+{
+    public class DictationEventData : InputEventData
+    {
+        /// <summary>
+        /// String result of the current dictation.
+        /// </summary>
+        public string DictationResult { get; private set; }
+        /// <summary>
+        /// Audio Clip of the last Dictation recording Session.
+        /// </summary>
+        public AudioClip DictationAudioClip { get; private set; }
+
+        public DictationEventData(EventSystem eventSystem) : base(eventSystem) { }
+
+        public void Initialize(IInputSource inputSource, uint sourceId, string dictationResult, AudioClip dictationAudioClip = null)
+        {
+            BaseInitialize(inputSource, sourceId);
+            DictationResult = dictationResult;
+            DictationAudioClip = dictationAudioClip;
+        }
+    }
+}

Assets/HoloToolkit/Input/Scripts/InputEvents/DictationEventData.cs.meta

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine.EventSystems;
+
+namespace HoloToolkit.Unity.InputModule
+{
+    /// <summary>
+    /// Interface to implement dictation events.
+    /// </summary>
+    public interface IDictationHandler : IEventSystemHandler
+    {
+        void OnDictationHypothesis(DictationEventData eventData);
+
+        void OnDictationResult(DictationEventData eventData);
+
+        void OnDictationComplete(DictationEventData eventData);
+
+        void OnDictationError(DictationEventData eventData);
+    }
+}

Assets/HoloToolkit/Input/Scripts/InputEvents/IDictationHandler.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using System;
-using UnityEngine;
 using UnityEngine.EventSystems;
 using UnityEngine.Windows.Speech;
 
@@ -38,9 +37,7 @@ public class SpeechKeywordRecognizedEventData : InputEventData
         /// </summary>
         public string RecognizedText { get; private set; }
 
-        public SpeechKeywordRecognizedEventData(EventSystem eventSystem) : base(eventSystem)
-        {
-        }
+        public SpeechKeywordRecognizedEventData(EventSystem eventSystem) : base(eventSystem) { }
 
         public void Initialize(IInputSource inputSource, uint sourceId, ConfidenceLevel confidence, TimeSpan phraseDuration, DateTime phraseStartTime, SemanticMeaning[] semanticMeanings, string recognizedText)
         {

Assets/HoloToolkit/Input/Scripts/InputEvents/IDictationHandler.cs.meta

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.EventSystems;
+using UnityEngine.Windows.Speech;
 
 namespace HoloToolkit.Unity.InputModule
 {
@@ -41,6 +42,8 @@ public class InputManager : Singleton<InputManager>
         private ManipulationEventData manipulationEventData;
         private HoldEventData holdEventData;
         private NavigationEventData navigationEventData;
+        private SpeechKeywordRecognizedEventData speechKeywordRecognizedEventData;
+        private DictationEventData dictationEventData;
 
         /// <summary>
         /// Indicates if input is currently enabled or not.
@@ -170,18 +173,6 @@ public void ClearInputDisableStack()
             }
         }
 
-        private void Start()
-        {
-            InitializeEventDatas();
-
-            if (GazeManager.Instance == null)
-            {
-                Debug.LogError("InputManager requires an active GazeManager in the scene");
-            }
-
-            RegisterGazeManager();
-        }
-
         private void InitializeEventDatas()
         {
             inputEventData = new InputEventData(EventSystem.current);
@@ -190,11 +181,22 @@ private void InitializeEventDatas()
             manipulationEventData = new ManipulationEventData(EventSystem.current);
             navigationEventData = new NavigationEventData(EventSystem.current);
             holdEventData = new HoldEventData(EventSystem.current);
+            speechKeywordRecognizedEventData = new SpeechKeywordRecognizedEventData(EventSystem.current);
+            dictationEventData = new DictationEventData(EventSystem.current);
         }
 
-        protected override void OnDestroy()
+        #region Unity Methods
+
+        private void Start()
         {
-            UnregisterGazeManager();
+            InitializeEventDatas();
+
+            if (GazeManager.Instance == null)
+            {
+                Debug.LogError("InputManager requires an active GazeManager in the scene");
+            }
+
+            RegisterGazeManager();
         }
 
         private void OnEnable()
@@ -207,10 +209,17 @@ private void OnDisable()
             UnregisterGazeManager();
         }
 
+        protected override void OnDestroy()
+        {
+            UnregisterGazeManager();
+        }
+
+        #endregion // Unity Methods
+
         public void HandleEvent<T>(BaseEventData eventData, ExecuteEvents.EventFunction<T> eventHandler)
             where T : IEventSystemHandler
         {
-            if (!enabled || disabledRefCount > 0)
+            if (!Instance.enabled || disabledRefCount > 0)
             {
                 return;
             }
@@ -439,6 +448,8 @@ public void RaiseSourceLost(IInputSource source, uint sourceId)
             HandleEvent(sourceStateEventData, OnSourceLostEventHandler);
         }
 
+        #region Manipulation Events
+
         private static readonly ExecuteEvents.EventFunction<IManipulationHandler> OnManipulationStartedEventHandler =
             delegate (IManipulationHandler handler, BaseEventData eventData)
             {
@@ -503,6 +514,10 @@ public void RaiseManipulationCanceled(IInputSource source, uint sourceId, Vector
             HandleEvent(manipulationEventData, OnManipulationCanceledEventHandler);
         }
 
+        #endregion // Manipulation Events
+
+        #region Hold Events
+
         private static readonly ExecuteEvents.EventFunction<IHoldHandler> OnHoldStartedEventHandler =
             delegate (IHoldHandler handler, BaseEventData eventData)
             {
@@ -551,6 +566,10 @@ public void RaiseHoldCanceled(IInputSource source, uint sourceId)
             HandleEvent(holdEventData, OnHoldCanceledEventHandler);
         }
 
+        #endregion // Hold Events
+
+        #region Navigation Events
+
         private static readonly ExecuteEvents.EventFunction<INavigationHandler> OnNavigationStartedEventHandler =
             delegate (INavigationHandler handler, BaseEventData eventData)
             {
@@ -615,5 +634,97 @@ public void RaiseNavigationCanceled(IInputSource source, uint sourceId, Vector3
             HandleEvent(navigationEventData, OnNavigationCanceledEventHandler);
         }
 
+        #endregion // Navigation Events
+
+        #region Speech Events
+
+
+        private static readonly ExecuteEvents.EventFunction<ISpeechHandler> OnSpeechKeywordRecognizedEventHandler =
+            delegate (ISpeechHandler handler, BaseEventData eventData)
+            {
+                SpeechKeywordRecognizedEventData casted = ExecuteEvents.ValidateEventData<SpeechKeywordRecognizedEventData>(eventData);
+                handler.OnSpeechKeywordRecognized(casted);
+            };
+
+
+        public void RaiseSpeechKeywordPhraseRecognized(IInputSource source, uint sourceId, ConfidenceLevel confidence, TimeSpan phraseDuration, DateTime phraseStartTime, SemanticMeaning[] semanticMeanings, string text)
+        {
+            // Create input event
+            speechKeywordRecognizedEventData.Initialize(source, sourceId, confidence, phraseDuration, phraseStartTime, semanticMeanings, text);
+
+            // Pass handler through HandleEvent to perform modal/fallback logic
+            HandleEvent(speechKeywordRecognizedEventData, OnSpeechKeywordRecognizedEventHandler);
+        }
+
+        private static readonly ExecuteEvents.EventFunction<IDictationHandler> OnDictationHypothesisEventHandler =
+            delegate (IDictationHandler handler, BaseEventData eventData)
+            {
+                DictationEventData casted = ExecuteEvents.ValidateEventData<DictationEventData>(eventData);
+                handler.OnDictationHypothesis(casted);
+            };
+
+        #endregion // Speech Events
+
+        #region Dictation Events
+
+        public void RaiseDictationHypothesis(IInputSource source, uint sourceId, string dictationHypothesis, AudioClip dictationAudioClip = null)
+        {
+            // Create input event
+            dictationEventData.Initialize(source, sourceId, dictationHypothesis, dictationAudioClip);
+
+            // Pass handler through HandleEvent to perform modal/fallback logic
+            HandleEvent(dictationEventData, OnDictationHypothesisEventHandler);
+        }
+
+        private static readonly ExecuteEvents.EventFunction<IDictationHandler> OnDictationResultEventHandler =
+            delegate (IDictationHandler handler, BaseEventData eventData)
+            {
+                DictationEventData casted = ExecuteEvents.ValidateEventData<DictationEventData>(eventData);
+                handler.OnDictationResult(casted);
+            };
+
+        public void RaiseDictationResult(IInputSource source, uint sourceId, string dictationResult, AudioClip dictationAudioClip = null)
+        {
+            // Create input event
+            dictationEventData.Initialize(source, sourceId, dictationResult, dictationAudioClip);
+
+            // Pass handler through HandleEvent to perform modal/fallback logic
+            HandleEvent(dictationEventData, OnDictationResultEventHandler);
+        }
+
+        private static readonly ExecuteEvents.EventFunction<IDictationHandler> OnDictationCompleteEventHandler =
+            delegate (IDictationHandler handler, BaseEventData eventData)
+            {
+                DictationEventData casted = ExecuteEvents.ValidateEventData<DictationEventData>(eventData);
+                handler.OnDictationComplete(casted);
+            };
+
+        public void RaiseDictationComplete(IInputSource source, uint sourceId, string dictationResult, AudioClip dictationAudioClip)
+        {
+            // Create input event
+            dictationEventData.Initialize(source, sourceId, dictationResult, dictationAudioClip);
+
+            // Pass handler through HandleEvent to perform modal/fallback logic
+            HandleEvent(dictationEventData, OnDictationCompleteEventHandler);
+        }
+
+        private static readonly ExecuteEvents.EventFunction<IDictationHandler> OnDictationErrorEventHandler =
+            delegate (IDictationHandler handler, BaseEventData eventData)
+            {
+                DictationEventData casted = ExecuteEvents.ValidateEventData<DictationEventData>(eventData);
+                handler.OnDictationComplete(casted);
+            };
+
+        public void RaiseDictationError(IInputSource source, uint sourceId, string dictationResult, AudioClip dictationAudioClip = null)
+        {
+            // Create input event
+            dictationEventData.Initialize(source, sourceId, dictationResult, dictationAudioClip);
+
+            // Pass handler through HandleEvent to perform modal/fallback logic
+            HandleEvent(dictationEventData, OnDictationErrorEventHandler);
+        }
+
+        #endregion // Dictation Events
+
     }
 }