Added temporary override of applicationHasFocus while handling the focus change to restore old functionality

- Since the `applicationHasFocus` property was updated with this branch to return the runtime's value instead of having the duplicate field, it now caused the defaultUpdateType to be different during the method. The goal of this change is to restore the old timing of when that property changes until after the `OnFocusChanged` method finishes executing.

Author: chris-massie

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

@@ -29,11 +29,20 @@ internal partial class InputManager
     {
         internal void OnFocusChanged(bool focus)
         {
+            // We set this to temporarily override applicationHasFocus before processing the focus change
+            // as defaultUpdateType is influenced by it. Before returning from this method, clear the
+            // bool to stop overriding to indicate this manager has finished processing the focus change.
+            m_IsHandlingFocusChange = true;
+            m_ApplicationHadFocus = !focus;
+
 #if UNITY_EDITOR
             SyncAllDevicesWhenEditorIsActivated();
 
             if (!m_Runtime.isInPlayMode)
+            {
+                m_IsHandlingFocusChange = false;
                 return;
+            }
 
             var gameViewFocus = m_Settings.editorInputBehaviorInPlayMode;
 #endif
@@ -51,11 +60,11 @@ internal void OnFocusChanged(bool focus)
                 m_Runtime.runInBackground;
 #endif
 
-            var backgroundBehavior = m_Settings.backgroundBehavior;
-            if (backgroundBehavior == InputSettings.BackgroundBehavior.IgnoreFocus && runInBackground)
+            if (m_Settings.backgroundBehavior == InputSettings.BackgroundBehavior.IgnoreFocus && runInBackground)
             {
                 // If runInBackground is true, no device changes should happen, even when focus is gained. So early out.
                 // If runInBackground is false, we still want to sync devices when focus is gained. So we need to continue further.
+                m_IsHandlingFocusChange = false;
                 return;
             }
 
@@ -116,6 +125,8 @@ internal void OnFocusChanged(bool focus)
 #if UNITY_EDITOR
             m_CurrentUpdate = InputUpdateType.None;
 #endif
+
+            m_IsHandlingFocusChange = false;
         }
 
         /// <summary>

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

@@ -241,7 +241,7 @@ public InputUpdateType defaultUpdateType
                 // 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))
                     return InputUpdateType.Editor;
-                #endif
+#endif
 
                 return m_UpdateMask.GetUpdateTypeForPlayer();
             }
@@ -536,7 +536,17 @@ internal static void StopEditorEventPassthrough()
 #else
             true;
 #endif
-        private bool applicationHasFocus => m_Runtime != null ? m_Runtime.isPlayerFocused : Application.isFocused;
+        private bool applicationHasFocus
+        {
+            get
+            {
+#if !UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
+                if (m_IsHandlingFocusChange)
+                    return m_ApplicationHadFocus;
+#endif
+                return m_Runtime != null ? m_Runtime.isPlayerFocused : Application.isFocused;
+            }
+        }
 
         private bool gameHasFocus =>
 #if UNITY_EDITOR
@@ -2425,6 +2435,12 @@ internal struct AvailableDevice
         #if !UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
         private bool m_DiscardOutOfFocusEvents;
         private double m_FocusRegainedTime;
+        // These two bools are used for overriding applicationHasFocus which affects gameHasFocus
+        // and thus defaultUpdateType. See comments in defaultUpdateType. While processing the
+        // focus change in the OnFocusChanged method, these are used to temporarily override
+        // those properties.
+        private bool m_IsHandlingFocusChange;
+        private bool m_ApplicationHadFocus;
         #endif
         private InputEventStream m_InputEventStream;
 

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

@@ -328,12 +328,11 @@ public void InitializeFocusState()
 
         private void OnFocusChanged(bool focus)
         {
-            m_FocusChangedMethod(focus);
-
-            // We set this *after* the callback above as InputManager.defaultUpdateType is influenced by the property.
             m_FocusState = focus
                 ? m_FocusState | FocusFlags.ApplicationFocus
                 : m_FocusState & ~FocusFlags.ApplicationFocus;
+
+            m_FocusChangedMethod(focus);
         }
 
 #endif

Packages/com.unity.inputsystem/Tests/TestFixture/InputTestRuntime.cs

@@ -246,6 +246,7 @@ public void InvokePlayerFocusChanged(bool newFocusState)
             m_FocusState = newFocusState
                 ? m_FocusState | FocusFlags.ApplicationFocus
                 : m_FocusState & ~FocusFlags.ApplicationFocus;
+
             onPlayerFocusChanged?.Invoke(newFocusState);
         }