FIX: Touch.activeTouches not canceled on focus loss (case 1364017, #1465).

Author: Rene Damm

Assets/Tests/InputSystem/CoreTests_Devices.cs

@@ -1960,6 +1960,39 @@ long DeviceCallback(int deviceId, InputDeviceCommand* command, ref bool received
         Assert.That(gyro.angularVelocity.ReadValue(), Is.EqualTo(Vector3.zero));
     }
 
+    class DeviceWithCustomReset : InputDevice, ICustomDeviceReset
+    {
+        [InputControl]
+        public AxisControl axis { get; private set; }
+
+        protected override void FinishSetup()
+        {
+            axis = GetChildControl<AxisControl>("axis");
+        }
+
+        public unsafe void Reset()
+        {
+            InputState.Change(axis, 1f);
+        }
+    }
+
+    [Test]
+    [Category("Devices")]
+    public void Devices_CanCustomizeResetOfDevice()
+    {
+        var device = InputSystem.AddDevice<DeviceWithCustomReset>();
+
+        Set(device.axis, 0.45f);
+
+        InputSystem.ResetDevice(device);
+
+        Assert.That(device.axis.ReadValue(), Is.EqualTo(1f));
+
+        InputSystem.ResetDevice(device, alsoResetDontResetControls: true);
+
+        Assert.That(device.axis.ReadValue(), Is.Zero);
+    }
+
     [Test]
     [Category("Devices")]
     public void Devices_WhenDeviceIsReset_AndResetsAreObservableStateChanges()

Assets/Tests/InputSystem/Plugins/EnhancedTouchTests.cs

@@ -1140,4 +1140,40 @@ public unsafe void EnhancedTouch_TouchSimulation_DisablesPointerDevicesWithoutDi
         Assert.That(Touchscreen.current.touches[0].isInProgress, Is.True);
         Assert.That(Touchscreen.current.touches[0].position.ReadValue(), Is.EqualTo(new Vector2(123, 234)));
     }
+
+    [Test]
+    [Category("EnhancedTouch")]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void EnhancedTouch_ActiveTouchesGetCanceledOnFocusLoss_WithRunInBackgroundBeing(bool runInBackground)
+    {
+        runtime.runInBackground = runInBackground;
+
+        BeginTouch(1, new Vector2(123, 456));
+
+        Assert.That(Touch.activeTouches, Has.Count.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Began));
+
+        runtime.PlayerFocusLost();
+
+        if (runInBackground)
+        {
+            // When running in the background, next update after focus loss sees touches cancelled
+            // and update after that sees them gone.
+            InputSystem.Update(InputUpdateType.Dynamic);
+        }
+        else
+        {
+            // When not running in the background, the same thing happens but only on focus gain.
+            runtime.PlayerFocusGained();
+            InputSystem.Update();
+        }
+
+        Assert.That(Touch.activeTouches, Has.Count.EqualTo(1));
+        Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Canceled));
+
+        InputSystem.Update();
+
+        Assert.That(Touch.activeTouches, Is.Empty);
+    }
 }

Assets/Tests/InputSystem/Plugins/UITests.cs

@@ -3467,10 +3467,10 @@ public void Setup()
 #endif
 
 #if !TEMP_DISABLE_UI_TESTS_ON_TRUNK
-    static bool[] canRunInBackgroundValueSource = new bool[] { false, true };
+    static bool[] canRunInBackgroundValueSource = new[] { false, true };
 
     [UnityTest]
