Fix emojify animations

Author: 0niel

lib/src/app/bootstrap.dart

@@ -17,6 +17,7 @@ import 'package:yandex_keyboard_desktop/src/app_ui/app_controls.dart';
 import 'package:yandex_keyboard_desktop/src/app_ui/app_tokens.dart';
 import 'package:yandex_keyboard_desktop/src/app/desktop_surface.dart';
 import 'package:yandex_keyboard_desktop/src/app/diagnostic_log.dart';
+import 'package:yandex_keyboard_desktop/src/app/frame_settle.dart';
 import 'package:yandex_keyboard_desktop/src/app/desktop_visual_preferences.dart';
 import 'package:yandex_keyboard_desktop/src/app/ios_bootstrap.dart';
 import 'package:yandex_keyboard_desktop/src/features/settings/presentation/settings_window.dart';
@@ -413,14 +414,14 @@ class _AppState extends State<App>
   Future<void> _showHotKeyErrorSurfaceNow() async {
     if (mounted && _surface != DesktopSurface.overlay) {
       setState(() => _surface = DesktopSurface.overlay);
-      await WidgetsBinding.instance.endOfFrame;
+      await settleFrame();
     }
     const size = Size(460, 96);
     await windowManager.setMinimumSize(size);
     await windowManager.setSize(size);
     await windowManager.setAlwaysOnTop(true);
     await windowManager.center();
-    await WidgetsBinding.instance.endOfFrame;
+    await settleFrame();
     await _showOverlayWindowInactive(widget.overlayGateway);
   }
 
@@ -464,6 +465,11 @@ class _AppState extends State<App>
   }
 
   Future<void> _handleWindowHiddenNow() async {
+    // Only react to the settings window being dismissed natively (its close
+    // button hides the shared window). Overlay-driven hides are orchestrated
+    // by the overlay itself; restoring here as well races the overlay's own
+    // placement queue and clobbers the window bounds mid-presentation.
+    if (_surface != DesktopSurface.settings) return;
     widget.textOperationGate.reset();
     if (_hotKeyErrorCode == null) await _restoreOverlayWindowNow();
   }
@@ -486,16 +492,23 @@ class _AppState extends State<App>
 
   Future<bool> _ensureOverlayHostSurface() async {
     var ready = false;
+    diag('ensureOverlayHostSurface: requested (surface=$_surface)');
     await _runSurfaceTransition(() async {
+      diag('ensureOverlayHostSurface: transition started');
       if (_surface == DesktopSurface.overlay) {
         ready = true;
         return;
       }
-      if (!await _confirmSettingsExitIfNeeded()) return;
+      if (!await _confirmSettingsExitIfNeeded()) {
+        diag('ensureOverlayHostSurface: discard declined');
+        return;
+      }
       if (!mounted) return;
       setState(() => _surface = DesktopSurface.overlay);
+      diag('ensureOverlayHostSurface: hiding settings window');
       await windowManager.hide();
-      await WidgetsBinding.instance.endOfFrame;
+      await settleFrame();
+      diag('ensureOverlayHostSurface: ready');
       ready = true;
     });
     return ready;
@@ -549,6 +562,16 @@ class _AppState extends State<App>
 
   Future<bool> _confirmSettingsExitIfNeeded() async {
     if (!widget.settingsController.state.isDirty) return true;
+    // The discard dialog renders inside the shared window; make sure it is
+    // visible and focused, otherwise the confirmation silently blocks the
+    // surface-transition queue while sitting in a background window.
+    if (_surface == DesktopSurface.settings) {
+      await _bestEffort(() async {
+        await _setNativeWindowCanActivate(widget.overlayGateway, true);
+        await windowManager.show();
+        await windowManager.focus();
+      });
+    }
     return await _settingsWindowKey.currentState?.confirmDiscardIfNeeded() ??
         false;
   }
@@ -643,7 +666,7 @@ class _AppState extends State<App>
     await _bestEffort(() => windowManager.setMovable(true));
     try {
       await _setNativeWindowCanActivate(widget.overlayGateway, true);
-      await WidgetsBinding.instance.endOfFrame;
+      await settleFrame();
       await windowManager.show();
       await windowManager.focus();
     } catch (_) {
@@ -675,6 +698,9 @@ class _AppState extends State<App>
         if (!await _confirmSettingsExitIfNeeded()) return;
       }
       setState(() => _surface = DesktopSurface.overlay);
+      // Hide the (large, activatable) settings window before morphing it
+      // into the compact overlay so the resize never plays out on screen.
+      await _bestEffort(windowManager.hide);
     }
     var resolvedTarget = targetHandle;
     if (resolvedTarget == null &&
@@ -691,7 +717,7 @@ class _AppState extends State<App>
     await OverlayWindowController.initialize(
       size: overlaySize,
     );
-    await WidgetsBinding.instance.endOfFrame;
+    await settleFrame();
     await _showOverlayWindowInactive(widget.overlayGateway);
   }
 
