PlugIns/GenericEvents/VR-Applications: AutoQUESTGenericMonitorUnityVRTK.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using VRTK;

/**
 * This class can be used to monitor the usage of an AR/VR which uses the VRTK framework. For this, it
 * uses the full functionality of the base class by considering further relevant game objects from the
 * VRTK framework and adding for them additional types of event handling.
 */
public class AutoQUESTGenericMonitorUnityVRTK : AutoQUESTGenericMonitorUnity
{
    /**
     * Traverses a hierarchy of game objects and adds game objects relevant for event logging to the given list
     */
    override protected void addRelevantGameObjects(GameObject gameObject, LinkedList<UnityEngine.Object> currentRelevantGameObjects)
    {
        base.addRelevantGameObjects(gameObject, currentRelevantGameObjects);

        if (gameObject)
        {
            Component[] vrtkObjects = gameObject.GetComponentsInChildren(typeof(VRTK_InteractableObject));
            foreach (Component relevantObject in vrtkObjects)
            {
                currentRelevantGameObjects.AddLast(relevantObject);
            }

            Component[] vrtkControllers = gameObject.GetComponentsInChildren(typeof(VRTK_ControllerEvents));
            foreach (Component relevantObject in vrtkControllers)
            {
                currentRelevantGameObjects.AddLast(relevantObject);
            }
        }
    }

    /**
     * registers event handling for the given relevant object
     */
    override protected void ensureEventHandling(UnityEngine.Object relevantObject)
    {
        if (relevantObject is VRTK_InteractableObject)
        {
            ensureEventHandling((VRTK_InteractableObject)relevantObject);
        }
        else if (relevantObject is VRTK_ControllerEvents)
        {
            ensureEventHandling((VRTK_ControllerEvents)relevantObject);
        }
        else
        {
            base.ensureEventHandling(relevantObject);
        }
    }

    /**
     * registers event handling for the given relevant object
     */
    private void ensureEventHandling(VRTK_InteractableObject interactableObject)
    {
        VRTKListeners listeners = (VRTKListeners) getListeners(interactableObject.gameObject);

        InteractableObjectEventHandler listener = listeners.getCreateListener("objectTouched", interactableObject);
        // remove the listener first to ensure, it is not registered twice
        interactableObject.InteractableObjectTouched -= listener;
        interactableObject.InteractableObjectTouched += listener;

        listener = listeners.getCreateListener("objectUntouched", interactableObject);
        // remove the listener first to ensure, it is not registered twice
        interactableObject.InteractableObjectUntouched -= listener;
        interactableObject.InteractableObjectUntouched += listener;

        listener = listeners.getCreateListener("objectGrabbed", interactableObject);
        // remove the listener first to ensure, it is not registered twice
        interactableObject.InteractableObjectGrabbed -= listener;
        interactableObject.InteractableObjectGrabbed += listener;

        listener = listeners.getCreateListener("objectUngrabbed", interactableObject);
        // remove the listener first to ensure, it is not registered twice
        interactableObject.InteractableObjectUngrabbed -= listener;
        interactableObject.InteractableObjectUngrabbed += listener;

        listener = listeners.getCreateListener("objectUsed", interactableObject);
        // remove the listener first to ensure, it is not registered twice
        interactableObject.InteractableObjectUsed -= listener;
        interactableObject.InteractableObjectUsed += listener;

        listener = listeners.getCreateListener("objectUnused", interactableObject);
        // remove the listener first to ensure, it is not registered twice
        interactableObject.InteractableObjectUnused -= listener;
        interactableObject.InteractableObjectUnused += listener;
    }

