Updated solution to allow the test runtime to start in focus independent of the Application.isFocused property

- Since the runtime is what triggers the callback that the InputManager uses to respond to the focus change, we don't need to have the InputManager set the focusState. We can just rely on the runtime itself to set the focus state after triggering the Action.
- TODO: The InputTestRuntime.InvokePlayerFocusChanged does the opposite order of NativeInputRuntime.OnFocusChanged when setting the field. However, if I update the test runtime to set the `m_FocusState` after invoking the `onPlayerFocusChanged`, the `UI_WhenAppLosesAndRegainsFocus_WhileUIButtonIsPressed_UIButtonClickBehaviorShouldDependOnIfDeviceCanRunInBackground(false)` test fails. More investigation is needed to identify if the test is not setup correctly or if the difference in order is intended.

Author: chris-massie

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

@@ -74,6 +74,12 @@ internal unsafe interface IInputRuntime
         /// command sent to the device.</returns>
         long DeviceCommand(int deviceId, InputDeviceCommand* commandPtr);
 
+        /// <summary>
+        /// Initialize the focus state based on current conditions of the application.
+        /// </summary>
+        /// <seealso cref="focusState"/>
+        void InitializeFocusState();
+
         /// <summary>
         /// Set delegate to be called on input updates.
         /// </summary>
@@ -117,7 +123,11 @@ internal unsafe interface IInputRuntime
         Action<bool> onPlayerFocusChanged { get; set; }
 #endif
 
+        /// <summary>
+        /// Flags indicating various focus states for the application and editor.
+        /// </summary>
         FocusFlags focusState { get; set; }
+
         /// <summary>
         /// Is true when the player or game view has focus.
         /// </summary>

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

@@ -33,10 +33,7 @@ internal void OnFocusChanged(bool focus)
             SyncAllDevicesWhenEditorIsActivated();
 
             if (!m_Runtime.isInPlayMode)
-            {
-                SetRuntimeFocusState(focus);
                 return;
-            }
 
             var gameViewFocus = m_Settings.editorInputBehaviorInPlayMode;
 #endif
@@ -59,7 +56,6 @@ 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.
-                SetRuntimeFocusState(focus);
                 return;
             }
 
@@ -120,9 +116,6 @@ internal void OnFocusChanged(bool focus)
 #if UNITY_EDITOR
             m_CurrentUpdate = InputUpdateType.None;
 #endif
-
-            // We set this *after* the block above as defaultUpdateType is influenced by the setting.
-            SetRuntimeFocusState(focus);
         }
 
         /// <summary>

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

@@ -2267,7 +2267,7 @@ internal void InstallRuntime(IInputRuntime runtime)
             #endif
             m_Runtime.pollingFrequency = pollingFrequency;
 
-            SetRuntimeFocusState(Application.isFocused);
+            m_Runtime.InitializeFocusState();
 
             // We only hook NativeInputSystem.onBeforeUpdate if necessary.
             if (m_BeforeUpdateListeners.length > 0 || m_HaveDevicesWithStateCallbackReceivers)
@@ -4046,21 +4046,6 @@ 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)
         {

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

@@ -316,12 +316,24 @@ private bool OnWantsToShutdown()
             return true;
         }
 
+        public void InitializeFocusState()
+        {
+            m_FocusState = Application.isFocused
+                ? m_FocusState | FocusFlags.ApplicationFocus
+                : m_FocusState & ~FocusFlags.ApplicationFocus;
+        }
+
 #if !UNITY_INPUTSYSTEM_SUPPORTS_FOCUS_EVENTS
         private Action<bool> m_FocusChangedMethod;
 
         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;
         }
 
 #endif

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

@@ -234,6 +234,13 @@ public unsafe long DeviceCommand(int deviceId, InputDeviceCommand* commandPtr)
             }
         }
 
+        public void InitializeFocusState()
+        {
+            // Testing should start in focus and individual tests can change this test runtime to lose focus
+            // by calling InvokePlayerFocusChanged via InputTestFixture.ScheduleFocusChangedEvent.
+            m_FocusState = FocusFlags.ApplicationFocus;
+        }
+
         public void InvokePlayerFocusChanged(bool newFocusState)
         {
             m_FocusState = newFocusState