fixed failing tests, processed feedback

Author: VeraMommersteeg

Assets/Tests/InputSystem/Plugins/EnhancedTouchTests.cs

@@ -172,11 +172,11 @@ public void EnhancedTouch_SupportsEditorUpdates(InputSettings.UpdateMode updateM
         // Switch back to player.
         ScheduleFocusEvent(true);
 
-        // We have to schedule the specific 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.
+        // 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:

Assets/Tests/InputSystem/Plugins/UserTests.cs

@@ -1268,14 +1268,19 @@ public void Users_DoNotReactToEditorInput()
         ++InputUser.listenForUnpairedDeviceActivity;
         InputUser.onUnpairedDeviceUsed += (control, eventPtr) => Assert.Fail("Should not react!");
 
-        // 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.
+        // 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);

…system/InputSystem/LegacyInputManager.cs …stem/InputManager.LegacyFocusHandling.csPackages/com.unity.inputsystem/InputSystem/LegacyInputManager.cs renamed to Packages/com.unity.inputsystem/InputSystem/InputManager.LegacyFocusHandling.cs Packages/com.unity.inputsystem/InputSystem/LegacyInputManager.cs renamed to Packages/com.unity.inputsystem/InputSystem/InputManager.LegacyFocusHandling.cs

@@ -20,7 +20,7 @@ internal enum FocusFlags : ushort
         None = 0,
 
         /// <summary>
-        /// The application has focus.
+        /// In editor this means the GameView has focus. In a built player this means the player has focus.
         /// </summary>
         ApplicationFocus = (1 << 0)
     };

Packages/com.unity.inputsystem/InputSystem/InputManager.LegacyFocusHandling.cs.meta

@@ -508,7 +508,7 @@ public bool runPlayerUpdatesInEditMode
 #else
             true;
 #endif
-        private bool applicationHasFocus => (focusState & FocusFlags.ApplicationFocus) != 0;
+        private bool applicationHasFocus => (focusState & FocusFlags.ApplicationFocus) != FocusFlags.None;
 
         private bool gameHasFocus =>
 #if UNITY_EDITOR
@@ -1973,10 +1973,12 @@ internal void InitializeData()
             // can manually turn off one of them to optimize operation.
             m_UpdateMask = InputUpdateType.Dynamic | InputUpdateType.Fixed;
 #if !UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
-            m_FocusState = FocusFlags.None;
+            m_FocusState = Application.isFocused
+                ? m_FocusState | FocusFlags.ApplicationFocus
+                : m_FocusState & ~FocusFlags.ApplicationFocus;
 #endif
 
-            #if UNITY_EDITOR
+#if UNITY_EDITOR
             m_EditorIsActive = true;
             m_UpdateMask |= InputUpdateType.Editor;
             #endif
@@ -2221,7 +2223,7 @@ internal void InstallRuntime(IInputRuntime runtime)
 #endif
             m_Runtime.pollingFrequency = pollingFrequency;
 
-            focusState = Application.isFocused
+            focusState = m_Runtime.isPlayerFocused
                 ? focusState | FocusFlags.ApplicationFocus
                 : focusState & ~FocusFlags.ApplicationFocus;
 
@@ -2380,7 +2382,7 @@ internal struct AvailableDevice
         private bool m_NativeBeforeUpdateHooked;
         private bool m_HaveDevicesWithStateCallbackReceivers;
 #if !UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
-        private FocusFlags m_FocusState;
+        private FocusFlags m_FocusState = FocusFlags.ApplicationFocus;
         private bool m_DiscardOutOfFocusEvents;
         private double m_FocusRegainedTime;
 #endif
@@ -2829,13 +2831,13 @@ private void InstallBeforeUpdateHookIfNecessary()
 
         private void RestoreDevicesAfterDomainReloadIfNecessary()
         {
-            #if UNITY_EDITOR && !ENABLE_CORECLR
+#if UNITY_EDITOR && !ENABLE_CORECLR
             if (m_SavedDeviceStates != null)
                 RestoreDevicesAfterDomainReload();
 #endif
         }
 
-        #if UNITY_EDITOR
+#if UNITY_EDITOR
         private void SyncAllDevicesWhenEditorIsActivated()
         {
             var isActive = m_Runtime.isEditorActive;
@@ -2868,7 +2870,7 @@ internal void SyncAllDevicesAfterEnteringPlayMode()
             SyncAllDevices();
         }
 
-        #endif // UNITY_EDITOR
+#endif // UNITY_EDITOR
 
         private void WarnAboutDevicesFailingToRecreateAfterDomainReload()
         {
@@ -2888,7 +2890,7 @@ private void WarnAboutDevicesFailingToRecreateAfterDomainReload()
             // At this point, we throw the device states away and forget about
             // what we had before the domain reload.
             m_SavedDeviceStates = null;
-            #endif // UNITY_EDITOR
+#endif // UNITY_EDITOR
         }
 
         private void OnBeforeUpdate(InputUpdateType updateType)