-    public IEnumerator Run_UI_WhenAppLosesAndRegainsFocus_WhileUIButtonIsPressed_UIButtonClickBehaviorShouldDependOnIfDeviceCanRunInBackground(
+    public IEnumerator UI_WhenAppLosesAndRegainsFocus_WhileUIButtonIsPressed_UIButtonClickBehaviorShouldDependOnIfDeviceCanRunInBackground(
         [ValueSource(nameof(canRunInBackgroundValueSource))] bool canRunInBackground)
     {
         // Whether we run in the background or not should only move the reset of the mouse button

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -16,6 +16,7 @@ however, it has to be formatted properly to pass verification tests.
 - All devices are now re-synced/reset in next update after entering play mode, this is needed to read current state of devices before any intentional input is provided ([case 1231907](https://issuetracker.unity3d.com/issues/mouse-coordinates-reported-as-00-until-the-first-move)).
 - Replaced `UnityLinkerBuildPipelineData.inputDirectory` with hardcoded `Temp` folder because `inputDirectory` is deprecated.
 - Deprecated `InputSettings.filterNoiseOnCurrent`. Now noise filtering is always enabled. Device only will become `.current` if any non-noise control have changed state.
+- A device reset (such as when focus is lost) on `Touchscreen` will now result in all ongoing touches getting cancelled instead of all touches being simply reset to default state.
 
 ### Fixed
 
@@ -30,6 +31,7 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed a device becoming `.current` (e.g. `Gamepad.current`, etc) when sending a new state event that contains no control changes (case 1377952).
 - Fixed calling `IsPressed` on an entire device returning `true` ([case 1374024](https://issuetracker.unity3d.com/issues/inputcontrol-dot-ispressed-always-returns-true-when-using-new-input-system)).
 - Fixed `InputSystem.RegisterLayoutOverride` resulting in the layout that overrides are being applied to losing the connection to its base layout ([case 1377719](https://fogbugz.unity3d.com/f/cases/1377719/)).
+- Fixed `Touch.activeTouches` still registering touches after the app loses focus ([case 1364017](https://issuetracker.unity3d.com/issues/input-system-new-input-system-registering-active-touches-when-app-loses-focus)).
 
 #### Actions
 

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

@@ -0,0 +1,14 @@
+namespace UnityEngine.InputSystem.LowLevel
+{
+    /// <summary>
+    /// A device that implements its own reset logic for when <see cref="InputSystem.ResetDevice"/>
+    /// is called.
+    /// </summary>
+    internal interface ICustomDeviceReset
+    {
+        /// <summary>
+        /// Reset the current device state.
+        /// </summary>
+        void Reset();
+    }
+}

Packages/com.unity.inputsystem/InputSystem/Devices/ICustomDeviceReset.cs.meta

@@ -1,6 +1,4 @@
-using UnityEngine.InputSystem.LowLevel;
-
-namespace UnityEngine.InputSystem
+namespace UnityEngine.InputSystem.LowLevel
 {
     internal interface IEventMerger
     {

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

@@ -1,6 +1,4 @@
-using UnityEngine.InputSystem.LowLevel;
-
-namespace UnityEngine.InputSystem
+namespace UnityEngine.InputSystem.LowLevel
 {
     /// <summary>
     /// Gives an opportunity for device to modify event data in-place before it gets propagated to the rest of the system.

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

@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
 using UnityEngine.InputSystem.Controls;
 using UnityEngine.InputSystem.Layouts;
@@ -488,7 +489,7 @@ public enum TouchPhase
     /// it is recommended to use the higher-level <see cref="EnhancedTouch.Touch"/> API instead.
     /// </remarks>
     [InputControlLayout(stateType = typeof(TouchscreenState), isGenericTypeOfDevice = true)]
-    public class Touchscreen : Pointer, IInputStateCallbackReceiver, IEventMerger
+    public class Touchscreen : Pointer, IInputStateCallbackReceiver, IEventMerger, ICustomDeviceReset
     {
         /// <summary>
         /// Synthetic control that has the data for the touch that is deemed the "primary" touch at the moment.
@@ -952,6 +953,45 @@ unsafe bool IInputStateCallbackReceiver.GetStateOffsetForEvent(InputControl cont
             return true;
         }
 
+        // Implement our own custom reset so that we can cancel touches instead of just wiping them
+        // with default state.
+        unsafe void ICustomDeviceReset.Reset()
+        {
+            var statePtr = currentStatePtr;
+
+            //// https://jira.unity3d.com/browse/ISX-930
+            ////TODO: Figure out a proper way to distinguish the source / reason for a state change.
+            ////      What we're doing here is constructing an event solely for the purpose of Finger.ShouldRecordTouch() not
+            ////      ignoring the state change like it does for delta resets.
+
+            using (var buffer = new NativeArray<byte>(StateEvent.GetEventSizeWithPayload<TouchState>(), Allocator.Temp))
+            {
+                var eventPtr = (StateEvent*)buffer.GetUnsafePtr();
+
+                eventPtr->baseEvent = new InputEvent(StateEvent.Type, buffer.Length, deviceId);
+
+                var primaryTouchState = (TouchState*)((byte*)statePtr + primaryTouch.stateBlock.byteOffset);
+                if (primaryTouchState->phase.IsActive())
+                {
+                    UnsafeUtility.MemCpy(eventPtr->state, primaryTouchState, UnsafeUtility.SizeOf<TouchState>());
+                    ((TouchState*)eventPtr->state)->phase = TouchPhase.Canceled;
+                    InputState.Change(primaryTouch.phase, TouchPhase.Canceled, eventPtr: new InputEventPtr((InputEvent*)eventPtr));
+                }
+
+                var touchStates = (TouchState*)((byte*)statePtr + touches[0].stateBlock.byteOffset);
+                var touchCount = touches.Count;
+                for (var i = 0; i < touchCount; ++i)
+                {
+                    if (touchStates[i].phase.IsActive())
+                    {
+                        UnsafeUtility.MemCpy(eventPtr->state, &touchStates[i], UnsafeUtility.SizeOf<TouchState>());
+                        ((TouchState*)eventPtr->state)->phase = TouchPhase.Canceled;
+                        InputState.Change(touches[i].phase, TouchPhase.Canceled, eventPtr: new InputEventPtr((InputEvent*)eventPtr));
+                    }
+                }
+            }
+        }
+
         internal static unsafe bool MergeForward(InputEventPtr currentEventPtr, InputEventPtr nextEventPtr)
         {
             if (currentEventPtr.type != StateEvent.Type || nextEventPtr.type != StateEvent.Type)

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

@@ -48,8 +48,6 @@ namespace UnityEngine.InputSystem.LowLevel
     /// some device (which, however, may or may not translate to an <see cref="InputDevice"/>; that
     /// part depends on whether the input system was able to create an <see cref="InputDevice"/>
     /// based on the information received from the backend).
-    ///
-    /// To implement your own type of event, TODO (manual?)
     /// </remarks>
     /// <seealso cref="InputEventPtr"/>
     // NOTE: This has to be layout compatible with native events.