HX-PGS-AIM-Android/Library/PackageCache/com.unity.inputsystem/InputSystem/Plugins/UnityRemote/UnityRemoteSupport.cs

#if UNITY_EDITOR
using System;
using System.Runtime.InteropServices;
using UnityEditor;
using UnityEngine.InputSystem.LowLevel;

namespace UnityEngine.InputSystem
{
    /// <summary>
    /// Adds support for processing input-related messages sent from the <c>Unite Remote</c> app.
    /// </summary>
    /// <remarks>
    /// A hook in the Unity runtime allows us to observe messages received from the remote (see Modules/GenericRemoteEditor).
    /// We get the binary blob of each message and a shot at processing the message instead of
    /// the native code doing it.
    /// </remarks>
    internal static class UnityRemoteSupport
    {
        public static bool isConnected => s_State.connected;

        public static void Initialize()
        {
            InputRuntime.s_Instance.onUnityRemoteMessage = ProcessMessageFromUnityRemote;

            InputSystem.onSettingsChange += () =>
            {
                if (InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kDisableUnityRemoteSupport))
                {
                    InputRuntime.s_Instance.onUnityRemoteMessage = null;
                    if (s_State.connected)
                        Disconnect();
                }
                else
                    InputRuntime.s_Instance.onUnityRemoteMessage = ProcessMessageFromUnityRemote;
            };
        }

