FIX: InvalidOperationExceptions with InputUser and touch input (case 1196522, #965).

Author: Rene Damm

Assets/Tests/InputSystem/CoreTests_Devices.cs

@@ -981,6 +981,11 @@ public void OnStateEvent(InputEventPtr eventPtr)
         {
             InputState.Change(this, eventPtr);
         }
+
+        public bool GetStateOffsetForEvent(InputControl control, InputEventPtr eventPtr, ref uint offset)
+        {
+            return false;
+        }
     }
 
     [Test]
@@ -1074,6 +1079,11 @@ public unsafe void OnStateEvent(InputEventPtr eventPtr)
 
             Assert.Fail();
         }
+
+        public bool GetStateOffsetForEvent(InputControl control, InputEventPtr eventPtr, ref uint offset)
+        {
+            return false;
+        }
     }
 
     [Test]

Assets/Tests/InputSystem/CoreTests_Events.cs

@@ -918,7 +918,7 @@ public void Events_CanSendLargerStateToDeviceWithSmallerState()
 
     [Test]
     [Category("Events")]
-    public unsafe void Events_CanDetectWhetherControlIsPartOfEvent()
+    public unsafe void Events_CanGetStatePointerFromEventThroughControl()
     {
         // We use a mouse here as it has several controls that are "parked" outside MouseState.
         var mouse = InputSystem.AddDevice<Mouse>();
@@ -948,12 +948,39 @@ public unsafe void Events_CanDetectWhetherControlIsPartOfEvent()
         InputSystem.Update();
     }
 
+    // For devices that implement IStateCallbackReceiver (such as Touchscreen), things get tricky. We may be looking
+    // at an event in a state format different from that of the device and with only the device knowing how it
+    // correlates to the state of an individual control.
+    [Test]
+    [Category("Events")]
+    public unsafe void Events_CanGetStatePointerFromEventThroughControl_EvenIfDeviceIsStateCallbackReceiver()
+    {
+        var touchscreen = InputSystem.AddDevice<Touchscreen>();
+
+        using (var trace = new InputEventTrace { deviceId = touchscreen.deviceId })
+        {
+            trace.Enable();
+
+            BeginTouch(1, new Vector2(123, 234));
+
+            var statePtr = touchscreen.primaryTouch.position.GetStatePtrFromStateEvent(trace.ToArray()[0]);
+            Assert.That(statePtr != null);
+
+            // Attempt reading the position value from the touch event.
+            Assert.That(touchscreen.primaryTouch.position.ReadValueFromState(statePtr),
+                Is.EqualTo(new Vector2(123, 234)).Using(Vector2EqualityComparer.Instance));
+
+            // It only works with primaryTouch. See Touchscreen.GetStateOffsetForEvent for details.
+            Assert.That(touchscreen.touches[1].position.GetStatePtrFromStateEvent(trace.ToArray()[0]) == null);
+        }
+    }
+
     [Test]
     [Category("Events")]
     public void Events_CanListenForWhenAllEventsHaveBeenProcessed()
     {
         var receivedCalls = 0;
-        Action callback = () => ++ receivedCalls;
+        void callback() => ++ receivedCalls;
 
         InputSystem.onAfterUpdate += callback;
 

Assets/Tests/InputSystem/Plugins/UserTests.cs

@@ -6,7 +6,6 @@
 using UnityEngine.InputSystem.Controls;
 using UnityEngine.InputSystem.LowLevel;
 using UnityEngine.InputSystem.Users;
-using UnityEngine.TestTools.Utils;
 using Gyroscope = UnityEngine.InputSystem.Gyroscope;
 
 [SuppressMessage("ReSharper", "CheckNamespace")]
@@ -853,6 +852,36 @@ public void Users_CanDetectUseOfUnpairedDevice()
         Assert.That(receivedControls, Has.Exactly(1).SameAs(gamepad.aButton));
     }
 
