fix: unblock camera/avatar input after paste or Alt-Tab focus loss

The input block applied while text input is active was never released
when focus was lost mid-input (clipboard paste dialog, Alt-Tab, or
spawning into a World), leaving camera and avatar movement permanently
locked until restart.

Fixes #9502

Includes a regression test that fails without this fix.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: eordano

Explorer/Assets/DCL/SceneLoadingScreens/SceneLoadingScreenController.cs

@@ -31,6 +31,7 @@ public partial class SceneLoadingScreenController : ControllerBase<SceneLoadingS
         private SceneTips tips;
         private CancellationTokenSource? tipsRotationCancellationToken;
         private CancellationTokenSource? tipsFadeCancellationToken;
+        private bool inputsBlocked;
 
         // IntVariable causes deadlock occasionally.
         // There is a similar issue reported on the forum:https://discussions.unity.com/t/deadlock-freezing-issue-with-localizationsettings-stringdatabase-getlocalizedstring-under-multiple-concurrent-calls-on-mobile/1566794
@@ -122,6 +123,12 @@ protected override void OnViewShow()
         protected override void OnViewClose()
         {
             base.OnViewClose();
+
+            // The blocked inputs must be restored on every close path, so the release runs first,
+            // before any statement that can throw: the fade-out is skipped when the close intent
+            // is cancelled or fails, while OnViewClose is guaranteed by the MVC teardown.
+            UnblockUnwantedInputs();
+
             tipsRotationCancellationToken?.SafeCancelAndDispose();
             tipsFadeCancellationToken?.SafeCancelAndDispose();
 
@@ -130,7 +137,14 @@ protected override void OnViewClose()
             audioMixerVolumesController.UnmuteGroup(AudioMixerExposedParam.Chat_Volume);
 
             viewInstance!.ClearTips();
-            tips.Release();
+
+            // Tips is null until the first load completes: a close racing that load must not
+            // release a default instance, and a later close must not release the same tips twice.
+            if (tips.Tips != null)
+            {
+                tips.Release();
+                tips = default;
+            }
         }
 
         protected override async UniTask WaitForCloseIntentAsync(CancellationToken ct)
@@ -287,11 +301,17 @@ private async UniTaskVoid RotateTipsOverTimeAsync(TimeSpan frequency, Cancellati
 
         private void BlockUnwantedInputs()
         {
+            if (inputsBlocked) return;
+
+            inputsBlocked = true;
             inputBlock.Disable(InputMapComponent.BLOCK_USER_INPUT);
         }
 
         private void UnblockUnwantedInputs()
         {
+            if (!inputsBlocked) return;
+
+            inputsBlocked = false;
             inputBlock.Enable(InputMapComponent.BLOCK_USER_INPUT);
         }
     }

Explorer/Assets/DCL/SceneLoadingScreens/Tests/SceneLoadingScreenControllerInputBlockShould.cs