        private static unsafe bool ProcessMessageFromUnityRemote(IntPtr messageData)
        {
            var messageHeader = (MessageHeader*)messageData;

            switch (messageHeader->type)
            {
                case (byte)MessageType.Hello:
                    if (s_State.connected)
                        break;

                    // Install handlers.
                    s_State.deviceChangeHandler = OnDeviceChange;
                    s_State.deviceCommandHandler = OnDeviceCommand; ////REVIEW: We really should have a way of installing a handler just for a specific device.
                    InputSystem.onDeviceChange += s_State.deviceChangeHandler;
                    InputSystem.onDeviceCommand += s_State.deviceCommandHandler;

                    // Add devices.
                    s_State.touchscreen = InputSystem.AddDevice<Touchscreen>();
                    s_State.touchscreen.m_DeviceFlags |= InputDevice.DeviceFlags.Remote;
                    s_State.accelerometer = InputSystem.AddDevice<Accelerometer>();
                    s_State.accelerometer.m_DeviceFlags |= InputDevice.DeviceFlags.Remote;
                    // Gryo etc. added only when we receive GyroSettingsMessage.

                    s_State.connected = true;
                    Debug.Log("Unity Remote connected to input!");
                    break;

                case (byte)MessageType.Goodbye:
                    if (!s_State.connected)
                        break;
                    Disconnect();
                    Debug.Log("Unity Remote disconnected from input!");
                    break;

                case (byte)MessageType.Options:
                    var optionsMessage = (OptionsMessage*)messageData;
                    s_State.screenSize = DetermineScreenSize(optionsMessage->dimension1, optionsMessage->dimension2);
                    break;

                case (byte)MessageType.TouchInput:
                    if (s_State.touchscreen == null)
                        break;
                    // Android Remote seems to not be sending the last two fields (azimuthAngle and attitudeAngle).
                    if (messageHeader->length < 56)
                        break;
                    var touchMessage = (TouchInputMessage*)messageData;
                    var phase = TouchPhase.None;
                    switch (touchMessage->phase)
                    {
                        case (int)UnityEngine.TouchPhase.Began: phase = TouchPhase.Began; break;
                        case (int)UnityEngine.TouchPhase.Canceled: phase = TouchPhase.Canceled; break;
                        case (int)UnityEngine.TouchPhase.Ended: phase = TouchPhase.Ended; break;
                        case (int)UnityEngine.TouchPhase.Moved: phase = TouchPhase.Moved; break;
                            // Ignore stationary.
                    }
                    if (phase == default)
                        break;
                    InputSystem.QueueStateEvent(s_State.touchscreen, new TouchState
                    {
                        touchId = touchMessage->id + 1,
                        phase = phase,
                        position = MapRemoteTouchCoordinatesToLocal(new Vector2(touchMessage->positionX, touchMessage->positionY)),
                        radius = new Vector2(touchMessage->radius, touchMessage->radius),
                        pressure = touchMessage->pressure
                    });
                    break;

                case (byte)MessageType.GyroSettings:
                    var gyroSettingsMessage = (GyroSettingsMessage*)messageData;
                    if (!s_State.gyroInitialized)
                    {
                        // Message itself indicates presence of a gyro. Add the devices.
                        s_State.gyroscope = InputSystem.AddDevice<Gyroscope>();
                        s_State.attitude = InputSystem.AddDevice<AttitudeSensor>();
                        s_State.gravity = InputSystem.AddDevice<GravitySensor>();
                        s_State.linearAcceleration = InputSystem.AddDevice<LinearAccelerationSensor>();
                        s_State.gyroscope.m_DeviceFlags |= InputDevice.DeviceFlags.Remote;
                        s_State.attitude.m_DeviceFlags |= InputDevice.DeviceFlags.Remote;
                        s_State.gravity.m_DeviceFlags |= InputDevice.DeviceFlags.Remote;
                        s_State.linearAcceleration.m_DeviceFlags |= InputDevice.DeviceFlags.Remote;

                        s_State.gyroInitialized = true;
                    }
                    // Disable them if they are not currently enabled.
                    if (gyroSettingsMessage->enabled == 0)
                    {
                        InputSystem.DisableDevice(s_State.gyroscope);
                        InputSystem.DisableDevice(s_State.attitude);
                        InputSystem.DisableDevice(s_State.gravity);
                        InputSystem.DisableDevice(s_State.linearAcceleration);
                    }
                    else
                    {
                        s_State.gyroEnabled = true;
                    }
                    s_State.gyroUpdateInterval = gyroSettingsMessage->receivedGyroUpdateInternal;
                    break;

                case (byte)MessageType.GyroInput:
                    var gyroInputMessage = (GyroInputMessage*)messageData;
                    if (s_State.attitude != null && s_State.attitude.enabled)
                    {
                        InputSystem.QueueStateEvent(s_State.attitude, new AttitudeState
                        {
                            attitude = new Quaternion(gyroInputMessage->attitudeX, gyroInputMessage->attitudeY, gyroInputMessage->attitudeZ,
                                gyroInputMessage->attitudeW)
                        });
                    }
                    if (s_State.gyroscope != null && s_State.gyroscope.enabled)
                    {
                        InputSystem.QueueStateEvent(s_State.gyroscope, new GyroscopeState
                        {
                            angularVelocity = new Vector3(gyroInputMessage->rotationRateX, gyroInputMessage->rotationRateY,
                                gyroInputMessage->rotationRateZ)
                        });
                    }
                    if (s_State.gravity != null && s_State.gravity.enabled)
                    {
                        InputSystem.QueueStateEvent(s_State.gravity, new GravityState
                        {
                            gravity = new Vector3(gyroInputMessage->gravityX, gyroInputMessage->gravityY,
                                gyroInputMessage->gravityZ)
                        });
                    }
                    if (s_State.linearAcceleration != null && s_State.linearAcceleration.enabled)
                    {
                        InputSystem.QueueStateEvent(s_State.linearAcceleration, new LinearAccelerationState
                        {
                            acceleration = new Vector3(gyroInputMessage->userAccelerationX, gyroInputMessage->userAccelerationY,
                                gyroInputMessage->userAccelerationZ)
                        });
                    }
                    break;

                case (byte)MessageType.AccelerometerInput:
                    if (s_State.accelerometer == null)
                        break;
                    var accelerometerMessage = (AccelerometerInputMessage*)messageData;
                    InputSystem.QueueStateEvent(s_State.accelerometer, new AccelerometerState
                    {
                        acceleration = new Vector3(accelerometerMessage->accelerationX, accelerometerMessage->accelerationY,
                            accelerometerMessage->accelerationZ)
                    });
                    break;
            }

            return false;
        }

