FIX: [Port] [UUM-150956] [Input System] Fixed PlayerInput Unity Events missing until reselected (#2503)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: K-Tone

Assets/Tests/InputSystem.Editor/PlayerInputEditorTests.cs

@@ -0,0 +1,223 @@
+using System.Collections;
+using System.Linq;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.Editor;
+using UnityEngine.TestTools;
+using UnityEngine.UIElements;
+using Object = UnityEngine.Object;
+
+/// <summary>
+/// Tests for the custom inspector of the PlayerInput component.
+/// </summary>
+internal sealed class PlayerInputEditorTests
+{
+    private GameObject go;
+    private PlayerInput playerInput;
+    private InputActionAsset actions;
+    private PlayerInputEditor editor;
+    private EditorWindow window;
+    private bool onGuiCalled;
+
+    private class TestHostWindow : EditorWindow {}
+
+    [SetUp]
+    public void SetUp()
+    {
+        go = new GameObject("Host");
+        playerInput = go.AddComponent<PlayerInput>();
+        actions = AssetDatabase.LoadAssetAtPath<InputActionAsset>(PlayerInputEditor.kDefaultInputActionsAssetPath);
+        window = EditorWindow.GetWindow<TestHostWindow>();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        if (editor != null)
+            Object.DestroyImmediate(editor);
+        window.Close();
+        Undo.ClearUndo(playerInput);
+        Object.DestroyImmediate(go);
+    }
+
+    private IEnumerator RenderInspector()
+    {
+        onGuiCalled = false;
+
+        var container = new IMGUIContainer(() =>
+        {
+            // Like the Inspector window, pick up changes made to the target outside the editor (e.g. undo).
+            editor.serializedObject.UpdateIfRequiredOrScript();
+            editor.OnInspectorGUI();
+            onGuiCalled = true;
+        });
+
+        window.rootVisualElement.Add(container);
+        window.Repaint();
+
+        var timeoutTime = Time.realtimeSinceStartupAsDouble + 3.0;
+        do
+        {
+            yield return null; // let Unity process a frame
+        }
+        while (!onGuiCalled && Time.realtimeSinceStartupAsDouble < timeoutTime);
+
+        container.RemoveFromHierarchy();
+        Assert.That(onGuiCalled, Is.True, "Inspector GUI was not drawn");
+    }
+
+    // Replaces the actions of the asset with the given ones in a single map, the way a reimport does. The IDs are
+    // derived from the position, so actions keep their ID across calls.
+    private static void LoadActions(InputActionAsset asset, params string[] actionNames)
+    {
+        var actionsJson = actionNames.Select((name, i) =>
+            $"{{\"name\":\"{name}\",\"type\":\"Button\",\"id\":\"00000000-0000-0000-0000-{i + 1:D12}\"}}");
+        asset.LoadFromJson(
+            $"{{\"maps\":[{{\"name\":\"map\",\"actions\":[{string.Join(",", actionsJson)}],\"bindings\":[]}}]}}");
+    }
+
+    // UUM-150956: switching to InvokeUnityEvents on a freshly added component did not show the per-action events
+    // until the inspector was recreated.
+    [UnityTest]
+    public IEnumerator ActionEventsAreListed_WhenBehaviorIsSwitchedToInvokeUnityEvents(
+        [Values(PlayerNotifications.SendMessages, PlayerNotifications.BroadcastMessages, PlayerNotifications.InvokeCSharpEvents)]
+        PlayerNotifications initialBehavior)
+    {
+        Assert.That(actions, Is.Not.Null);
+
+        playerInput.m_Actions = actions;
+        playerInput.m_NotificationBehavior = initialBehavior;
+        editor = (PlayerInputEditor)UnityEditor.Editor.CreateEditor(playerInput);
+
+        yield return RenderInspector();
+        Assert.That(playerInput.m_ActionEvents, Is.Null.Or.Empty);
+
+        editor.serializedObject.FindProperty(nameof(PlayerInput.m_NotificationBehavior)).intValue =
+            (int)PlayerNotifications.InvokeUnityEvents;
+        editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+
+        yield return RenderInspector();
+
+        Assert.That(playerInput.m_ActionEvents.Select(e => e.actionId),
+            Is.EquivalentTo(actions.Select(a => a.id.ToString())));
+    }
+
+    [UnityTest]
+    public IEnumerator ActionEventsFollowActionsAsset_WhenSwitchingBackToInvokeUnityEvents()
+    {
+        Assert.That(actions, Is.Not.Null);
+
+        playerInput.m_Actions = actions;
+        playerInput.m_NotificationBehavior = PlayerNotifications.InvokeUnityEvents;
+        editor = (PlayerInputEditor)UnityEditor.Editor.CreateEditor(playerInput);
+
+        yield return RenderInspector();
+        Assert.That(playerInput.m_ActionEvents, Is.Not.Empty);
+
+        // Switch away, swap in an asset with different actions, then switch back.
+        var otherActions = ScriptableObject.CreateInstance<InputActionAsset>();
+        try
+        {
+            otherActions.AddActionMap("map").AddAction("other");
+
+            var behaviorProperty = editor.serializedObject.FindProperty(nameof(PlayerInput.m_NotificationBehavior));
+            behaviorProperty.intValue = (int)PlayerNotifications.SendMessages;
+            editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            yield return RenderInspector();
+
+            editor.serializedObject.FindProperty(nameof(PlayerInput.m_Actions)).objectReferenceValue = otherActions;
+            editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            yield return RenderInspector();
+
+            behaviorProperty.intValue = (int)PlayerNotifications.InvokeUnityEvents;
+            editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            yield return RenderInspector();
+
+            Assert.That(playerInput.m_ActionEvents.Select(e => e.actionId),
+                Is.EquivalentTo(otherActions.Select(a => a.id.ToString())));
+        }
+        finally
+        {
+            Object.DestroyImmediate(otherActions);
+        }
+    }
+
+    // Leaving InvokeUnityEvents and coming back with the same asset must pick up actions added in the meantime.
+    [UnityTest]
+    public IEnumerator ActionEventsFollowActionsAsset_WhenReenteringInvokeUnityEventsWithSameAsset()
+    {
+        var asset = ScriptableObject.CreateInstance<InputActionAsset>();
+        try
+        {
+            LoadActions(asset, "first");
+
+            playerInput.m_Actions = asset;
+            playerInput.m_NotificationBehavior = PlayerNotifications.InvokeUnityEvents;
+            editor = (PlayerInputEditor)UnityEditor.Editor.CreateEditor(playerInput);
+            yield return RenderInspector();
+
+            var behaviorProperty = editor.serializedObject.FindProperty(nameof(PlayerInput.m_NotificationBehavior));
+            behaviorProperty.intValue = (int)PlayerNotifications.SendMessages;
+            editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            yield return RenderInspector();
+
+            LoadActions(asset, "first", "second");
+
+            behaviorProperty.intValue = (int)PlayerNotifications.InvokeUnityEvents;
+            editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            yield return RenderInspector();
+
+            Assert.That(playerInput.m_ActionEvents.Select(e => e.actionId),
+                Is.EquivalentTo(asset.Select(a => a.id.ToString())));
+        }
+        finally
+        {
+            Object.DestroyImmediate(asset);
+        }
+    }
+
+    // Behavior changes made through undo/redo don't go through the inspector's dropdown.
+    [UnityTest]
+    public IEnumerator ActionEventsAreListed_WhenInvokeUnityEventsIsRestoredByUndoRedo()
+    {
+        var asset = ScriptableObject.CreateInstance<InputActionAsset>();
+        try
+        {
+            LoadActions(asset, "first");
+
+            playerInput.m_Actions = asset;
+            playerInput.m_NotificationBehavior = PlayerNotifications.SendMessages;
+            editor = (PlayerInputEditor)UnityEditor.Editor.CreateEditor(playerInput);
+            yield return RenderInspector();
+
+            Undo.IncrementCurrentGroup();
+            editor.serializedObject.FindProperty(nameof(PlayerInput.m_NotificationBehavior)).intValue =
+                (int)PlayerNotifications.InvokeUnityEvents;
+            editor.serializedObject.ApplyModifiedProperties();
+            Undo.IncrementCurrentGroup();
+            yield return RenderInspector();
+
+            Assert.That(playerInput.m_ActionEvents.Select(e => e.actionId),
+                Is.EquivalentTo(asset.Select(a => a.id.ToString())));
+
+            Undo.PerformUndo();
+            yield return RenderInspector();
+            Assert.That(playerInput.m_NotificationBehavior, Is.EqualTo(PlayerNotifications.SendMessages));
+
+            LoadActions(asset, "first", "second");
+
+            Undo.PerformRedo();
+            yield return RenderInspector();
+            Assert.That(playerInput.m_NotificationBehavior, Is.EqualTo(PlayerNotifications.InvokeUnityEvents));
+
+            Assert.That(playerInput.m_ActionEvents.Select(e => e.actionId),
+                Is.EquivalentTo(asset.Select(a => a.id.ToString())));
+        }
+        finally
+        {
+            Object.DestroyImmediate(asset);
+        }
+    }
+}

Assets/Tests/InputSystem.Editor/PlayerInputEditorTests.cs.meta

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Fixed polling for interaction phases (such as `WasPerformedThisFrame`) being missed during `Update` due to interaction timeouts sometimes occurring during the later before-render period when a before-render device (such as an XR HMD) is added. This means that timeouts and interactions like Hold may now wait to perform until the next frame instead of the earliest chance during before-render. [UUM-147719](https://issuetracker.unity3d.com/product/unity/issues/guid/UUM-147719)
 - Fixed touch input from Unity Remote 5 being ignored in Unity 6000.5 and newer. [UUM-155327](https://issuetracker.unity3d.com/product/unity/issues/guid/UUM-155327)
 - Fixed actions enabled during startup, for example in an Entities system's `OnCreate`, being disabled when entering Play Mode with domain reload disabled and in Player builds. [UUM-151403](https://issuetracker.unity3d.com/product/unity/issues/guid/UUM-151403)
+- Fixed the Player Input component Inspector not showing the action map events after the Behavior is set to Invoke Unity Events, until the GameObject was selected again. [UUM-150956](https://issuetracker.unity3d.com/product/unity/issues/guid/UUM-150956)
 
 ## [1.20.1] - 2026-10-05
 

Packages/com.unity.inputsystem/CHANGELOG.md

@@ -213,7 +213,9 @@ public override void OnInspectorGUI()
             // Notifications/event section.
             EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_NotificationBehaviorProperty, m_NotificationBehaviorText);
-            if (EditorGUI.EndChangeCheck() || actionsWereChanged || !m_NotificationBehaviorInitialized)
+            // Also compare against the last handled behavior to catch changes made outside this inspector (undo, scripts).
+            if (EditorGUI.EndChangeCheck() || actionsWereChanged || !m_NotificationBehaviorInitialized ||
+                m_NotificationBehavior != (PlayerNotifications)m_NotificationBehaviorProperty.intValue)
                 OnNotificationBehaviorChange();
             switch ((PlayerNotifications)m_NotificationBehaviorProperty.intValue)
             {
@@ -451,18 +453,18 @@ private void OnNotificationBehaviorChange()
                     playerInput.m_DeviceRegainedEvent ??= new PlayerInput.DeviceRegainedEvent();
                     playerInput.m_ControlsChangedEvent ??= new PlayerInput.ControlsChangedEvent();
 
-                    if (areEventsDirty)
-                    {
-                        serializedObject.Update();
-
-                        // Force action refresh.
-                        m_ActionAssetInitialized = false;
-                        Refresh();
-                    }
+                    // The action event list is only kept up to date while the behavior is InvokeUnityEvents, so rebuild
+                    // it whenever we switch to it. Do it right away rather than deferring to the next repaint, so the
+                    // events show up in this same GUI pass.
+                    var enteringUnityEvents = !m_NotificationBehaviorInitialized ||
+                        m_NotificationBehavior != PlayerNotifications.InvokeUnityEvents;
+                    if (areEventsDirty || enteringUnityEvents)
+                        InitializeEditorComponent(false);
                     break;
                 }
             }
 
+            m_NotificationBehavior = notificationBehavior;
             m_NotificationBehaviorInitialized = true;
         }
 
@@ -655,6 +657,7 @@ void AddEntry(InputAction action, PlayerInput.ActionEvent actionEvent)
         [NonSerialized] private SerializedProperty m_ControlsChangedEventProperty;
 
         [NonSerialized] private bool m_NotificationBehaviorInitialized;
+        [NonSerialized] private PlayerNotifications m_NotificationBehavior;
         [NonSerialized] private bool m_ActionAssetInitialized;
 #if UNITY_6000_4_OR_NEWER
         [NonSerialized] private EntityId m_ActionAssetEntityId;

Packages/com.unity.inputsystem/InputSystem/Editor/Plugins/PlayerInput/PlayerInputEditor.cs

@@ -4547,6 +4547,7 @@ private static void RemovePlayModeCallbacks<TDelegate>(ref CallbackArray<TDelega
                     callbacks.RemoveCallback(callbacks[i]);
             }
         }
+
 #endif
 
         internal static ISavedState SaveAndResetState()