NEW: Added Focus Events to Input Event Queue

Assets/Tests/InputSystem/CoreTests_Actions.cs

@@ -631,7 +631,9 @@
 
         using (var trace = new InputActionTrace(action))
         {
-            runtime.PlayerFocusLost();
+            ScheduleFocusEvent(false);
+            InputSystem.Update(InputUpdateType.Dynamic);
+
             Set(gamepad.leftTrigger, 0.123f, queueEventOnly: true);
             InputSystem.Update(InputUpdateType.Editor);
 
@@ -661,13 +663,13 @@
             // could just rely on order of event. Which means this test work for a fixed timestamp and it should
             // changed accordingly.
             currentTime += 1.0f;
-            runtime.PlayerFocusLost();
+            ScheduleFocusEvent(false);
             currentTime += 1.0f;
             // Queuing an event like it would be in the editor when the GameView is out of focus.
             Set(mouse.position, new Vector2(0.234f, 0.345f) , queueEventOnly: true);
             currentTime += 1.0f;
             // Gaining focus like it would happen in the editor when the GameView regains focus.
-            runtime.PlayerFocusGained();
+            ScheduleFocusEvent(true);
             currentTime += 1.0f;
             // This emulates a device sync that happens when the player regains focus through an IOCTL command.
             // That's why it also has it's time incremented.
@@ -720,14 +722,15 @@
 
             trace.Clear();
 
-            runtime.PlayerFocusLost();
+            ScheduleFocusEvent(false);
+            InputSystem.Update(InputUpdateType.Dynamic);
             currentTime = 10;
 
             InputSystem.Update(InputUpdateType.Editor);
 
             Assert.That(trace, Is.Empty);
 
-            runtime.PlayerFocusGained();
+            ScheduleFocusEvent(true);
             InputSystem.Update(InputUpdateType.Dynamic);
 
             actions = trace.ToArray();

Assets/Tests/InputSystem/CoreTests_Devices.cs

@@ -19,6 +19,7 @@
 using UnityEngine.Scripting;
 using UnityEngine.TestTools;
 using UnityEngine.TestTools.Utils;
+using UnityEngineInternal.Input;
 using Gyroscope = UnityEngine.InputSystem.Gyroscope;
 using UnityEngine.TestTools.Constraints;
 using Is = NUnit.Framework.Is;
@@ -1522,8 +1523,9 @@
         Assert.That(device, Is.Not.Null);
 
         // Loose focus.
-        runtime.PlayerFocusLost();
-        InputSystem.Update();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
+        //InputSystem.Update();
 
         // Disconnect.
         var inputEvent = DeviceRemoveEvent.Create(deviceId, runtime.currentTime);
@@ -1534,8 +1536,9 @@
         Assert.That(InputSystem.devices, Is.Empty);
 
         // Regain focus.
-        runtime.PlayerFocusGained();
-        InputSystem.Update();
+        ScheduleFocusEvent(true);
+        InputSystem.Update(InputUpdateType.Dynamic);
+        //InputSystem.Update();
 
         var newDeviceId = runtime.ReportNewInputDevice(deviceDesc);
         InputSystem.Update();
@@ -4604,7 +4607,13 @@
         InputSystem.onDeviceChange += DeviceChangeCallback;
 
         var eventCount = 0;
-        InputSystem.onEvent += (eventPtr, _) => ++ eventCount;
+        InputSystem.onEvent += (eventPtr, _) =>
+        {
+            // Focus events will always be processed no matter the state
+            // Since the test relies on counting events based on state, dont count focus events
+            if (eventPtr.data->type != (FourCC)FocusConstants.kEventType)
+                ++eventCount;
+        };
 
         Assert.That(trackedDevice.enabled, Is.True);
         Assert.That(mouse.enabled, Is.True);
@@ -4647,7 +4656,8 @@
         }
 
         // Lose focus.
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
 
         Assert.That(sensor.enabled, Is.False);
         Assert.That(disabledDevice.enabled, Is.False);
@@ -5068,7 +5078,8 @@
         commands.Clear();
 
         // Regain focus.
-        runtime.PlayerFocusGained();
+        ScheduleFocusEvent(true);
+        InputSystem.Update(InputUpdateType.Dynamic);
 
         Assert.That(sensor.enabled, Is.False);
         Assert.That(disabledDevice.enabled, Is.False);
@@ -5275,13 +5286,10 @@
                             "Sync Gamepad", "Sync Joystick",
                             "Sync TrackedDevice", "Sync TrackedDevice2",
                             "Sync Mouse", "Sync Mouse2", "Sync Mouse3",
-                            "Sync Keyboard", "Reset Joystick"
-                        }));
-                        // Enabled devices that don't support syncs get reset.
-                        Assert.That(changes, Is.EquivalentTo(new[]
-                        {
-                            "SoftReset Mouse1", "SoftReset Mouse3", "HardReset Joystick", "SoftReset TrackedDevice2"
+                            "Sync Keyboard"
                         }));