        private static void Disconnect()
        {
            InputSystem.RemoveDevice(s_State.touchscreen);
            InputSystem.RemoveDevice(s_State.accelerometer);
            if (s_State.gyroscope != null)
                InputSystem.RemoveDevice(s_State.gyroscope);
            if (s_State.attitude != null)
                InputSystem.RemoveDevice(s_State.attitude);
            if (s_State.gravity != null)
                InputSystem.RemoveDevice(s_State.gravity);
            if (s_State.linearAcceleration != null)
                InputSystem.RemoveDevice(s_State.linearAcceleration);

            ResetGlobalState();
        }

        private static void OnDeviceChange(InputDevice device, InputDeviceChange change)
        {
            switch (change)
            {
                case InputDeviceChange.Removed:
                    // Deal with someone manually removing one of our devices.
                    if (device == s_State.accelerometer)
                        s_State.accelerometer = null;
                    else if (device == s_State.attitude)
                        s_State.accelerometer = null;
                    else if (device == s_State.gravity)
                        s_State.gravity = null;
                    else if (device == s_State.gyroscope)
                        s_State.gyroscope = null;
                    else if (device == s_State.touchscreen)
                        s_State.touchscreen = null;
                    else if (device == s_State.linearAcceleration)
                        s_State.linearAcceleration = null;
                    break;

                case InputDeviceChange.Enabled:
                case InputDeviceChange.Disabled:
                    // If it's any of our devices that make up the remote gyro,
                    // send a message to the remote.
                    if (device == s_State.attitude || device == s_State.gravity || device == s_State.gyroscope ||
                        device == s_State.linearAcceleration)
                    {
                        SyncGyroEnabledInRemote();
                    }
                    break;
            }
        }

        private static unsafe long? OnDeviceCommand(InputDevice device, InputDeviceCommand* command)
        {
            if (device != s_State.attitude && device != s_State.gyroscope && device != s_State.gravity &&
                device != s_State.linearAcceleration)
                return null;

            if (command->type == SetSamplingFrequencyCommand.Type)
            {
                s_State.gyroUpdateInterval = ((SetSamplingFrequencyCommand*)command)->frequency;
                InputRuntime.s_Instance.SetUnityRemoteGyroUpdateInterval(s_State.gyroUpdateInterval);
                return InputDeviceCommand.GenericSuccess;
            }

            if (command->type == QuerySamplingFrequencyCommand.Type)
            {
                ((QuerySamplingFrequencyCommand*)command)->frequency = s_State.gyroUpdateInterval;
                return InputDeviceCommand.GenericSuccess;
            }

            return InputDeviceCommand.GenericFailure;
        }

        private static void SyncGyroEnabledInRemote()
        {
            var enabled = (s_State.attitude?.enabled ?? false) || (s_State.gravity?.enabled ?? false) ||
                (s_State.gyroscope?.enabled ?? false) || (s_State.linearAcceleration?.enabled ?? false);
            if (enabled != s_State.gyroEnabled)
            {
                s_State.gyroEnabled = enabled;
                InputRuntime.s_Instance.SetUnityRemoteGyroEnabled(enabled);
            }
        }

