Interactive.cs

Go to the documentation of this file.

// 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.Events;
using System.Collections.Generic;
using HoloToolkit.Unity.InputModule;

#if UNITY_WSA || UNITY_STANDALONE_WIN
using UnityEngine.Windows.Speech;
#endif

namespace HoloToolkit.Examples.InteractiveElements
{
    public class Interactive : MonoBehaviour, IInputClickHandler, IFocusable, IInputHandler
    {

        public GameObject ParentObject;

        public bool IsEnabled = true;

        public bool HasGaze { get; protected set; }

        public bool HasDown { get; protected set; }

        public bool DetectHold = false;

        public float HoldTime = 0.5f;

        public float RollOffTime = 0.02f;

        public bool IsSelected { get; protected set; }

        [Tooltip("Set a keyword to invoke the OnSelect event")]
        public string Keyword = "";

        [Tooltip("Gaze is required for the keyword to trigger this Interactive.")]
        public bool KeywordRequiresGaze = true;

        public UnityEvent OnSelectEvents;
        public UnityEvent OnDownEvent;
        public UnityEvent OnHoldEvent;

        public enum ButtonStateEnum { Default, Focus, Press, Selected, FocusSelected, PressSelected, Disabled, DisabledSelected }
        protected ButtonStateEnum mState = ButtonStateEnum.Default;

        protected float mRollOffTimer = 0;
        protected float mHoldTimer = 0;
        protected bool mCheckRollOff = false;
        protected bool mCheckHold = false;

#if UNITY_WSA || UNITY_STANDALONE_WIN
        protected KeywordRecognizer mKeywordRecognizer;
#endif
        protected Dictionary<string, int> mKeywordDictionary;
        protected string[] mKeywordArray;

        protected bool mIgnoreSelect = false;
        protected bool mCheckEnabled = false;
        protected bool mCheckSelected = false;
        protected bool UserInitiatedEvent = false;
        protected bool mAllowSelection = false;

        protected List<InteractiveWidget> mInteractiveWidgets = new List<InteractiveWidget>();

        protected virtual void Awake()
        {
            if (ParentObject == null)
            {
                ParentObject = this.gameObject;
            }

            CollectWidgets(forceCollection: true);
        }

        protected virtual void Start()
        {
            if (Keyword != "")
            {
                mKeywordArray = new string[1] { Keyword };
                if (Keyword.IndexOf(',') > -1)
                {
                    mKeywordArray = Keyword.Split(',');

                    mKeywordDictionary = new Dictionary<string, int>();
                    for (int i = 0; i < mKeywordArray.Length; ++i)
                    {
                        mKeywordDictionary.Add(mKeywordArray[i], i);
                    }
                }

#if UNITY_WSA || UNITY_STANDALONE_WIN
                if (!KeywordRequiresGaze)
                {
                    mKeywordRecognizer = new KeywordRecognizer(mKeywordArray);
                    mKeywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized;
                    mKeywordRecognizer.Start();
                }
#endif

            }

            mCheckEnabled = IsEnabled;
            mCheckSelected = IsSelected;

            UpdateEffects();
        }

        public virtual void OnInputClicked(InputClickedEventData eventData)
        {
            if (!IsEnabled)
            {
                return;
            }

            UserInitiatedEvent = true;

            if (mIgnoreSelect)
            {
                mIgnoreSelect = false;
                return;
            }

            UpdateEffects();

            OnSelectEvents.Invoke();
        }

        public virtual void OnFocusEnter()
        {
            if (!IsEnabled)
            {
                return;
            }

            HasGaze = true;

            SetKeywordListener(true);

            UpdateEffects();
        }

        public virtual void OnFocusExit()
        {
            HasGaze = false;
            EndHoldDetection();
            mRollOffTimer = 0;
            mCheckRollOff = true;
            SetKeywordListener(false);
            UpdateEffects();
        }

        private void SetKeywordListener(bool listen)
        {
#if UNITY_WSA || UNITY_STANDALONE_WIN
            if (listen)
            {
                if (KeywordRequiresGaze && mKeywordArray != null)
                {
                    if (mKeywordRecognizer == null)
                    {
                        mKeywordRecognizer = new KeywordRecognizer(mKeywordArray);
                        mKeywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized;
                        mKeywordRecognizer.Start();
                    }
                    else
                    {
                        if (!mKeywordRecognizer.IsRunning)
                        {
                            mKeywordRecognizer.Start();
                        }
                    }
                }
            }
            else
            {
                if (mKeywordRecognizer != null && KeywordRequiresGaze)
                {
                    if (mKeywordRecognizer.IsRunning)
                    {
                        mKeywordRecognizer.Stop();
                        mKeywordRecognizer.OnPhraseRecognized -= KeywordRecognizer_OnPhraseRecognized;
                        mKeywordRecognizer.Dispose();
                        mKeywordRecognizer = null;
                    }
                }
            }
#endif
        }

        public void SetTitle(string title)
        {
            LabelTheme lblTheme = gameObject.GetComponent<LabelTheme>();
            if (lblTheme != null)
            {
                lblTheme.Default = title;
            }
            TextMesh textMesh = gameObject.GetComponentInChildren<TextMesh>();
            if (textMesh != null)
            {
                textMesh.text = title;
            }
        }