    /**
     * registers event handling for the given relevant object
     */
    private void ensureEventHandling(VRTK_ControllerEvents controller)
    {
        VRTKListeners listeners = (VRTKListeners)getListeners(controller.gameObject);

        ControllerInteractionEventHandler listener = listeners.getCreateListener("triggerPressed", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerPressed -= listener;
        controller.TriggerPressed += listener;

        listener = listeners.getCreateListener("triggerReleased", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerReleased -= listener;
        controller.TriggerReleased += listener;

        listener = listeners.getCreateListener("triggerTouchStart", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerTouchStart -= listener;
        controller.TriggerTouchStart += listener;

        listener = listeners.getCreateListener("triggerTouchEnd", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerTouchEnd -= listener;
        controller.TriggerTouchEnd += listener;


        listener = listeners.getCreateListener("triggerHairlineStart", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerHairlineStart -= listener;
        controller.TriggerHairlineStart += listener;

        listener = listeners.getCreateListener("triggerHairlineEnd", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerHairlineEnd -= listener;
        controller.TriggerHairlineEnd += listener;


        listener = listeners.getCreateListener("triggerClicked", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerClicked -= listener;
        controller.TriggerClicked += listener;

        listener = listeners.getCreateListener("triggerUnclicked", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerUnclicked -= listener;
        controller.TriggerUnclicked += listener;


        listener = listeners.getCreateListener("triggerAxisChanged", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TriggerAxisChanged -= listener;
        controller.TriggerAxisChanged += listener;


        listener = listeners.getCreateListener("gripPressed", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripPressed -= listener;
        controller.GripPressed += listener;

        listener = listeners.getCreateListener("gripReleased", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripReleased -= listener;
        controller.GripReleased += listener;


        listener = listeners.getCreateListener("gripTouchStart", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripTouchStart -= listener;
        controller.GripTouchStart += listener;

        listener = listeners.getCreateListener("gripTouchEnd", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripTouchEnd -= listener;
        controller.GripTouchEnd += listener;


        listener = listeners.getCreateListener("gripHairlineStart", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripHairlineStart -= listener;
        controller.GripHairlineStart += listener;

        listener = listeners.getCreateListener("gripHairlineEnd", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripHairlineEnd -= listener;
        controller.GripHairlineEnd += listener;


        listener = listeners.getCreateListener("gripClicked", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripClicked -= listener;
        controller.GripClicked += listener;

        listener = listeners.getCreateListener("gripUnclicked", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripUnclicked -= listener;
        controller.GripUnclicked += listener;


        listener = listeners.getCreateListener("gripAxisChanged", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.GripAxisChanged -= listener;
        controller.GripAxisChanged += listener;


        listener = listeners.getCreateListener("touchpadPressed", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TouchpadPressed -= listener;
        controller.TouchpadPressed += listener;

        listener = listeners.getCreateListener("touchpadReleased", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TouchpadReleased -= listener;
        controller.TouchpadReleased += listener;


        listener = listeners.getCreateListener("touchpadTouchStart", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TouchpadTouchStart -= listener;
        controller.TouchpadTouchStart += listener;

        listener = listeners.getCreateListener("touchpadTouchEnd", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TouchpadTouchEnd -= listener;
        controller.TouchpadTouchEnd += listener;


        listener = listeners.getCreateListener("touchpadAxisChanged", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.TouchpadAxisChanged -= listener;
        controller.TouchpadAxisChanged += listener;


        listener = listeners.getCreateListener("buttonOnePressed", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonOnePressed -= listener;
        controller.ButtonOnePressed += listener;

        listener = listeners.getCreateListener("buttonOneReleased", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonOneReleased -= listener;
        controller.ButtonOneReleased += listener;


        listener = listeners.getCreateListener("buttonOneTouchStart", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonOneTouchStart -= listener;
        controller.ButtonOneTouchStart += listener;

        listener = listeners.getCreateListener("buttonOneTouchEnd", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonOneTouchEnd -= listener;
        controller.ButtonOneTouchEnd += listener;


        listener = listeners.getCreateListener("buttonTwoPressed", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonTwoPressed -= listener;
        controller.ButtonTwoPressed += listener;

        listener = listeners.getCreateListener("buttonTwoReleased", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonTwoReleased -= listener;
        controller.ButtonTwoReleased += listener;


        listener = listeners.getCreateListener("buttonTwoTouchStart", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonTwoTouchStart -= listener;
        controller.ButtonTwoTouchStart += listener;

        listener = listeners.getCreateListener("buttonTwoTouchEnd", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ButtonTwoTouchEnd -= listener;
        controller.ButtonTwoTouchEnd += listener;


        listener = listeners.getCreateListener("startMenuPressed", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.StartMenuPressed -= listener;
        controller.StartMenuPressed += listener;

        listener = listeners.getCreateListener("startMenuReleased", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.StartMenuReleased -= listener;
        controller.StartMenuReleased += listener;


        listener = listeners.getCreateListener("controllerEnabled", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ControllerEnabled -= listener;
        controller.ControllerEnabled += listener;

        listener = listeners.getCreateListener("controllerDisabled", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ControllerDisabled -= listener;
        controller.ControllerDisabled += listener;


        listener = listeners.getCreateListener("controllerIndexChanged", controller);
        // remove the listener first to ensure, it is not registered twice
        controller.ControllerIndexChanged -= listener;
        controller.ControllerIndexChanged += listener;

    }

    /**
     * creates a new listeners object supporting VRTK
     */
    override protected Listeners createListeners()
    {
        return new VRTKListeners(LogEvent);
    }

    /**
     * inner structure to use for storing listeners for scene objects
     */
    protected class VRTKListeners : AutoQUESTGenericMonitorUnity.Listeners
    {
        /**
         * used to pass the event handling callback method
         */
        internal VRTKListeners(EventHandlingCallback callback) : base (callback)
        {
            // nothing to do
        }

        /**
         * returns a listener for the given event type and updates the internal timestamp. If there is no listener
         * one will be created and registered.
         */
        internal InteractableObjectEventHandler getCreateListener(string eventType, VRTK_InteractableObject eventTarget)
        {
            InteractableObjectEventHandler listener = null;

            foreach (KeyValuePair<string, object> candidate in listeners)
            {
                if (candidate.Key == eventType)
                {
                    listener = (InteractableObjectEventHandler)candidate.Value;
                    break;
                }
            }

            if (listener == null)
            {
                listener = delegate (object sender, InteractableObjectEventArgs e)
                {
                    callback(eventType, eventTarget.gameObject, new KeyValuePair<string, string>("interactingObject", e.interactingObject.name));
                };

                addListener(eventType, listener);
                //Debug.Log("ensuring handling of event " + eventType + " for  " + eventTarget);
            }

            lastTouched = DateTime.UtcNow.Ticks;
            return listener;
        }

        /**
         * returns a listener for the given event type and updates the internal timestamp. If there is no listener
         * one will be created and registered.
         */
        internal ControllerInteractionEventHandler getCreateListener(string eventType, VRTK_ControllerEvents controller)
        {
            ControllerInteractionEventHandler listener = null;

            foreach (KeyValuePair<string, object> candidate in listeners)
            {
                if (candidate.Key == eventType)
                {
                    listener = (ControllerInteractionEventHandler)candidate.Value;
                    break;
                }
            }

            if (listener == null)
            {
                listener = delegate (object sender, ControllerInteractionEventArgs e)
                {
                    if (eventType.StartsWith("touchpad"))
                    {
                        Vector2 axis = e.touchpadAxis;
                        roundVector(ref axis);

                        callback(eventType, controller.gameObject,
                                 new KeyValuePair<string, string>("controller", controller.gameObject.name),
                                 new KeyValuePair<string, string>("touchpadAngle", Math.Round(e.touchpadAngle, 2).ToString()),
                                 new KeyValuePair<string, string>("touchpadAxis", "(" + axis.x + ", " + axis.y + ")"));
                    }
                    else if (eventType.StartsWith("trigger"))
                    {
                        callback(eventType, controller.gameObject,
                                 new KeyValuePair<string, string>("controller", controller.gameObject.name),
                                 new KeyValuePair<string, string>("buttonPressure", Math.Round(e.buttonPressure, 2).ToString()));
                    }
                    else
                    {
                        callback(eventType, controller.gameObject,
                                 new KeyValuePair<string, string>("controller", controller.gameObject.name));
                    }
                };

                addListener(eventType, listener);
                //Debug.Log("ensuring handling of event " + eventType + " for  " + eventTarget);
            }

            lastTouched = DateTime.UtcNow.Ticks;
            return listener;
        }

        /**
         * convenience method to round the values of a vector to two decimal positions
         */
        private void roundVector(ref Vector2 vector)
        {
            vector.x = (float)Math.Round(vector.x, 2);
            vector.y = (float)Math.Round(vector.y, 2);
        }
    }

}