        // This is taken from HandleOptionsMessage() in GenericRemote.cpp.
        private static Vector2 DetermineScreenSize(int dimension1, int dimension2)
        {
            const float kMaxPixels = 640 * 480;  // limit the resolution to VGA
            float screenPixels = dimension1 * dimension2;
            var divider = (int)Mathf.Ceil(Mathf.Sqrt(screenPixels / kMaxPixels));

            if (divider == 0)
                return default;

            var hdim1 = dimension1 / divider;
            var hdim2 = dimension2 / divider;

            // GetConfigValue is private. Reflect around it.
            var getConfigValueMethod = typeof(EditorSettings).GetMethod("GetConfigValue");
            if (getConfigValueMethod != null && "Normal".Equals(getConfigValueMethod.Invoke(null, new[] { "UnityRemoteResolution" })))
            {
                hdim1 = dimension1;
                hdim2 = dimension2;
            }

            if (hdim1 >= 1 && hdim2 >= 1)
                return new Vector2(dimension1, dimension2);

            return default;
        }

        private static Vector2 MapRemoteTouchCoordinatesToLocal(Vector2 position)
        {
            var screenSizeRemote = s_State.screenSize;
            var screenSizeLocal = InputRuntime.s_Instance.screenSize;

            return new Vector2(
                position.x / screenSizeRemote.x * screenSizeLocal.x,
                position.y = position.y / screenSizeRemote.y * screenSizeLocal.y);
        }

        // See Editor/Src/RemoteInput/GenericRemote.cpp

        internal enum MessageType : byte
        {
            Invalid = 0,

            Hello = 1,
            Options = 2,
            GyroSettings = 3,
            DeviceOrientation = 4,
            DeviceFeatures = 5,

            TouchInput = 10,
            AccelerometerInput = 11,
            TrackBallInput = 12,
            Key = 13,
            GyroInput = 14,
            MousePresence = 15,
            JoystickInput = 16,
            JoystickNames = 17,

            WebCamDeviceList = 20,
            WebCamStream = 21,

            LocationServiceData = 30,
            CompassData = 31,

            Goodbye = 32,

            Reserved = 255,
        }

        internal interface IUnityRemoteMessage
        {
            byte staticType { get; }
        }

        [StructLayout(LayoutKind.Explicit, Size = 5)]
        internal struct MessageHeader
        {
            // Unfortunately, the header has an odd 5 byte length and everything
            // coming after it is misaligned. Reason is that native reads is as a stream
            // and wants to pack tightly.
            [FieldOffset(0)] public byte type;
            [FieldOffset(1)] public int length;
        }

        [StructLayout(LayoutKind.Explicit)]
        internal unsafe struct HelloMessage : IUnityRemoteMessage
        {
            [FieldOffset(0)] public MessageHeader header;
            [FieldOffset(5)] public uint protocolIdLength;
            [FieldOffset(9)] public fixed char protocolId[11];
            [FieldOffset(20)] public int protocolVersion;

            public byte staticType => (byte)MessageType.Hello;

            public static HelloMessage Create()
            {
                var msg = default(HelloMessage);
                msg.protocolIdLength = 11;
                msg.protocolId[0] = 'U';
                msg.protocolId[1] = 'n';
                msg.protocolId[2] = 'i';
                msg.protocolId[3] = 't';
                msg.protocolId[4] = 'y';
                msg.protocolId[5] = 'R';
                msg.protocolId[6] = 'e';
                msg.protocolId[7] = 'm';
                msg.protocolId[8] = 'o';
                msg.protocolId[9] = 't';
                msg.protocolId[10] = 'e';
                msg.protocolVersion = 0;
                return msg;
            }
        }

        [StructLayout(LayoutKind.Explicit)]
        internal struct OptionsMessage : IUnityRemoteMessage
        {
            [FieldOffset(0)] public MessageHeader header;
            [FieldOffset(5)] public int dimension1;
            [FieldOffset(9)] public int dimension2;

            public byte staticType => (byte)MessageType.Options;
        }

        [StructLayout(LayoutKind.Explicit)]
        internal struct GoodbyeMessage : IUnityRemoteMessage
        {
            [FieldOffset(0)] public MessageHeader header;

            public byte staticType => (byte)MessageType.Goodbye;
        }

