FIX: [XR-10725] Fixed regression with initial focus causing input devices to always be disabled

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 @@
         /// <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 @@
 
             if (!m_Runtime.isInPlayMode)
             {
-                focusState = focus ? FocusFlags.ApplicationFocus : FocusFlags.None;
+                SetRuntimeFocusState(focus);
                 return;
             }
 
@@ -59,7 +59,7 @@
             {
                 // 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 @@
 #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 @@
         /// <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 @@
         {
             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 @@
 #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 @@
             // 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 @@
             #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 @@
         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 @@
 
 #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)
         {