fix(flow-client): loading state muting based on trigger events

flow-client/src/main/java/com/vaadin/client/ApplicationConnection.java

@@ -90,8 +90,6 @@ public ApplicationConnection(
             Console.debug(
                     "Vaadin application servlet version: " + servletVersion);
         }
-
-        ConnectionIndicator.setState(ConnectionIndicator.LOADING);
     }
 
     /**
@@ -210,12 +208,10 @@ private native void publishJavascriptMethods(String applicationId,
             var ur = ap.@ApplicationConnection::registry.@com.vaadin.client.Registry::getURIResolver()();
             return ur.@com.vaadin.client.URIResolver::resolveVaadinUri(Ljava/lang/String;)(uriToResolve);
         });
-
         client.sendEventMessage = $entry(function(nodeId, eventType, eventData) {
             var sc = ap.@ApplicationConnection::registry.@com.vaadin.client.Registry::getServerConnector()();
             sc.@com.vaadin.client.communication.ServerConnector::sendEventMessage(ILjava/lang/String;Lelemental/json/JsonObject;)(nodeId,eventType,eventData);
         });
-
         client.initializing = false;
         client.exportedWebComponents = exportedWebComponents;
         $wnd.Vaadin.Flow.clients[applicationId] = client;

flow-client/src/main/java/com/vaadin/client/ConnectionIndicator.java

@@ -100,4 +100,48 @@ public static native void setProperty(String property, Object value)
             $wnd.Vaadin.connectionIndicator[property] = value;
         }
     }-*/;
+
+    /**
+     * Notifies the client-side connection state indicator that a loading
+     * operation has started.
+     * <p>
+     * This method triggers the {@link ConnectionIndicator#LOADING} state
+     * transition on the client side.
+     */
+    public static native void loadingStarted()
+    /*-{
+        if ($wnd.Vaadin.connectionState) {
+            $wnd.Vaadin.connectionState.loadingStarted();
+        }
+     }-*/;
+
+    /**
+     * Notifies the client-side connection state indicator that a loading
+     * operation has completed successfully.
+     * <p>
+     * When all requests finish, this method triggers the
+     * {@link ConnectionIndicator#CONNECTED} state transition on the client
+     * side.
+     */
+    public static native void loadingFinished()
+    /*-{
+        if ($wnd.Vaadin.connectionState) {
+            $wnd.Vaadin.connectionState.loadingFinished();
+        }
+     }-*/;
+
+    /**
+     * Notifies the client-side connection state indicator that a loading
+     * operation has encountered an error or failed.
+     * <p>
+     * If no requests are remaining, triggers the
+     * {@link ConnectionIndicator#CONNECTION_LOST} state transition on the
+     * client side.
+     */
+    public static native void loadingFailed()
+    /*-{
+        if ($wnd.Vaadin.connectionState) {
+            $wnd.Vaadin.connectionState.loadingFailed();
+        }
+     }-*/;
 }

flow-client/src/main/java/com/vaadin/client/DefaultRegistry.java

@@ -20,6 +20,7 @@
 import com.vaadin.client.communication.ConnectionStateHandler;
 import com.vaadin.client.communication.DefaultConnectionStateHandler;
 import com.vaadin.client.communication.Heartbeat;
+import com.vaadin.client.communication.LoadingIndicatorStateHandler;
 import com.vaadin.client.communication.MessageHandler;
 import com.vaadin.client.communication.MessageSender;
 import com.vaadin.client.communication.Poller;
@@ -87,6 +88,8 @@ public DefaultRegistry(ApplicationConnection connection,
         set(PushConfiguration.class, new PushConfiguration(this));
         set(ReconnectConfiguration.class, new ReconnectConfiguration(this));
         set(Poller.class, new Poller(this));
+        set(LoadingIndicatorStateHandler.class,
+                new LoadingIndicatorStateHandler(this));
     }
 
 }

flow-client/src/main/java/com/vaadin/client/Registry.java

@@ -19,6 +19,7 @@
 
 import com.vaadin.client.communication.ConnectionStateHandler;
 import com.vaadin.client.communication.Heartbeat;
+import com.vaadin.client.communication.LoadingIndicatorStateHandler;
 import com.vaadin.client.communication.MessageHandler;
 import com.vaadin.client.communication.MessageSender;
 import com.vaadin.client.communication.Poller;
@@ -319,6 +320,15 @@ public Poller getPoller() {
         return get(Poller.class);
     }
 
+    /**
+     * Gets the {@link LoadingIndicatorStateHandler} singleton.
+     *
+     * @return the {@link LoadingIndicatorStateHandler} singleton instance
+     */
+    public LoadingIndicatorStateHandler getLoadingIndicatorStateHandler() {
+        return get(LoadingIndicatorStateHandler.class);
+    }
+
     /**
      * Deletes and recreates resettable instances of registry singletons.
      */