        [StructLayout(LayoutKind.Explicit)]
        internal struct TouchInputMessage : IUnityRemoteMessage
        {
            [FieldOffset(0)] public MessageHeader header;
            [FieldOffset(5)] public float positionX;
            [FieldOffset(9)] public float positionY;
            [FieldOffset(13)] public ulong frame;
            [FieldOffset(21)] public int id;
            [FieldOffset(25)] public int phase;
            [FieldOffset(29)] public int tapCount;
            [FieldOffset(33)] public float radius;
            [FieldOffset(37)] public float radiusVariance;
            [FieldOffset(41)] public int type;
            [FieldOffset(45)] public float pressure;
            [FieldOffset(49)] public float maximumPossiblePressure;
            [FieldOffset(53)] public float azimuthAngle;
            [FieldOffset(57)] public float altitudeAngle;

            public byte staticType => (byte)MessageType.TouchInput;
        }

        [StructLayout(LayoutKind.Explicit)]
        internal struct GyroSettingsMessage : IUnityRemoteMessage
        {
            [FieldOffset(0)] public MessageHeader header;
            [FieldOffset(5)] public int enabled;
            [FieldOffset(9)] public float receivedGyroUpdateInternal;

            public byte staticType => (byte)MessageType.GyroSettings;
        }

        [StructLayout(LayoutKind.Explicit)]
        internal struct GyroInputMessage : IUnityRemoteMessage
        {
            [FieldOffset(0)] public MessageHeader header;
            [FieldOffset(5)] public float rotationRateX;
            [FieldOffset(9)] public float rotationRateY;
            [FieldOffset(13)] public float rotationRateZ;
            [FieldOffset(17)] public float rotationRateUnbiasedX;
            [FieldOffset(21)] public float rotationRateUnbiasedY;
            [FieldOffset(25)] public float rotationRateUnbiasedZ;
            [FieldOffset(29)] public float gravityX;
            [FieldOffset(33)] public float gravityY;
            [FieldOffset(37)] public float gravityZ;
            [FieldOffset(41)] public float userAccelerationX;
            [FieldOffset(45)] public float userAccelerationY;
            [FieldOffset(49)] public float userAccelerationZ;
            [FieldOffset(53)] public float attitudeX;
            [FieldOffset(57)] public float attitudeY;
            [FieldOffset(61)] public float attitudeZ;
            [FieldOffset(65)] public float attitudeW;

            public byte staticType => (byte)MessageType.GyroInput;
        }

        [StructLayout(LayoutKind.Explicit)]
        internal struct AccelerometerInputMessage : IUnityRemoteMessage
        {
            [FieldOffset(0)] public MessageHeader header;
            [FieldOffset(5)] public float accelerationX;
            [FieldOffset(9)] public float accelerationY;
            [FieldOffset(13)] public float accelerationZ;
            [FieldOffset(17)] public float deltaTime;

            public byte staticType => (byte)MessageType.AccelerometerInput;
        }

        private struct State
        {
            public bool connected;
            public bool gyroInitialized;
            public bool gyroEnabled;
            public float gyroUpdateInterval;
            public Vector2 screenSize;

            public Action<InputDevice, InputDeviceChange> deviceChangeHandler;
            public InputDeviceCommandDelegate deviceCommandHandler;

            // Devices that we create for receiving input from the remote.
            public Touchscreen touchscreen;
            public Accelerometer accelerometer;
            public Gyroscope gyroscope;
            public AttitudeSensor attitude;
            public GravitySensor gravity;
            public LinearAccelerationSensor linearAcceleration;
        }

        private static State s_State;

        ////TODO: hook this into Hakan's new cleanup mechanism
        internal static void ResetGlobalState()
        {
            if (s_State.deviceChangeHandler != null)
                InputSystem.onDeviceChange -= s_State.deviceChangeHandler;
            if (s_State.deviceCommandHandler != null)
                InputSystem.onDeviceCommand -= s_State.deviceCommandHandler;
            s_State = default;
        }
    }
}
#endif