@@ -0,0 +1,256 @@
+using Arch.Core;
+using Cysharp.Threading.Tasks;
+using DCL.Audio;
+using DCL.Input;
+using DCL.Input.Component;
+using DCL.Prefs;
+using DCL.Utilities;
+using ECS.Abstract;
+using MVC;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Audio;
+using UnityEngine.TestTools;
+using Object = UnityEngine.Object;
+
+namespace DCL.SceneLoadingScreens.Tests
+{
+    /// <summary>
+    ///     Regression coverage for #9502: camera and avatar input stayed permanently blocked after the
+    ///     scene loading screen closed on a cancelled outer token (teleport superseded/aborted mid-load,
+    ///     e.g. spawning into a World via a coordinate link, or a long Alt-Tab stalling the fade).
+    ///     <see cref="InputMapComponent.BlockInput" />/<see cref="InputMapComponent.UnblockInput" /> are
+    ///     refcounted with no external audit or reset, so an acquire in <c>OnBeforeViewShow</c> that is
+    ///     never matched by a release on an abnormal close leaks the block forever - every subsequent
+    ///     "unblock" (e.g. a chat blur) only brings the counter from 2 back to 1, not to 0.
+    ///     See bugreports-early-aug/camera-avatar-locked-after-paste-alttab/{report.md,review.md}.
+    /// </summary>
+    public class SceneLoadingScreenControllerInputBlockShould
+    {
+        private const string VIEW_PREFAB_PATH = "Assets/DCL/SceneLoadingScreens/Assets/SceneLoadingScreen.prefab";
+        private const string AUDIO_MIXER_PATH = "Assets/DCL/Audio/Prefabs/GeneralAudioMixer.mixer";
+
+        private static readonly InputMapComponent.Kind ALL_KINDS = AllKinds();
+        private static readonly InputMapComponent.Kind BLOCKED_BY_LOADING_SCREEN = BlockUserInputMask();
+
+        // SceneLoadingScreenController.UpdateLocalizedTextAsync() is fired via .Forget() from both
+        // OnViewInstantiated and OnViewShow - a detached UniTaskVoid this test never has a handle to
+        // await. In a bare EditMode harness (no active localization catalog) its AsyncOperationHandle
+        // resolves to Failed a few Editor ticks later and logs "cannot load localized text" - unrelated
+        // to the input-block bug under test. Nothing else in the process pumps the Editor loop once a
+        // test's own awaits are done, so without an explicit flush that continuation can resolve
+        // arbitrarily far in the future (another fixture entirely) - past any ignoreFailingMessages
+        // window scoped only to [SetUp]/[TearDown] or even [OneTimeSetUp]/[OneTimeTearDown]. The fix is
+        // two-part: suppress for the whole fixture AND explicitly pump bounded frames at the tail of
+        // each test (FlushDeferredViewLogsAsync) so the log - if it fires at all - fires HERE, while
+        // suppression is still active, instead of leaking into an unrelated later test.
+        private const int FLUSH_FRAME_COUNT = 30;
+
+        private World world;
+        private SingleInstanceEntity inputMapEntity;
+        private IInputBlock inputBlock;
+        private SceneLoadingScreenView viewInstance;
+        private AudioMixerVolumesController audioMixerVolumesController;
+        private bool originalIgnoreFailingMessages;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            // The view's fire-and-forget localized-text refresh is unrelated to the input-block bug
+            // under test and can log in a bare Editor test context (no active localization init) -
+            // including from late async continuations that land between tests, so the suppression
+            // must span the whole fixture, not a single test.
+            originalIgnoreFailingMessages = LogAssert.ignoreFailingMessages;
+            LogAssert.ignoreFailingMessages = true;
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            LogAssert.ignoreFailingMessages = originalIgnoreFailingMessages;
+        }
+
+        // Pumps bounded Editor frames so any pending fire-and-forget continuation (see the comment
+        // above FLUSH_FRAME_COUNT) gets a chance to actually resolve and log before this test returns,
+        // rather than resolving later while some unrelated test/fixture is running. Tolerant by design:
+        // the message may fire 0..N times here (or not at all) - LogAssert.ignoreFailingMessages is what
+        // makes that acceptable, not an expectation that it must occur.
+        private static async UniTask FlushDeferredViewLogsAsync()
+        {
+            for (var i = 0; i < FLUSH_FRAME_COUNT; i++)
+                await UniTask.Yield();
+        }
+
+        [SetUp]
+        public void SetUp()
+        {
+            // SceneLoadingScreenController's ctor eagerly constructs a PersistentSetting<int>, which reads
+            // DCLPlayerPrefs.GetInt off the static dclPrefs backing field - never populated in a bare EditMode
+            // test process (RuntimeInitializeOnLoadMethod only fires in Play/Runtime). Inject an in-memory
+            // implementation via reflection, the established pattern for this exact gap (see
+            // ChatReactionRecentsServiceShould/HomeMarkerControllerShould).
+            var dclPrefsField = typeof(DCLPlayerPrefs).GetField("dclPrefs", BindingFlags.NonPublic | BindingFlags.Static);
+            dclPrefsField!.SetValue(null, new InMemoryDCLPlayerPrefs());
+
+            world = World.Create();
+            world.Create(new InputMapComponent(ALL_KINDS));
+            inputMapEntity = world.CacheInputMap();
+            inputBlock = new ECSInputBlock(world);
+
+            var viewPrefab = AssetDatabase.LoadAssetAtPath<SceneLoadingScreenView>(VIEW_PREFAB_PATH);
+            Assert.IsNotNull(viewPrefab, $"Could not load the real loading-screen prefab from {VIEW_PREFAB_PATH}");
+            viewInstance = Object.Instantiate(viewPrefab);
+
+            var audioMixer = AssetDatabase.LoadAssetAtPath<AudioMixer>(AUDIO_MIXER_PATH);
+            Assert.IsNotNull(audioMixer, $"Could not load the real audio mixer from {AUDIO_MIXER_PATH}");
+            audioMixerVolumesController = new AudioMixerVolumesController(audioMixer);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (viewInstance != null)
+                Object.DestroyImmediate(viewInstance.gameObject);
+
+            world.Dispose();
+
+            // Reset the static field so later tests in the same run aren't left with a stale in-memory
+            // prefs instance (mirrors the reset half of the same established pattern).
+            var dclPrefsField = typeof(DCLPlayerPrefs).GetField("dclPrefs", BindingFlags.NonPublic | BindingFlags.Static);
+            dclPrefsField!.SetValue(null, null);
+        }
+
+        [Test]
+        public async Task ReleaseInputBlockWhenCloseIntentIsCancelledAsync()
+        {
+            // The framework resets LogAssert state at test start, wiping any fixture/SetUp-scoped
+            // suppression - the flag must be raised inside the test body itself.
+            LogAssert.ignoreFailingMessages = true;
+
+            ISceneTipsProvider tipsProvider = Substitute.For<ISceneTipsProvider>();
+
+            tipsProvider.GetAsync(Arg.Any<CancellationToken>())
+                        .Returns(UniTask.FromResult(new SceneTips(TimeSpan.Zero, false, new List<SceneTips.Tip>())));
+
+            SceneLoadingScreenController controller = CreateController(tipsProvider);
+
+            using var cts = new CancellationTokenSource();
+            cts.Cancel();
+
+            // OnBeforeViewShow blocks input unconditionally on every show. The outer token is already
+            // cancelled, so WaitForCloseIntentAsync's "if (!ct.IsCancellationRequested) await FadeOutAsync(ct)"
+            // guard is never entered and the only release the unpatched code has (the last statement of
+            // FadeOutAsync) never runs - this is leak path 1 from report.md ("outer token cancelled").
+            await controller.LaunchViewLifeCycleAsync(new CanvasOrdering(CanvasOrdering.SortingLayer.Overlay, 0), CompletedParams(), cts.Token);
+
+            Assert.That(ActiveKinds(), Is.EqualTo(ALL_KINDS & ~BLOCKED_BY_LOADING_SCREEN),
+                "input should be blocked right after showing the loading screen");
+
+            // The MVC teardown (MVCManager.ShowOverlayAsync's finally) always calls HideViewAsync once the
+            // view has started showing, regardless of whether WaitForCloseIntentAsync threw, was cancelled,
+            // or returned normally - so OnViewClose is guaranteed to run here exactly as it does in production.
+            await ((IController)controller).HideViewAsync(CancellationToken.None);
+
+            Assert.That(ActiveKinds(), Is.EqualTo(ALL_KINDS),
+                "BLOCK_USER_INPUT must be released when the loading screen closes on a cancelled token - " +
+                "unpatched, this leaks +1 on the refcount forever (#9502)");
+
+            // Let the OnViewInstantiated/OnViewShow localized-text refreshes settle before TearDown
+            // destroys viewInstance, so any log they produce fires inside this test, not later.
+            await FlushDeferredViewLogsAsync();
+        }
+
+        [Test]
+        public async Task ReleaseInputBlockWhenCloseRacesTheInitialTipsLoadAsync()
+        {
+            // The framework resets LogAssert state at test start, wiping any fixture/SetUp-scoped
+            // suppression - the flag must be raised inside the test body itself.
+            LogAssert.ignoreFailingMessages = true;
+
+            ISceneTipsProvider tipsProvider = Substitute.For<ISceneTipsProvider>();
+
+            // The tips load never resolves during this test, so `tips` stays at its default value
+            // (Tips == null) for the whole run - exactly the close-races-the-initial-load scenario from
+            // review.md ("earliest-cancel variant... cold addressables make the tips window largest on
+            // first show") that made the first patch attempt's placement of the release - after
+            // tips.Release() - still leak, because tips.Release() throws on a default SceneTips before
+            // reaching it.
+            tipsProvider.GetAsync(Arg.Any<CancellationToken>()).Returns(UniTask.Never<SceneTips>(CancellationToken.None));
+
+            SceneLoadingScreenController controller = CreateController(tipsProvider);
+
+            // Deliberately not awaited: LaunchViewLifeCycleAsync runs synchronously through
+            // OnBeforeViewShow/OnViewShow and suspends inside LoadTipsAsync (awaiting a promise that
+            // never completes), so by the time control returns here the block has already been
+            // acquired and WaitForCloseIntentAsync is still in flight - matching the real
+            // MVCManager.ShowOverlayAsync race where the teardown's finally can call HideViewAsync while
+            // the orphaned lifecycle task is still suspended.
+            UniTask launch = controller.LaunchViewLifeCycleAsync(new CanvasOrdering(CanvasOrdering.SortingLayer.Overlay, 0), CompletedParams(), CancellationToken.None);
+
+            Assert.That(ActiveKinds(), Is.EqualTo(ALL_KINDS & ~BLOCKED_BY_LOADING_SCREEN),
+                "input should be blocked right after showing the loading screen");
+
+            try
+            {
+                await ((IController)controller).HideViewAsync(CancellationToken.None);
+            }
+            catch (NullReferenceException)
+            {
+                // Pre-existing, separate defect (review.md finding 1): unpatched OnViewClose() calls
+                // tips.Release() on a still-default `tips` and throws. That defect is not what is under
+                // test here - what matters is whether the input block was released before that
+                // statement could run at all, which is asserted below regardless of this exception.
+            }
+
+            Assert.That(ActiveKinds(), Is.EqualTo(ALL_KINDS),
+                "BLOCK_USER_INPUT must be released even when OnViewClose races the initial tips load - " +
+                "unpatched, this leaks +1 on the refcount forever (#9502)");
+
+            launch.Forget();
+
+            // Let the OnViewInstantiated/OnViewShow localized-text refreshes settle before TearDown
+            // destroys viewInstance, so any log they produce fires inside this test, not later.
+            await FlushDeferredViewLogsAsync();
+        }
+
+        private SceneLoadingScreenController CreateController(ISceneTipsProvider tipsProvider) =>
+            new (() => viewInstance, tipsProvider, TimeSpan.Zero, audioMixerVolumesController, inputBlock);
+
+        private static SceneLoadingScreenController.Params CompletedParams()
+        {
+            AsyncLoadProcessReport report = AsyncLoadProcessReport.Create(CancellationToken.None);
+            report.SetProgress(1f);
+            return new SceneLoadingScreenController.Params(report);
+        }
+
+        private InputMapComponent.Kind ActiveKinds() =>
+            inputMapEntity.GetInputMapComponent(world).Active;
+
+        private static InputMapComponent.Kind AllKinds()
+        {
+            InputMapComponent.Kind all = InputMapComponent.Kind.None;
+
+            foreach (InputMapComponent.Kind kind in InputMapComponent.VALUES)
+                all |= kind;
+
+            return all;
+        }
+
+        private static InputMapComponent.Kind BlockUserInputMask()
+        {
+            InputMapComponent.Kind mask = InputMapComponent.Kind.None;
+
+            foreach (InputMapComponent.Kind kind in InputMapComponent.BLOCK_USER_INPUT)
+                mask |= kind;
+
+            return mask;
+        }
+    }
+}