cleanup

Author: VeraMommersteeg

Assets/Tests/InputSystem/CoreTests_Devices.cs

@@ -1524,8 +1524,7 @@ public void Devices_CanReconnectDevice_WhenDisconnectedWhileAppIsOutOfFocus()
 
         // Loose focus.
         ScheduleFocusEvent(false);
-        InputSystem.Update(InputUpdateType.Dynamic);
-        //InputSystem.Update();
+        InputSystem.Update();
 
         // Disconnect.
         var inputEvent = DeviceRemoveEvent.Create(deviceId, runtime.currentTime);
@@ -1537,8 +1536,7 @@ public void Devices_CanReconnectDevice_WhenDisconnectedWhileAppIsOutOfFocus()
 
         // Regain focus.
         ScheduleFocusEvent(true);
-        InputSystem.Update(InputUpdateType.Dynamic);
-        //InputSystem.Update();
+        InputSystem.Update();
 
         var newDeviceId = runtime.ReportNewInputDevice(deviceDesc);
         InputSystem.Update();
@@ -5288,7 +5286,7 @@ void DeviceChangeCallback(InputDevice device, InputDeviceChange change)
                             "Sync Mouse", "Sync Mouse2", "Sync Mouse3",
                             "Sync Keyboard"
                         }));
-                        // Enabled devices that don't support syncs dont get reset for Ignore Forcus as we do not want to cancel any actions.
+                        // 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;
                     }

Assets/Tests/InputSystem/Plugins/EnhancedTouchTests.cs

@@ -172,7 +172,7 @@ public void EnhancedTouch_SupportsEditorUpdates(InputSettings.UpdateMode updateM
         // Switch back to player.
         ScheduleFocusEvent(true);
 
-        // We have to schedule the specificic update type that the player is configured to process events in,
+        // 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.
@@ -1187,7 +1187,6 @@ 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();
         }

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

@@ -165,7 +165,7 @@ public InputUpdateType defaultUpdateType
                     return m_CurrentUpdate;
 
 #if UNITY_EDITOR
-                // We can no longer rely on checking the curent focus state, due to this check being used pre-update
+                // We can no longer rely on checking the current focus state, due to this check being used pre-update
                 // to determine in which update type to process input, and focus being updated in Update.
                 // The solution here would be to make update calls explicitly specify the update type and no longer use this property.
                 if (!m_RunPlayerUpdatesInEditMode && (!gameIsPlaying || !gameHasFocus))
@@ -2139,8 +2139,9 @@ internal void InstallRuntime(IInputRuntime runtime)
 #endif
             m_Runtime.pollingFrequency = pollingFrequency;
 
-            focusState = Application.isFocused ? focusState |= FocusFlags.ApplicationFocus
-                : focusState &= ~FocusFlags.ApplicationFocus;
+            focusState = Application.isFocused 
+                ? focusState | FocusFlags.ApplicationFocus
+                : focusState & ~FocusFlags.ApplicationFocus;
 
             // We only hook NativeInputSystem.onBeforeUpdate if necessary.
             if (m_BeforeUpdateListeners.length > 0 || m_HaveDevicesWithStateCallbackReceivers)
@@ -3173,7 +3174,6 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                 {
                     InputDevice device = null;
                     var currentEventReadPtr = m_InputEventStream.currentEventPtr;
-                    var currentEventType = currentEventReadPtr->type;
 
                     Debug.Assert(!currentEventReadPtr->handled, "Event in buffer is already marked as handled");
 
@@ -3186,6 +3186,7 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                         break;
 
                     var currentEventTimeInternal = currentEventReadPtr->internalTime;
+                    var currentEventType = currentEventReadPtr->type;
 #if UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
 #if UNITY_EDITOR
                     if (SkipEventDueToEditorBehaviour(updateType, currentEventType, dropStatusEvents, currentEventTimeInternal))
@@ -3318,7 +3319,7 @@ private unsafe void ProcessEventBuffer(InputUpdateType updateType, ref InputEven
                     ProcessEvent(device, updateType, currentEventReadPtr, ref totalEventBytesProcessed);
 
                     m_InputEventStream.Advance(leaveEventInBuffer: false);
-
+                    
                     // Discard events in case the maximum event bytes per update has been exceeded
                     if (AreMaximumEventBytesPerUpdateExceeded(totalEventBytesProcessed))
                         break;
@@ -3366,14 +3367,15 @@ private unsafe void ProcessBeforeRenderStateEvents(out InputDevice device, out I
             }
         }
 
+#if UNITY_EDITOR
         // Handles editor-specific focus/background early-out behavior and advances the stream accordingly.
         // Returns true if event should be skipped (stream advanced), false otherwise.
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private unsafe bool SkipEventDueToEditorBehaviour(InputUpdateType updateType, FourCC currentEventType, bool dropStatusEvents, double currentEventTimeInternal)
         {
             var focusEventType = new FourCC(FocusConstants.kEventType);
             var possibleFocusEvent = m_InputEventStream.Peek();
-
+            
             if (possibleFocusEvent != null)
             {
                 if (possibleFocusEvent->type == focusEventType && !gameShouldGetInputRegardlessOfFocus)
@@ -3432,6 +3434,7 @@ private unsafe bool SkipEventDueToEditorBehaviour(InputUpdateType updateType, Fo
             }
             return false;
         }
+#endif
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private unsafe bool ShouldDeferEventBetweenEditorAndPlayerUpdates(InputUpdateType updateType, FourCC currentEventType, InputDevice device)
@@ -3826,29 +3829,6 @@ private void UpdateDeviceStateOnFocusLost(InputDevice device, bool runInBackgrou
             }
         }
 
-        /// <summary>
-        /// Determines if we should exit early from event processing without handling events.
-        /// </summary>
-        /// <param name="eventBuffer">The current event buffer</param>
-        /// <param name="canFlushBuffer">Whether the buffer can be flushed</param>
-        /// <param name="updateType">The current update type</param>
-        /// <returns>True if we should exit early, false otherwise.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool ShouldExitEarlyFromEventProcessing(FourCC currentEventType, InputUpdateType updateType)
-        {
-#if UNITY_EDITOR
-            // Check various PlayMode specific early exit conditions
-            if (ShouldExitEarlyBasedOnBackgroundBehavior(currentEventType, updateType))
-                return true;
-
-            // When the game is playing and has focus, we never process input in editor updates.
-            // All we do is just switch to editor state buffers and then exit.
-            if ((gameIsPlaying && gameHasFocus && updateType == InputUpdateType.Editor))
-                return true;
-#endif
-            return false;
-        }
-
         /// <summary>
         /// Determines if status events should be dropped and modifies early exit behavior accordingly.
         /// </summary>

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

@@ -170,7 +170,7 @@ private bool ShouldExitEarlyFromEventProcessing(InputUpdateType updateType)
 
             return false;
         }
-
+#if UNITY_EDITOR
         /// <summary>
         /// Checks background behavior conditions for early exit from event processing.
         /// </summary>
@@ -200,6 +200,7 @@ private bool ShouldExitEarlyBasedOnBackgroundBehavior(InputUpdateType updateType
 
             return false;
         }
+#endif
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private unsafe bool LegacyEarlyOutFromEventProcessing(InputUpdateType updateType, ref InputEventBuffer eventBuffer, ref bool dropStatusEvents)