flow-client/src/main/java/com/vaadin/client/communication/DefaultConnectionStateHandler.java

@@ -460,7 +460,16 @@ private void resolveTemporaryError(Type type) {
             scheduledReconnect.cancel();
             scheduledReconnect = null;
         }
-        ConnectionIndicator.setState(ConnectionIndicator.CONNECTED);
+        if (Type.HEARTBEAT.equals(type)) {
+            // Heartbeat never has loading indication, it is safe to assume
+            // that no other requests are in progress and set the `CONNECTED`
+            // state directly.
+            ConnectionIndicator.setState(ConnectionIndicator.CONNECTED);
+        } else {
+            // Let the loading indicator state handler check and remove
+            // the prior loading state indication if necessary.
+            registry.getLoadingIndicatorStateHandler().stopLoading();
+        }
 
         Console.debug("Re-established connection to server");
     }

flow-client/src/main/java/com/vaadin/client/communication/LoadingIndicatorStateHandler.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.client.communication;
+
+import com.google.gwt.core.client.Scheduler;
+
+import com.vaadin.client.ConnectionIndicator;
+import com.vaadin.client.Registry;
+import com.vaadin.client.flow.collection.JsCollections;
+import com.vaadin.client.flow.collection.JsSet;
+import com.vaadin.flow.shared.JsonConstants;
+
+/**
+ * Manages the state of loading indicator based on active RPC requests, event
+ * types, and lifecycle events.
+ * <p>
+ * This class ensures appropriate visual feedback (e.g., loading bar) is shown
+ * or hidden according to the current network conditions and request status. It
+ * is responsible for muting the loading indication when RPC requests are
+ * triggered by high-frequency UI events (mousemove and such) to avoid excessive
+ * visual noise in these cases.
+ */
+public class LoadingIndicatorStateHandler {
+    private final Registry registry;
+
+    private boolean loading = false;
+
+    private boolean showLoading = false;
+
+    // High-frequency events, whose related RPC requests are not expected
+    // to trigger loading indication.
+    private static final JsSet<String> SILENT_EVENT_TYPES = JsCollections.set();
+    {
+        JsCollections.array("keydown", "keypress", "keyup", "mousemove",
+                "pointermove", "pointerrawupdate", "touchmove", "beforeinput",
+                "input", "scroll", "wheel", "drag", "dragover")
+                .forEach(SILENT_EVENT_TYPES::add);
+    }
+
+    /**
+     * Creates a new instance connected to the given registry.
+     *
+     * @param registry
+     *            the global registry
+     */
+    public LoadingIndicatorStateHandler(Registry registry) {
+        this.registry = registry;
+    }
+
+    /**
+     * Updates the connection state to {@link ConnectionIndicator#LOADING} when
+     * a non-silent request starts.
+     */
+    public void startLoading() {
+        if (!showLoading) {
+            // The next request is muted, do not show loading.
+            return;
+        }
+
+        update();
+    }
+
+    /**
+     * Updates the connection state to {@link ConnectionIndicator#CONNECTED}
+     * when active requests finish.
+     */
+    public void stopLoading() {
+        if (registry.getRequestResponseTracker().hasActiveRequest()) {
+            // Some request is in progress, skip the current stop.
+            return;
+        }
+
+        // Reset the loading state
+        showLoading = false;
+
+        // Debounce the update to avoid hiding loading when a follow-up
+        // request is started or scheduled right away.
+        Scheduler.get().scheduleDeferred(this::update);
+    }
+
+    /**
+     * Processes an RPC message to determine if a loading indicator should be
+     * displayed.
+     *
+     * @param rpcType
+     *            the type of RPC request being processed
+     * @param eventType
+     *            for event RPC requests, the name of the event, otherwise
+     *            {@code null}
+     */
+    public void processMessage(String rpcType, String eventType) {
+        // Require at least one non-silent message to indicate loading for
+        // the next request.
+        boolean silent = JsonConstants.RPC_EVENT_TYPE.equals(rpcType)
+                && eventType != null && SILENT_EVENT_TYPES.has(eventType);
+        if (!silent) {
+            showLoading = true;
+        }
+    }
+
+    /**
+     * Applies the loading state change after a dirty check.
+     */
+    private void update() {
+        if (showLoading == loading) {
+            return;
+        }
+
+        loading = showLoading;
+        // Setting the loading state directly using
+        // `ConnectionIndicator.setState()` interferes with other loading
+        // parties
+        // (Flow router, Hilla requests), therefore `.loadingStarted()` /
+        // `.loadingFinished()` are preferred.
+        if (loading) {
+            ConnectionIndicator.loadingStarted();
+        } else {
+            ConnectionIndicator.loadingFinished();
+        }
+    }
+}

flow-client/src/main/java/com/vaadin/client/communication/MessageHandler.java