@@ -702,7 +728,7 @@ class _AppState extends State<App>
     );
     if (mounted && _surface != DesktopSurface.overlay) {
       setState(() => _surface = DesktopSurface.overlay);
-      await WidgetsBinding.instance.endOfFrame;
+      await settleFrame();
     }
     await OverlayWindowController.initialize(size: overlaySize);
     if (show) {

lib/src/app/frame_settle.dart

@@ -0,0 +1,23 @@
+import 'dart:async';
+
+import 'package:flutter/scheduler.dart';
+import 'package:flutter/widgets.dart';
+
+/// Completes after the next rendered frame so native window operations
+/// (show/resize) never present a stale surface.
+///
+/// While the app window is hidden Flutter reports `AppLifecycleState.hidden`
+/// and disables frame scheduling, so a plain `await endOfFrame` deadlocks
+/// until something else makes the window visible. This helper forces a frame
+/// in that state and additionally bounds the wait, so window orchestration
+/// queues can never wedge permanently.
+Future<void> settleFrame({
+  Duration timeout = const Duration(milliseconds: 350),
+}) {
+  final binding = WidgetsBinding.instance;
+  if (!binding.framesEnabled &&
+      binding.schedulerPhase == SchedulerPhase.idle) {
+    binding.scheduleForcedFrame();
+  }
+  return binding.endOfFrame.timeout(timeout, onTimeout: () {});
+}

lib/src/features/text_assistant/presentation/overlay_presenter.dart

@@ -6,17 +6,21 @@ class OverlayPresenter {
   VoidCallback? _onShow;
   Future<bool> Function()? _ensureHostSurface;
 
+  // Note: comparisons use == rather than identical(): attach/detach receive
+  // fresh tear-offs of the same instance method, which are equal but never
+  // identical. With identical() a disposed overlay could never detach itself,
+  // leaving _onShow pointing at a defunct State (so hotkeys silently no-op).
   void attach(VoidCallback onShow) => _onShow = onShow;
 
   void detach(VoidCallback onShow) {
-    if (identical(_onShow, onShow)) _onShow = null;
+    if (_onShow == onShow) _onShow = null;
   }
 
   void attachHostGuard(Future<bool> Function() ensureHostSurface) =>
       _ensureHostSurface = ensureHostSurface;
 
   void detachHostGuard(Future<bool> Function() ensureHostSurface) {
-    if (identical(_ensureHostSurface, ensureHostSurface)) {
+    if (_ensureHostSurface == ensureHostSurface) {
       _ensureHostSurface = null;
     }
   }

lib/src/features/text_assistant/presentation/text_assistant_overlay.dart

@@ -6,6 +6,7 @@ import 'package:lucide_flutter/lucide_flutter.dart';
 import 'package:provider/provider.dart';
 import 'package:window_manager/window_manager.dart';
 import 'package:yandex_keyboard_desktop/src/app/diagnostic_log.dart';
+import 'package:yandex_keyboard_desktop/src/app/frame_settle.dart';
 import 'package:yandex_keyboard_desktop/src/platform/overlay/overlay_interaction_channel.dart';
 import 'package:yandex_keyboard_desktop/src/platform/overlay/overlay_window_gateway.dart';
 import 'package:yandex_keyboard_desktop/src/features/text_assistant/application/text_replacement_controller.dart';
@@ -510,6 +511,11 @@ class TextAssistantOverlayState extends State<TextAssistantOverlay> {
         _noticeKindForState(controller.state) != kind) {
       return;
     }
+    // Busy stages emit several states that all map to the same notice kind
+    // (loading). Re-running the whole native placement for each of them
+    // (SetWindowPos + FRAMECHANGED + ShowWindow) makes the loading animation
+    // stutter, so skip when this notice is already presented.
+    if (_presentedNoticeKind == kind && _sessionShown) return;
     final desiredSize = noticeWindowSizeFor(
       MediaQuery.maybeOf(context)?.textScaler ?? TextScaler.noScaling,
       kind: kind,
@@ -548,9 +554,14 @@ class TextAssistantOverlayState extends State<TextAssistantOverlay> {
       );
       if (!_placementIsCurrent(generation)) return false;
       final previousBounds = _lastNativeBounds;
-      if (!freshPresentation &&
-          previousBounds != null &&
-          previousBounds != placement.nativeBounds) {
+      // Only animate pure moves: every animation step that changes the window
+      // size forces a synchronous swapchain resize, which visibly stutters
+      // any in-flight content animation (e.g. the processing indicator).
+      final isPureMove = previousBounds != null &&
+          previousBounds != placement.nativeBounds &&
+          (previousBounds.width - placement.nativeBounds.width).abs() < 1 &&
+          (previousBounds.height - placement.nativeBounds.height).abs() < 1;
+      if (!freshPresentation && isPureMove) {
         await _animateNativeBounds(
           nativePlacement,
           placement,
@@ -586,7 +597,7 @@ class TextAssistantOverlayState extends State<TextAssistantOverlay> {
     await windowManager.setMinimumSize(fittedSize);
     if (!_placementIsCurrent(generation)) return false;
     if (freshPresentation) _replayEntrance();
-    await WidgetsBinding.instance.endOfFrame;
+    await settleFrame();
     if (!_placementIsCurrent(generation)) return false;
     if (gateway case final NativeOwnedOverlayActivationGateway activation) {
       await activation.showOwnedWindowInactive();

test/features/text_assistant/presentation/overlay_presenter_test.dart

@@ -62,4 +62,46 @@ void main() {
 
     expect(await presenter.ensureHostSurface(), isTrue);
   });
+
+  test('detach accepts a fresh tear-off of the attached instance method',
+      () async {
+    // A disposed overlay State detaches with a new tear-off of the same
+    // method; it must still clear the stored callback or hotkeys keep
+    // invoking a defunct State (regression: settings left open broke the
+    // overlay shortcut until the settings window was closed via its button).
+    final presenter = OverlayPresenter();
+    final host = _ShowHost();
+    presenter.attach(host.show);
+    presenter.detach(host.show);
+    var restored = 0;
+    presenter.attachHostGuard(() async {
+      restored++;
+      return true;
+    });
+
+    presenter.show();
+    await pumpEventQueue();
+
+    expect(host.shown, 0);
+    expect(restored, 1);
+  });
+
+  test('detach ignores a callback from a different host', () async {
+    final presenter = OverlayPresenter();
+    final attached = _ShowHost();
+    final other = _ShowHost();
+    presenter.attach(attached.show);
+    presenter.detach(other.show);
+
+    presenter.show();
+
+    expect(attached.shown, 1);
+    expect(other.shown, 0);
+  });
+}
+
+final class _ShowHost {
+  var shown = 0;
+
+  void show() => shown++;
 }