NEW: Added Focus Events to Input Event Queue

Assets/Tests/InputSystem/CoreTests_Actions.cs

@@ -631,7 +631,9 @@ public void Actions_DoNotGetTriggeredByEditorUpdates()
 
         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 @@ public void Actions_DoNotGetTriggeredByOutOfFocusEventInEditor(InputSettings.Bac
             // 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 @@ public void Actions_TimeoutsDoNotGetTriggeredInEditorUpdates()
 
             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,7 +1523,7 @@ public void Devices_CanReconnectDevice_WhenDisconnectedWhileAppIsOutOfFocus()
         Assert.That(device, Is.Not.Null);
 
         // Loose focus.
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
         InputSystem.Update();
 
         // Disconnect.
@@ -1534,7 +1535,7 @@ public void Devices_CanReconnectDevice_WhenDisconnectedWhileAppIsOutOfFocus()
         Assert.That(InputSystem.devices, Is.Empty);
 
         // Regain focus.
-        runtime.PlayerFocusGained();
+        ScheduleFocusEvent(true);
         InputSystem.Update();
 
         var newDeviceId = runtime.ReportNewInputDevice(deviceDesc);
@@ -4604,7 +4605,13 @@ void DeviceChangeCallback(InputDevice device, InputDeviceChange change)
         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 +4654,8 @@ void DeviceChangeCallback(InputDevice device, InputDeviceChange change)
         }
 
         // Lose focus.
-        runtime.PlayerFocusLost();
+        ScheduleFocusEvent(false);
+        InputSystem.Update(InputUpdateType.Dynamic);
 
         Assert.That(sensor.enabled, Is.False);
         Assert.That(disabledDevice.enabled, Is.False);
@@ -5068,7 +5076,8 @@ void DeviceChangeCallback(InputDevice device, InputDeviceChange change)
         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 +5284,10 @@ void DeviceChangeCallback(InputDevice device, InputDeviceChange change)
                             "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 Focus as we do not want to cancel any actions.
+                        Assert.That(changes, Is.Empty);
                         break;
                     }
             }
@@ -5318,7 +5324,13 @@ public void Devices_CanSkipProcessingEventsWhileInBackground()
         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 +5341,7 @@ public void Devices_CanSkipProcessingEventsWhileInBackground()
         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

@@ -2720,7 +2720,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);
@@ -3016,7 +3017,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 @@ public void EnhancedTouch_SupportsEditorUpdates(InputSettings.UpdateMode updateM
         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 @@ public void EnhancedTouch_SupportsEditorUpdates(InputSettings.UpdateMode updateM
         Assert.That(Touch.activeTouches[0].touchId, Is.EqualTo(2));
 
         // Switch back to player.
-        runtime.PlayerFocusGained();
-        InputSystem.Update();
+        ScheduleFocusEvent(true);
+
+        // Explicitly schedule the player's configured update type rather than relying on the default.
+        // Without explicit scheduling, defaultUpdateType would be Editor (since focus has not yet been
+        // gained during update), causing the editor buffer to be used instead of the player buffer,
+        // which would retrieve the wrong active touch. A proper fix would require removing defaultUpdateType
+        // and splitting player/editor update loops into separate methods.
+        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 @@ public void EnhancedTouch_ActiveTouchesGetCanceledOnFocusLoss_WithRunInBackgroun
         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,7 @@ public void EnhancedTouch_ActiveTouchesGetCanceledOnFocusLoss_WithRunInBackgroun
         else
         {
             // When not running in the background, the same thing happens but only on focus gain.
-            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 @@ public IEnumerator UI_WhenAppLosesAndRegainsFocus_WhileUIButtonIsPressed_UIButto
 
         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 @@ public IEnumerator UI_WhenAppLosesAndRegainsFocus_WhileUIButtonIsPressed_UIButto
         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 @@ public IEnumerator UI_WhenAppLosesAndRegainsFocus_WhileUIButtonIsPressed_UIButto
 
         // 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,21 @@ public void Users_DoNotReactToEditorInput()
         ++InputUser.listenForUnpairedDeviceActivity;
         InputUser.onUnpairedDeviceUsed += (control, eventPtr) => Assert.Fail("Should not react!");
 
-        runtime.PlayerFocusLost();
-
+        // Process the focus event before pressing the button to ensure correct update type selection.
+        //
+        // Issue: When Update() is called without an update type, it uses defaultUpdateType which checks
+        // focus state. However, scheduled focus events aren't processed until an update runs, so the
+        // focus check sees stale state and selects the wrong update type.
+        //
+        // Workaround: Run a dynamic update first to process the focus event, ensuring the subsequent
+        // button press correctly uses editor update type.
+        //
+        // Alternative: Queue the button press and explicitly call an editor update to process both events.
+        //
+        // Proper fix: Remove defaultUpdateType and split editor/player loops, or always specify the
+        // update type explicitly when calling Update().
+        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