        public virtual void OnInputDown(InputEventData eventData)
        {
            if (!HasGaze)
            {
                return;
            }

            HasDown = true;
            mCheckRollOff = false;

            if (DetectHold)
            {
                mHoldTimer = 0;
                mCheckHold = true;
            }
            UpdateEffects();

            OnDownEvent.Invoke();
        }

        public virtual void OnInputUp(InputEventData eventData)
        {
            mCheckHold = false;
            HasDown = false;
            mIgnoreSelect = false;
            EndHoldDetection();
            mCheckRollOff = false;

            UpdateEffects();
        }

        public virtual void OnHold()
        {
            mIgnoreSelect = true;
            EndHoldDetection();

            UpdateEffects();

            OnHoldEvent.Invoke();
        }

        public float GetHoldPercentage()
        {
            return mHoldTimer / HoldTime;
        }

        protected void EndHoldDetection()
        {
            mHoldTimer = 0;
            mCheckHold = false;
        }

        private void CollectWidgets(bool forceCollection = false)
        {
            if (mInteractiveWidgets.Count == 0 || forceCollection)
            {
                if (ParentObject != null)
                {
                    ParentObject.GetComponentsInChildren(mInteractiveWidgets);
                }
                for (int i = 0; i < mInteractiveWidgets.Count; ++i)
                {
                    if (mInteractiveWidgets[i].InteractiveHost == null)
                    {
                        mInteractiveWidgets[i].InteractiveHost = this;
                    }
                    else
                    {
                        mInteractiveWidgets.RemoveAt(i);
                        --i;
                    }
                }
            }
        }

        protected void UpdateEffects()
        {
            CollectWidgets();

            CompareStates();

            int interactiveCount = mInteractiveWidgets.Count;
            for (int i = 0; i < interactiveCount; ++i)
            {
                InteractiveWidget widget = mInteractiveWidgets[i];
                widget.SetState(mState);

                int currentCount = mInteractiveWidgets.Count;
                if (currentCount < interactiveCount)
                {
                    Debug.LogWarningFormat("Call to {0}'s SetState removed other interactive widgets. GameObject name: {1}.", widget.GetType(), widget.name);
                    interactiveCount = currentCount;
                }
            }
        }

        public void RegisterWidget(InteractiveWidget widget)
        {
            CollectWidgets();
            if (mInteractiveWidgets.Contains(widget))
            {
                return;
            }

            mInteractiveWidgets.Add(widget);
            widget.SetState(mState);
        }

        public void UnregisterWidget(InteractiveWidget widget)
        {
            if (mInteractiveWidgets != null)
            {
                mInteractiveWidgets.Remove(widget);
            }
        }

#if UNITY_WSA || UNITY_STANDALONE_WIN
        protected virtual void KeywordRecognizer_OnPhraseRecognized(PhraseRecognizedEventArgs args)
        {

            // Check to make sure the recognized keyword matches, then invoke the corresponding method.
            if (args.text == Keyword && (!KeywordRequiresGaze || HasGaze) && IsEnabled)
            {
                if (mKeywordDictionary == null)
                {
                    OnInputClicked(null);
                }
            }
        }
#endif

        protected void CompareStates()
        {
            if (IsEnabled)
            {
                // all states
                if (IsSelected)
                {
                    if (HasGaze)
                    {
                        if (HasDown)
                        {
                            mState = ButtonStateEnum.PressSelected;
                        }
                        else
                        {
                            mState = ButtonStateEnum.FocusSelected;
                        }
                    }
                    else
                    {
                        if (HasDown)
                        {
                            mState = ButtonStateEnum.PressSelected;
                        }
                        else
                        {
                            mState = ButtonStateEnum.Selected;
                        }
                    }
                }
                else
                {
                    if (HasGaze)
                    {
                        if (HasDown)
                        {
                            mState = ButtonStateEnum.Press;
                        }
                        else
                        {
                            mState = ButtonStateEnum.Focus;
                        }
                    }
                    else
                    {
                        if (HasDown)
                        {
                            mState = ButtonStateEnum.Press;
                        }
                        else
                        {
                            mState = ButtonStateEnum.Default;
                        }
                    }
                }

            }
            else
            {
                if (IsSelected)
                {
                    mState = ButtonStateEnum.DisabledSelected;
                }
                else
                {
                    mState = ButtonStateEnum.Disabled;
                }
            }
            mCheckSelected = IsSelected;
            mCheckEnabled = IsEnabled;
        }

        protected virtual void Update()
        {

            if (mCheckRollOff && HasDown)
            {
                if (mRollOffTimer < RollOffTime)
                {
                    mRollOffTimer += Time.deltaTime;
                }
                else
                {
                    mCheckRollOff = false;
                    OnInputUp(null);
                }
            }
            if (mCheckHold)
            {
                if (mHoldTimer < HoldTime)
                {
                    mHoldTimer += Time.deltaTime;
                }
                else
                {
                    mCheckHold = false;
                    OnHold();
                }
            }

            if (!UserInitiatedEvent && (mCheckEnabled != IsEnabled || mCheckSelected != IsSelected))
            {
                UpdateEffects();
            }

            UserInitiatedEvent = false;
        }

        protected virtual void OnDestroy()
        {
            SetKeywordListener(false);
        }

        protected virtual void OnEnable()
        {
#if UNITY_WSA || UNITY_STANDALONE_WIN
            if (mKeywordRecognizer != null && !KeywordRequiresGaze)
            {
                SetKeywordListener(true);
            }
#endif
        }

        protected virtual void OnDisable()
        {
            OnFocusExit();
        }
    }
}