@@ -592,6 +592,7 @@ private void endRequestIfResponse(ValueMap json) {
             // End the request if the received message was a
             // response, not sent asynchronously
             registry.getRequestResponseTracker().endRequest();
+            registry.getLoadingIndicatorStateHandler().stopLoading();
         }
     }
 

flow-client/src/main/java/com/vaadin/client/communication/MessageSender.java

@@ -21,7 +21,6 @@
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.user.client.Timer;
 
-import com.vaadin.client.ConnectionIndicator;
 import com.vaadin.client.Console;
 import com.vaadin.client.Registry;
 import com.vaadin.flow.shared.ApplicationConstants;
@@ -137,7 +136,6 @@ private void doSendInvocationsToServer() {
                     + pushPendingMessage.toJson());
             JsonObject payload = pushPendingMessage;
             pushPendingMessage = null;
-            registry.getRequestResponseTracker().startRequest();
             sendPayload(payload);
             return;
         } else if (hasQueuedMessages()) {
@@ -156,7 +154,6 @@ private void doSendInvocationsToServer() {
             return;
         }
 
-        boolean showLoadingIndicator = serverRpcQueue.showLoadingIndicator();
         JsonArray reqJson = serverRpcQueue.toJson();
         serverRpcQueue.clear();
 
@@ -177,9 +174,7 @@ private void doSendInvocationsToServer() {
             resetTimer();
             extraJson.put(ApplicationConstants.RESYNCHRONIZE_ID, true);
         }
-        if (showLoadingIndicator) {
-            ConnectionIndicator.setState(ConnectionIndicator.LOADING);
-        }
+        registry.getLoadingIndicatorStateHandler().startLoading();
         send(reqJson, extraJson);
     }
 
@@ -193,7 +188,6 @@ private void doSendInvocationsToServer() {
      */
     protected void send(final JsonArray reqInvocations,
             final JsonObject extraJson) {
-        registry.getRequestResponseTracker().startRequest();
         send(preparePayload(reqInvocations, extraJson));
     }
 

flow-client/src/main/java/com/vaadin/client/communication/RequestResponseTracker.java

@@ -19,7 +19,6 @@
 import com.google.web.bindery.event.shared.EventBus;
 import com.google.web.bindery.event.shared.HandlerRegistration;
 
-import com.vaadin.client.ConnectionIndicator;
 import com.vaadin.client.Registry;
 import com.vaadin.client.communication.MessageSender.ResynchronizationState;
 import com.vaadin.client.gwt.com.google.web.bindery.event.shared.SimpleEventBus;
@@ -120,13 +119,6 @@ public void endRequest() {
             registry.getMessageSender().sendInvocationsToServer();
         }
 
-        // Always reset loading indicator when request ends.
-        // Client-side component will handle timing for each request
-        // independently.
-        // This ensures rapid successive requests get individual timing instead
-        // of accumulating time across requests.
-        ConnectionIndicator.setState(ConnectionIndicator.CONNECTED);
-
         fireEvent(new ResponseHandlingEndedEvent());
     }
 

flow-client/src/main/java/com/vaadin/client/communication/ServerConnector.java

@@ -244,6 +244,9 @@ public void sendReturnChannelMessage(int stateNodeId, int channelId,
     }
 
     private void sendMessage(JsonObject message) {
+        registry.getLoadingIndicatorStateHandler().processMessage(
+                message.getString(JsonConstants.RPC_TYPE),
+                message.getString(JsonConstants.RPC_EVENT_TYPE));
         ServerRpcQueue rpcQueue = registry.getServerRpcQueue();
         rpcQueue.add(message);
         rpcQueue.flush();

flow-client/src/test-gwt/java/com/vaadin/client/ClientEngineTestBase.java

@@ -8,6 +8,40 @@
  * from being run as a regular JVM unit test.
  */
 public abstract class ClientEngineTestBase extends GWTTestCase {
+    protected static native void createDummyConnectionState()
+    /*-{
+      if (!$wnd.Vaadin) {
+        $wnd.Vaadin = {};
+      }
+      if (!$wnd.Vaadin.connectionState) {
+        $wnd.Vaadin.connectionState = {
+          state: 'connected',
+          requestCount: 0,
+          setState: function(state) {
+            this.state = state;
+          },
+          loadingStarted: function() {
+            this.state = 'loading';
+            this.requestCount++;
+          },
+          loadingFinished: function() {
+            if (this.requestCount == 0) { return; }
+            this.requestCount--;
+            if (this.requestCount == 0) { this.state = 'connected'; }
+          },
+          loadingFailed: function() {
+            if (this.requestCount == 0) { return; }
+            this.requestCount--;
+            if (this.requestCount == 0) { this.state = 'connection-lost'; }
+          }
+        };
+      } else {
+        // reset to initial state
+        $wnd.Vaadin.connectionState.setState('connected');
+        $wnd.Vaadin.connectionState.requestCount = 0;
+      }
+    }-*/;
+
     @Override
     protected void gwtSetUp() throws Exception {
         installPolyfills();