+    // Touchscreens, because of the unusual TouchState events they receive, are trickier to handle than other
+    // types of devices. Make use that InputUser.listenForUnpairedDeviceActivity doesn't choke on such events.
+    // (case 1196522)
+    [Test]
+    [Category("Users")]
+    public void Users_CanDetectUseOfUnpairedDevice_WhenDeviceIsTouchscreen()
+    {
+        var touchscreen = InputSystem.AddDevice<Touchscreen>();
+
+        var activityWasDetected = false;
+
+        ++InputUser.listenForUnpairedDeviceActivity;
+        InputUser.onUnpairedDeviceUsed +=
+            (control, eventPtr) =>
+        {
+            // Because of Touchscreen's state trickery, there's no saying which actual TouchControl
+            // the event is for until Touchscreen has actually gone and done its thing and processed
+            // the event. So, all we can say here is that 'control' should be part of any of the
+            // TouchControls on our Touchscreen.
+            Assert.That(control.FindInParentChain<TouchControl>(), Is.Not.Null);
+            Assert.That(control.device, Is.SameAs(touchscreen));
+
+            activityWasDetected = true;
+        };
+
+        BeginTouch(1, new Vector2(123, 234));
+
+        Assert.That(activityWasDetected);
+    }
+
     // Make sure that if we pair a device from InputUser.onUnpairedDeviceUsed, we don't get any further
     // callbacks.
     [Test]

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 Due to package verification, the latest version below is the unpublished version and the date is meaningless.
 however, it has to be formatted properly to pass verification tests.
 