@@ -3105,7 +3107,7 @@ private bool ShouldRunDeviceInBackground(InputDevice device)
                 device.canRunInBackground;
         }
 
-        #if UNITY_EDITOR
+#if UNITY_EDITOR
         internal void LeavePlayMode()
         {
             // Reenable all devices and reset their play mode state.
@@ -3133,7 +3135,7 @@ private void OnPlayerLoopInitialization()
             InputStateBuffers.SwitchTo(m_StateBuffers, InputUpdate.s_LatestUpdateType);
         }
 
-        #endif // UNITY_EDITOR
+#endif // UNITY_EDITOR
 
         internal bool ShouldRunUpdate(InputUpdateType updateType)
         {
@@ -3144,7 +3146,7 @@ internal bool ShouldRunUpdate(InputUpdateType updateType)
 
             var mask = m_UpdateMask;
 
-            #if UNITY_EDITOR
+#if UNITY_EDITOR
             // If the player isn't running, the only thing we run is editor updates, except if
             // explicitly overriden via `runUpdatesInEditMode`.
             // NOTE: This means that in edit mode (outside of play mode) we *never* switch to player
@@ -3153,7 +3155,7 @@ internal bool ShouldRunUpdate(InputUpdateType updateType)
             //       it will see gamepad inputs going to the editor and respond to them.
             if (!gameIsPlaying && updateType != InputUpdateType.Editor && !runPlayerUpdatesInEditMode)
                 return false;
-            #endif // UNITY_EDITOR
+#endif // UNITY_EDITOR
 
             return (updateType & mask) != 0;
         }
@@ -3314,7 +3316,7 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                     }
 #endif
 #else
-                    #if UNITY_EDITOR
+#if UNITY_EDITOR
                     if (dropStatusEvents)
                     {
                         // If the type here is a status event, ask advance not to leave the event in the buffer.  Otherwise, leave it there.
@@ -3332,7 +3334,7 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                         m_InputEventStream.Advance(false);
                         continue;
                     }
-                    #endif
+#endif
 #endif
                     // If we're timeslicing, check if the event time is within limits.
                     if (timesliceEvents && currentEventTimeInternal >= currentTime)
@@ -3346,7 +3348,7 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                         device = TryGetDeviceById(currentEventReadPtr->deviceId);
                     if (device == null && currentEventType != focusEventType)
                     {
-                    #if UNITY_EDITOR
+#if UNITY_EDITOR
                         ////TODO: see if this is a device we haven't created and if so, just ignore
                         m_Diagnostics?.OnCannotFindDeviceForEvent(new InputEventPtr(currentEventReadPtr));
 #endif
@@ -3355,11 +3357,11 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                         continue;
                     }
 
-                    #if UNITY_EDITOR
+#if UNITY_EDITOR
                     // In the editor, route keyboard/pointer events between Editor/Player updates if required.
                     if (ShouldDeferEventBetweenEditorAndPlayerUpdates(updateType, currentEventType, device))
                         continue;
-                    #endif // UNITY_EDITOR
+#endif // UNITY_EDITOR
 
                     // If device is disabled, we let the event through only in certain cases.
                     // Removal and configuration change events should always be processed.