+                        // Enabled devices that don't support syncs dont get reset for Ignore Forcus as we do not want to cancel any actions.
+                        Assert.That(changes, Is.Empty);
                         break;
                     }
             }
@@ -5318,7 +5326,13 @@
         Assert.That(performedCount, Is.EqualTo(1));
 
         // Lose focus
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+#if UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
+        // in the new system, we have to process the focus event to update the state of the devices.
+        // In the old system, this wouldn't work and would make the test fal
+        InputSystem.Update();
+#endif
+
         Assert.That(gamepad.enabled, Is.False);
 
         // Queue an event while in the background. We don't want to see this event to be processed once focus
@@ -5329,7 +5343,7 @@
         InputSystem.Update();
 
         // Gain focus
-        runtime.PlayerFocusGained();
+        ScheduleFocusEvent(true);
 
         // Run update to try process events accordingly once focus is gained
         InputSystem.Update();

Assets/Tests/InputSystem/CoreTests_Editor.cs

@@ -2717,7 +2717,8 @@ public void Editor_CanForceKeyboardAndMouseInputToGameViewWithoutFocus()
         var keyboard = InputSystem.AddDevice<Keyboard>();
         var mouse = InputSystem.AddDevice<Mouse>();
 
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
 
         Assert.That(keyboard.enabled, Is.True);
         Assert.That(mouse.enabled, Is.True);
@@ -3013,7 +3014,8 @@ public void Editor_LeavingPlayMode_ReenablesAllDevicesTemporarilyDisabledDueToFo
         Set(mouse.position, new Vector2(123, 234));
         Press(gamepad.buttonSouth);
 
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
 
         Assert.That(gamepad.enabled, Is.False);
 

Assets/Tests/InputSystem/CoreTests_State.cs

@@ -704,7 +704,9 @@ public void State_CanSetUpMonitorsForStateChanges_InEditor()
         InputState.AddChangeMonitor(gamepad.leftStick,
             (control, time, eventPtr, monitorIndex) => monitorFired = true);
 
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
+
         Set(gamepad.leftStick, new Vector2(0.123f, 0.234f), queueEventOnly: true);
         InputSystem.Update(InputUpdateType.Editor);
 
