Fixed regression with initial focus causing added input devices to be disabled

- Fixed regression caused by #2365 where the focus state of the application was not being synced to the input runtime correctly, causing all input devices to be initially disabled until the game window was clicked away and then back.
- Fixed some incorrect setting of the `focusState` by just setting or clearing the ApplicationFocus flag instead of setting the entire value. In effect this has no current difference because the flags enum only has two values, but makes it future-proof.

Author: chris-massie

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

@@ -113,7 +113,7 @@ internal unsafe interface IInputRuntime
         /// <summary>
         /// Set delegate to call when the application changes focus.
         /// </summary>
-        /// <seealso cref="Application.onFocusChanged"/>
+        /// <seealso cref="Application.focusChanged"/>
         Action<bool> onPlayerFocusChanged { get; set; }
 #endif
 

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

@@ -22,7 +22,7 @@ internal enum FocusFlags : ushort
         /// <summary>
         /// In editor this means the GameView has focus. In a built player this means the player has focus.
         /// </summary>
-        ApplicationFocus = (1 << 0)
+        ApplicationFocus = (1 << 0),
     };
 
     internal partial class InputManager
@@ -34,7 +34,7 @@ internal void OnFocusChanged(bool focus)
 
             if (!m_Runtime.isInPlayMode)
             {
-                focusState = focus ? FocusFlags.ApplicationFocus : FocusFlags.None;
+                SetRuntimeFocusState(focus);
                 return;
             }
 
@@ -59,7 +59,7 @@ internal void OnFocusChanged(bool focus)
             {
                 // 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.
-                focusState = focus ? FocusFlags.ApplicationFocus : FocusFlags.None;
+                SetRuntimeFocusState(focus);
                 return;
             }
 
@@ -122,7 +122,7 @@ internal void OnFocusChanged(bool focus)
 #endif
 
             // We set this *after* the block above as defaultUpdateType is influenced by the setting.
-            focusState = focus ? FocusFlags.ApplicationFocus : FocusFlags.None;
+            SetRuntimeFocusState(focus);
         }
 
         /// <summary>
@@ -150,8 +150,6 @@ private bool ShouldFlushEventBuffer()
         /// <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)]

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

@@ -268,20 +268,15 @@ public FocusFlags focusState
         {
             get
             {
-#if UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
-                return m_Runtime.focusState;
-#else
-                return m_FocusState;
-#endif
+                if (m_Runtime != null)
+                    return m_Runtime.focusState;
+
+                return Application.isFocused ? FocusFlags.ApplicationFocus : FocusFlags.None;
             }
             set
             {
-#if UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
                 if (m_Runtime != null)
                     m_Runtime.focusState = value;
-#else
-                m_FocusState = value;
-#endif
             }
         }
 
@@ -557,11 +552,11 @@ internal static void StopEditorEventPassthrough()
 #else
             true;
 #endif
-        private bool applicationHasFocus => (focusState & FocusFlags.ApplicationFocus) != FocusFlags.None;
+        private bool applicationHasFocus => m_Runtime != null ? m_Runtime.isPlayerFocused : Application.isFocused;
 
         private bool gameHasFocus =>
 #if UNITY_EDITOR
-                     m_RunPlayerUpdatesInEditMode || applicationHasFocus || gameShouldGetInputRegardlessOfFocus || isEditorEventPassthroughActive;
+            m_RunPlayerUpdatesInEditMode || applicationHasFocus || gameShouldGetInputRegardlessOfFocus || isEditorEventPassthroughActive;
 #else
             applicationHasFocus || gameShouldGetInputRegardlessOfFocus;
 #endif
@@ -2027,11 +2022,6 @@ internal void InitializeData()
             // we don't know which one the user is going to use. The user
             // can manually turn off one of them to optimize operation.
             m_UpdateMask = InputUpdateType.Dynamic | InputUpdateType.Fixed;
-            #if !UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
-            m_FocusState = Application.isFocused
-                ? m_FocusState | FocusFlags.ApplicationFocus
-                : m_FocusState & ~FocusFlags.ApplicationFocus;
-            #endif
             #if UNITY_EDITOR
             m_EditorIsActive = true;
             m_UpdateMask |= InputUpdateType.Editor;
@@ -2277,9 +2267,7 @@ internal void InstallRuntime(IInputRuntime runtime)
             #endif
             m_Runtime.pollingFrequency = pollingFrequency;
 
-            focusState = m_Runtime.isPlayerFocused
-                ? focusState | FocusFlags.ApplicationFocus
-                : focusState & ~FocusFlags.ApplicationFocus;
+            SetRuntimeFocusState(Application.isFocused);
 
             // We only hook NativeInputSystem.onBeforeUpdate if necessary.
             if (m_BeforeUpdateListeners.length > 0 || m_HaveDevicesWithStateCallbackReceivers)
@@ -2451,7 +2439,6 @@ internal struct AvailableDevice
         private bool m_NativeBeforeUpdateHooked;
         private bool m_HaveDevicesWithStateCallbackReceivers;
         #if !UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
-        private FocusFlags m_FocusState = FocusFlags.ApplicationFocus;
         private bool m_DiscardOutOfFocusEvents;
         private double m_FocusRegainedTime;
         #endif
@@ -4059,6 +4046,21 @@ private bool ShouldDropStatusEvents(InputEventBuffer eventBuffer)
 
 #endif // UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
 
+        /// <summary>
+        /// Set the focus state of the runtime, converting from the given boolean to either setting or clearing the focus flag.
+        /// </summary>
+        /// <param name="applicationFocus">The application focus state.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void SetRuntimeFocusState(bool applicationFocus)
+        {
+            if (m_Runtime != null)
+            {
+                m_Runtime.focusState = applicationFocus
+                    ? m_Runtime.focusState | FocusFlags.ApplicationFocus
+                    : m_Runtime.focusState & ~FocusFlags.ApplicationFocus;
+            }
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void FinalizeUpdate(InputUpdateType updateType)
         {