@@ -3369,12 +3371,12 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                         (device.m_DeviceFlags & (InputDevice.DeviceFlags.DisabledInRuntime |
                                                  InputDevice.DeviceFlags.DisabledWhileInBackground)) != 0)
                     {
-                    #if UNITY_EDITOR
+#if UNITY_EDITOR
                         // If the device is disabled in the backend, getting events for them
                         // is something that indicates a problem in the backend so diagnose.
                         if ((device.m_DeviceFlags & InputDevice.DeviceFlags.DisabledInRuntime) != 0)
                             m_Diagnostics?.OnEventForDisabledDevice(currentEventReadPtr, device);
-                    #endif
+#endif
 
                         m_InputEventStream.Advance(false);
                         continue;
@@ -3390,16 +3392,16 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                     // Give the device a chance to do something with data before we propagate it to event listeners.
                     if (device != null && device.hasEventPreProcessor)
                     {
-                        #if UNITY_EDITOR
+#if UNITY_EDITOR
                         var eventSizeBeforePreProcessor = currentEventReadPtr->sizeInBytes;
-                        #endif
+#endif
                         var shouldProcess = ((IEventPreProcessor)device).PreProcessEvent(currentEventReadPtr);
-                        #if UNITY_EDITOR
+#if UNITY_EDITOR
                         if (currentEventReadPtr->sizeInBytes > eventSizeBeforePreProcessor)
                         {
                             throw new AccessViolationException($"'{device}'.PreProcessEvent tries to grow an event from {eventSizeBeforePreProcessor} bytes to {currentEventReadPtr->sizeInBytes} bytes, this will potentially corrupt events after the current event and/or cause out-of-bounds memory access.");
                         }
-                        #endif
+#endif
                         if (!shouldProcess)
                         {
                             // Skip event if PreProcessEvent considers it to be irrelevant.
@@ -3750,9 +3752,9 @@ private unsafe void ProcessStateEvent(InputDevice device, InputUpdateType update
                 // If the state format doesn't match, ignore the event.
                 if (device.stateBlock.format != eventPtr.stateFormat)
                 {
-                                    #if UNITY_EDITOR
+#if UNITY_EDITOR
                     m_Diagnostics?.OnEventFormatMismatch(currentEventReadPtr, device);
-                                    #endif
+#endif
                     return;
                 }
 
@@ -3767,9 +3769,9 @@ private unsafe void ProcessStateEvent(InputDevice device, InputUpdateType update
             //       Only events should. If running play mode updates in editor, we want to defer to the play mode
             //       callbacks to set the last update time to avoid dropping events only processed by the editor state.
             if (device.m_LastUpdateTimeInternal <= eventPtr.internalTime
-                            #if UNITY_EDITOR
+#if UNITY_EDITOR
                 && !(updateType == InputUpdateType.Editor && runPlayerUpdatesInEditMode)
-                            #endif
+#endif
             )
                 device.m_LastUpdateTimeInternal = eventPtr.internalTime;
 
@@ -4382,7 +4384,7 @@ private bool FlipBuffersForDeviceIfNecessary(InputDevice device, InputUpdateType
                 return false;
             }
 
-            #if UNITY_EDITOR
+#if UNITY_EDITOR
             ////REVIEW: should this use the editor update ticks as quasi-frame-boundaries?
             // Updates go to the editor only if the game isn't playing or does not have focus.
             // Otherwise we fall through to the logic that flips for the *next* dynamic and
@@ -4396,7 +4398,7 @@ private bool FlipBuffersForDeviceIfNecessary(InputDevice device, InputUpdateType
                 m_StateBuffers.m_EditorStateBuffers.SwapBuffers(device.m_DeviceIndex);
                 return true;
             }
-            #endif
+#endif
 
             // Flip buffers if we haven't already for this frame.
             if (device.m_CurrentUpdateStepCount != InputUpdate.s_UpdateStepCount)
@@ -4414,7 +4416,7 @@ private bool FlipBuffersForDeviceIfNecessary(InputDevice device, InputUpdateType
 
         // Stuff everything that we want to survive a domain reload into
         // a m_SerializedState.
-        #if UNITY_EDITOR || DEVELOPMENT_BUILD
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
         [Serializable]
         internal struct DeviceState
         {

Packages/com.unity.inputsystem/InputSystem/InputManager.cs

@@ -234,7 +234,7 @@ public FocusFlags focusState
             get => m_FocusState;
             set => m_FocusState = value;
         }
-        public bool isPlayerFocused => (m_FocusState & FocusFlags.ApplicationFocus) != 0;
+        public bool isPlayerFocused => (m_FocusState & FocusFlags.ApplicationFocus) != FocusFlags.None;
 
         public float pollingFrequency
         {

Packages/com.unity.inputsystem/InputSystem/LegacyInputManager.cs.meta

@@ -844,6 +844,7 @@ public void Trigger(InputAction action)
         /// <summary>
         /// Utility function for manually scheduling an InputFocusEvent.
         /// This is useful for testing how the system reacts to focus changes.
+        /// <param name = "focus">The focus state to be scheduled.</param>
         /// </summary>
         public unsafe void ScheduleFocusEvent(bool focus)
         {

Packages/com.unity.inputsystem/InputSystem/NativeInputRuntime.cs

@@ -236,7 +236,9 @@ public unsafe long DeviceCommand(int deviceId, InputDeviceCommand* commandPtr)
 
         public void InvokePlayerFocusChanged(bool newFocusState)
         {
-            focusState = newFocusState ? FocusFlags.ApplicationFocus : FocusFlags.None;
+            m_FocusState = newFocusState
+                ? m_FocusState | FocusFlags.ApplicationFocus
+                : m_FocusState & ~FocusFlags.ApplicationFocus;
             onPlayerFocusChanged?.Invoke(newFocusState);
         }
 
@@ -349,8 +351,8 @@ public struct PairedUser
         public Action<int, string> onDeviceDiscovered { get; set; }
         public Action onShutdown { get; set; }
         public Action<bool> onPlayerFocusChanged { get; set; }
-        public FocusFlags focusState { get; set; }
-        public bool isPlayerFocused => (focusState & FocusFlags.ApplicationFocus) != 0;
+        public FocusFlags focusState { get { return m_FocusState; } set { m_FocusState = value; } }
+        public bool isPlayerFocused => (m_FocusState & FocusFlags.ApplicationFocus) != 0;
         public float pollingFrequency { get; set; } = 60.0f; // At least 60 Hz by default
         public double currentTime { get; set; }
         public double currentTimeForFixedUpdate { get; set; }
@@ -424,6 +426,7 @@ public void SetUnityRemoteGyroUpdateInterval(float interval)
 
         internal const int kDefaultEventBufferSize = 1024 * 512;
 
+        private FocusFlags m_FocusState = FocusFlags.ApplicationFocus;
         private int m_NextDeviceId = 1;
         private int m_NextEventId = 1;
         internal int m_EventCount;