@@ -1676,7 +1678,9 @@ public void State_RecordingHistory_ExcludesEditorInputByDefault()
         {
             history.StartRecording();
 
-            runtime.PlayerFocusLost();
+            ScheduleFocusEvent(false);
+            InputSystem.Update(InputUpdateType.Dynamic);
+
             Set(gamepad.leftTrigger, 0.123f, queueEventOnly: true);
             InputSystem.Update(InputUpdateType.Editor);
 
@@ -1696,7 +1700,9 @@ public void State_RecordingHistory_CanCaptureEditorInput()
             history.updateMask = InputUpdateType.Editor;
             history.StartRecording();
 
-            runtime.PlayerFocusLost();
+            ScheduleFocusEvent(false);
+            InputSystem.Update(InputUpdateType.Dynamic);
+
             Set(gamepad.leftTrigger, 0.123f, queueEventOnly: true);
             InputSystem.Update(InputUpdateType.Editor);
 

Assets/Tests/InputSystem/Plugins/EnhancedTouchTests.cs

@@ -158,11 +158,10 @@
         Assert.That(Touch.activeTouches, Has.Count.EqualTo(1));
 
         // And make sure we're not seeing the data in the editor.
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
         InputSystem.Update(InputUpdateType.Editor);
 
         Assert.That(Touch.activeTouches, Is.Empty);
-
         // Feed some data into editor state.
         BeginTouch(2, new Vector2(0.234f, 0.345f), queueEventOnly: true);
         InputSystem.Update(InputUpdateType.Editor);
@@ -171,8 +170,25 @@
         Assert.That(Touch.activeTouches[0].touchId, Is.EqualTo(2));
 
         // Switch back to player.
-        runtime.PlayerFocusGained();
-        InputSystem.Update();
+        ScheduleFocusEvent(true);
+
+        // We have to schedule the specificic update type that the player is configured to process events in,
+        // otherwise we will end up using defaultUpdateType, which due to the fact we do not have focus in pre-update yet,
+        // will be Editor, which means that we will end up swapping buffers to the editor buffer, and retreiving the wrong active touch
+        // The only way to properly fix this, is to remove defaultUpdateType, and split the player/editor update loops into separate methods, which would be a breaking change.
+        // Until then, we have to make sure to schedule the correct update type here.
+        switch (updateMode)
+        {
+            case InputSettings.UpdateMode.ProcessEventsInDynamicUpdate:
+                InputSystem.Update(InputUpdateType.Dynamic);
+                break;
+            case InputSettings.UpdateMode.ProcessEventsInFixedUpdate:
+                InputSystem.Update(InputUpdateType.Fixed);
+                break;
+            case InputSettings.UpdateMode.ProcessEventsManually:
+                InputSystem.Update(InputUpdateType.Manual);
+                break;
+        }
 
         Assert.That(Touch.activeTouches, Has.Count.EqualTo(1));
         Assert.That(Touch.activeTouches[0].touchId, Is.EqualTo(1));
@@ -1160,7 +1176,7 @@
         Assert.That(Touch.activeTouches, Has.Count.EqualTo(1));
         Assert.That(Touch.activeTouches[0].phase, Is.EqualTo(TouchPhase.Began));
 
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
 
         if (runInBackground)
         {
@@ -1171,7 +1187,8 @@
         else
         {
             // When not running in the background, the same thing happens but only on focus gain.
-            runtime.PlayerFocusGained();
+            //runtime.PlayerFocusGained();
+            ScheduleFocusEvent(true);
             InputSystem.Update();
         }
 

Assets/Tests/InputSystem/Plugins/InputForUITests.cs

@@ -715,19 +715,19 @@ public void UIActions_DoNotGetTriggeredByOutOfFocusEventInEditor(InputSettings.B
         currentTime += 1.0f;
         Update();
         currentTime += 1.0f;
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
         currentTime += 1.0f;
         Set(mouse.position, outOfFocusPosition , queueEventOnly: true);
         currentTime += 1.0f;
-        runtime.PlayerFocusGained();
+        ScheduleFocusEvent(true);
         currentTime += 1.0f;
         Set(mouse.position, focusPosition, queueEventOnly: true);
         currentTime += 1.0f;
 
         // We call specific updates to simulate editor behavior when regaining focus.
         InputSystem.Update(InputUpdateType.Editor);
         Assert.AreEqual(0, m_InputForUIEvents.Count);
-        InputSystem.Update();
+        InputSystem.Update(InputUpdateType.Dynamic);
         // Calling the event provider update after we call InputSystem updates so that we trigger InputForUI events
         EventProvider.NotifyUpdate();
 

Assets/Tests/InputSystem/Plugins/UITests.cs

@@ -4128,7 +4128,9 @@
 
         scene.leftChildReceiver.events.Clear();
 
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
+
         if (canRunInBackground)
             Assert.That(clickCanceled, Is.EqualTo(0));
         else
@@ -4139,7 +4141,9 @@
         Assert.That(scene.eventSystem.hasFocus, Is.False);
         Assert.That(clicked, Is.False);
 
-        runtime.PlayerFocusGained();
+        ScheduleFocusEvent(true);
+        InputSystem.Update(InputUpdateType.Dynamic);
+
         scene.eventSystem.SendMessage("OnApplicationFocus", true);
 
         yield return null;
@@ -4168,11 +4172,13 @@
 
         // Ensure that losing and regaining focus doesn't cause the next click to be ignored
         clicked = false;
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
         scene.eventSystem.SendMessage("OnApplicationFocus", false);
         yield return null;
 
-        runtime.PlayerFocusGained();
+        ScheduleFocusEvent(true);
+        InputSystem.Update(InputUpdateType.Dynamic);
         scene.eventSystem.SendMessage("OnApplicationFocus", true);
         yield return null;
 

Assets/Tests/InputSystem/Plugins/UserTests.cs

@@ -1268,8 +1268,16 @@ public void Users_DoNotReactToEditorInput()
         ++InputUser.listenForUnpairedDeviceActivity;
         InputUser.onUnpairedDeviceUsed += (control, eventPtr) => Assert.Fail("Should not react!");
 
-        runtime.PlayerFocusLost();
-
+        // We now have to run a dynamic update before the press, to make sure the focus state is up to date.
+        // This is due to scheduled focus events are not being processed in pre-update, and not running an update before the press would result in the incorrect state.
+        // When calling an empty Update(), it will use the default defaultUpdateType to determine which update type to use.
+        // However in pre-update the focus will not have switched to false yet if not running a dynamic update before, so the focus check in defaultUpdateType is no longer correct.
+        // which would cause it to schedule a dynamic update instead. We solve this by first processing the focus event before pressing the button,
+        // which will then make it correctly swap to an editor update type when doing the button press.
+        // Another way to make this test pass, is to queue the button press and then explicitly call an editor update and process both events
+        // The way to solve this is to remove defaultUpdateType and split the editor/player loops or to make sure we do not call any Update() without update type, so we do not use defaultUpdateType.
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
         Press(gamepad.buttonSouth);
 
         Assert.That(gamepad.buttonSouth.isPressed, Is.True);

Assets/Tests/InputSystem/Unity.InputSystem.Tests.asmdef

@@ -70,6 +70,11 @@
             "name": "Unity",
             "expression": "6000.3.0a6",
             "define": "UNITY_INPUT_SYSTEM_PLATFORM_POLLING_FREQUENCY"
+        },
+        {
+            "name": "Unity",
+            "expression": "6000.5.0a8",
+            "define": "UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS"
         }
     ],
     "noEngineReferences": false