+## [1.0.0-preview.4] - 2019-12-12
+
+### Changed
+
+- `InputControlExtensions.GetStatePtrFromStateEvent` no longer throws `InvalidOperationException` when the state format for the event does not match that of the device. It simply returns `null` instead (same as when control is found in the event's state).
+
+### Fixed
+
+- `InputUser` in combination with touchscreens no longer throws `InvalidOperationException` complaining about incorrect state format.
+ * In a related change, `InputControlExtensions.GetStatePtrFromStateEvent` now works with touch events, too.
+
 ## [1.0.0-preview.3] - 2019-11-14
 
 ### Fixed

Packages/com.unity.inputsystem/InputSystem/Actions/InputAction.cs

@@ -1,9 +1,10 @@
 using System;
-using Unity.Collections.LowLevel.Unsafe;
 using UnityEngine.InputSystem.LowLevel;
 using UnityEngine.InputSystem.Utilities;
 using UnityEngine.Serialization;
 
+////TODO: add way to retrieve the binding correspond to a control
+
 ////TODO: add way to retrieve the currently ongoing interaction and also add way to know how long it's been going on
 
 ////FIXME: Whether a control from a binding that's part of a composite appears on an action is currently not consistently enforced.

Packages/com.unity.inputsystem/InputSystem/Controls/InputControlExtensions.cs

@@ -15,6 +15,29 @@ namespace UnityEngine.InputSystem
     /// </summary>
     public static class InputControlExtensions
     {
+        /// <summary>
+        /// Find a control of the given type in control hierarchy of <paramref name="control"/>.
+        /// </summary>
+        /// <param name="control">Control whose parents to inspect.</param>
+        /// <typeparam name="TControl">Type of control to look for. Actual control type can be
+        /// subtype of this.</typeparam>
+        /// <remarks>The found control of type <typeparamref name="TControl"/> which may be either
+        /// <paramref name="control"/> itself or one of its parents. If no such control was found,
+        /// returns <c>null</c>.</remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="control"/> is <c>null</c>.</exception>
+        public static TControl FindInParentChain<TControl>(this InputControl control)
+            where TControl : InputControl
+        {
+            if (control == null)
+                throw new ArgumentNullException(nameof(control));
+
+            for (var parent = control; parent != null; parent = parent.parent)
+                if (parent is TControl parentOfType)
+                    return parentOfType;
+
+            return null;
+        }
+
         /// <summary>
         /// Return true if the given control is actuated.
         /// </summary>
@@ -113,16 +136,38 @@ public static unsafe object ReadDefaultValueAsObject(this InputControl control)
         }
 
         /// <summary>
-        /// Read the value of the given control from an event.
+        /// Read the value for the given control from the given event.
         /// </summary>
-        /// <param name="control"></param>
-        /// <param name="inputEvent">Input event. This must be a <see cref="StateEvent"/> or <seealso cref="DeltaStateEvent"/>.
+        /// <param name="control">Control to read value for.</param>
+        /// <param name="inputEvent">Event to read value from. Must be a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>.</param>
+        /// <typeparam name="TValue">Type of value to read.</typeparam>
+        /// <exception cref="ArgumentNullException"><paramref name="control"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="inputEvent"/> is not a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>.</exception>
+        /// <returns>The value for the given control as read out from the given event or <c>default(TValue)</c> if the given
+        /// event does not contain a value for the control (e.g. if it is a <see cref="DeltaStateEvent"/> not containing the relevant
+        /// portion of the device's state memory).</returns>
+        public static TValue ReadValueFromEvent<TValue>(this InputControl<TValue> control, InputEventPtr inputEvent)
+            where TValue : struct
+        {
+            if (control == null)
+                throw new ArgumentNullException(nameof(control));
+            if (!ReadValueFromEvent(control, inputEvent, out var value))
+                return default;
+            return value;
+        }
+
+        /// <summary>
+        /// Check if the given event contains a value for the given control and if so, read the value.
+        /// </summary>
+        /// <param name="control">Control to read value for.</param>
+        /// <param name="inputEvent">Input event. This must be a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>.
         /// Note that in the case of a <see cref="DeltaStateEvent"/>, the control may not actually be part of the event. In this
         /// case, the method returns false and stores <c>default(TValue)</c> in <paramref name="value"/>.</param>
         /// <param name="value">Variable that receives the control value.</param>
-        /// <typeparam name="TValue"></typeparam>
+        /// <typeparam name="TValue">Type of value to read.</typeparam>
         /// <returns>True if the value has been successfully read from the event, false otherwise.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="control"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="control"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="inputEvent"/> is not a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>.</exception>
         /// <seealso cref="ReadUnprocessedValueFromEvent{TValue}(InputControl{TValue},InputEventPtr)"/>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "2#")]
         public static unsafe bool ReadValueFromEvent<TValue>(this InputControl<TValue> control, InputEventPtr inputEvent, out TValue value)
@@ -457,6 +502,26 @@ public static unsafe bool HasValueChangeInEvent(this InputControl control, Input
             return control.CompareValue(control.currentStatePtr, control.GetStatePtrFromStateEvent(eventPtr));
         }
 
+        /// <summary>
+        /// Given a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>, return the raw memory pointer that can
+        /// be used, for example, with <see cref="InputControl{T}.ReadValueFromState"/> to read out the value of <paramref name="control"/>
+        /// contained in the event.
+        /// </summary>
+        /// <param name="control">Control to access state for in the given state event.</param>
+        /// <param name="eventPtr">A <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/> containing input state.</param>
+        /// <returns>A pointer that can be used with methods such as <see cref="InputControl{TValue}.ReadValueFromState"/> or <c>null</c>
+        /// if <paramref name="eventPtr"/> does not contain state for the given <paramref name="control"/>.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="control"/> is <c>null</c> -or- <paramref name="eventPtr"/> is invalid.</exception>
+        /// <exception cref="ArgumentException"><paramref name="eventPtr"/> is not a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>.</exception>
+        /// <remarks>
+        /// Note that the given state event must have the same state format (see <see cref="InputStateBlock.format"/>) as the device
+        /// to which <paramref name="control"/> belongs. If this is not the case, the method will invariably return <c>null</c>.
+        ///
+        /// In practice, this means that the method cannot be used with touch events or, in general, with events sent to devices
+        /// that implement <see cref="IInputStateCallbackReceiver"/> (which <see cref="Touchscreen"/> does) except if the event
+        /// is in the same state format as the device. Touch events will generally be sent as state events containing only the
+        /// state of a single <see cref="Controls.TouchControl"/>, not the state of the entire <see cref="Touchscreen"/>.
+        /// </remarks>
         public static unsafe void* GetStatePtrFromStateEvent(this InputControl control, InputEventPtr eventPtr)
         {
             if (control == null)
@@ -489,7 +554,7 @@ public static unsafe bool HasValueChangeInEvent(this InputControl control, Input
             }
             else
             {
-                throw new ArgumentException("Event must be a state or delta state event", "eventPtr");
+                throw new ArgumentException("Event must be a state or delta state event", nameof(eventPtr));
             }
 
             // Make sure we have a state event compatible with our device. The event doesn't
@@ -498,11 +563,18 @@ public static unsafe bool HasValueChangeInEvent(this InputControl control, Input
             // to read.
             var device = control.device;
             if (stateFormat != device.m_StateBlock.format)
-                throw new InvalidOperationException(
-                    $"Cannot read control '{control.path}' from {eventPtr.type} with format {stateFormat}; device '{device}' expects format {device.m_StateBlock.format}");
+            {
+                // If the device is an IInputStateCallbackReceiver, there's a chance it actually recognizes
+                // the state format in the event and can correlate it to the state as found on the device.
+                if (!device.hasStateCallbacks ||
+                    !((IInputStateCallbackReceiver)device).GetStateOffsetForEvent(control, eventPtr, ref stateOffset))
+                    return null;
+            }
 
             // Once a device has been added, global state buffer offsets are baked into control hierarchies.
             // We need to unsubtract those offsets here.
+            // NOTE: If the given device has not actually been added to the system, the offset is simply 0
+            //       and this is a harmless NOP.
             stateOffset += device.m_StateBlock.byteOffset;
 
             // Return null if state is out of range.

Packages/com.unity.inputsystem/InputSystem/Controls/InputControlPath.cs

@@ -613,6 +613,29 @@ public static bool Matches(string expected, InputControl control)
             return MatchesRecursive(ref parser, control);
         }
 
+        /// <summary>
+        /// Check whether the given path matches <paramref name="control"/> or any of its parents.
+        /// </summary>
+        /// <param name="expected">A control path.</param>
+        /// <param name="control">An input control.</param>
+        /// <returns>True if the given path matches at least a partial path to <paramref name="control"/>.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="expected"/> is <c>null</c> or empty -or-
+        /// <paramref name="control"/> is <c>null</c>.</exception>
+        /// <remarks>
+        /// <example>
+        /// <code>
+        /// // True as the path matches the Keyboard device itself, i.e. the parent of
+        /// // Keyboard.aKey.
+        /// InputControlPath.MatchesPrefix("&lt;Keyboard&gt;", Keyboard.current.aKey);
+        ///
+        /// // False as the path matches none of the controls leading to Keyboard.aKey.
+        /// InputControlPath.MatchesPrefix("&lt;Gamepad&gt;", Keyboard.current.aKey);
+        ///
+        /// // True as the path matches Keyboard.aKey itself.
+        /// InputControlPath.MatchesPrefix("&lt;Keyboard&gt;/a", Keyboard.current.aKey);
+        /// </code>
+        /// </example>
+        /// </remarks>
         public static bool MatchesPrefix(string expected, InputControl control)
         {
             if (string.IsNullOrEmpty(expected))

Packages/com.unity.inputsystem/InputSystem/Devices/InputDevice.cs

@@ -594,6 +594,18 @@ internal bool hasControlsWithDefaultState
             }
         }
 
+        internal bool hasStateCallbacks
+        {
+            get => (m_DeviceFlags & DeviceFlags.HasStateCallbacks) == DeviceFlags.HasStateCallbacks;
+            set
+            {
+                if (value)
+                    m_DeviceFlags |= DeviceFlags.HasStateCallbacks;
+                else
+                    m_DeviceFlags &= ~DeviceFlags.HasStateCallbacks;
+            }
+        }
+
         internal void AddDeviceUsage(InternedString usage)
         {
             var controlUsageCount = m_UsageToControl.LengthSafe();

Packages/com.unity.inputsystem/InputSystem/Devices/Pointer.cs

@@ -248,5 +248,10 @@ void IInputStateCallbackReceiver.OnStateEvent(InputEventPtr eventPtr)
         {
             OnStateEvent(eventPtr);
         }
+
+        bool IInputStateCallbackReceiver.GetStateOffsetForEvent(InputControl control, InputEventPtr eventPtr, ref uint offset)
+        {
+            return false;
+        }
     }
 }