[Android] Encode the original pointer count in messages that represent Android touch events (#178015)

Android touch events include updates to multiple pointers, but each
pointer data message sent from the embedder to the framework represents
a single pointer. So the Android embedder will send multiple messages
for each touch event, and the framework's AndroidViewController will
reassemble the messages and forward the resulting event to the platform
view.

The AndroidViewController tracks the number of active pointers in its
own local state. If that state is out of sync with the event handled by
the Android embedder, then the AndroidViewController may send duplicate
events to the platform view.

This PR encodes the Android touch event's pointer count in the messages
sent to the framework. This allows the AndroidViewController to reliably
determine whether it has received all of the pointer messages that
originated from an event.

Fixes flutter/flutter#176574

Author: jason-simmons

engine/src/flutter/shell/platform/android/io/flutter/embedding/android/AndroidTouchProcessor.java

@@ -106,9 +106,15 @@ public class AndroidTouchProcessor {
   @VisibleForTesting static final int DEFAULT_VERTICAL_SCROLL_FACTOR = 48;
   @VisibleForTesting static final int DEFAULT_HORIZONTAL_SCROLL_FACTOR = 48;
 
-  // This value must match the value in framework's platform_view.dart.
+  // These values must match the values in the framework's platform_views.dart.
   // This flag indicates whether the original Android pointer events were batched together.
   private static final int POINTER_DATA_FLAG_BATCHED = 1;
+  // This flag indicates that this message is part of a group of messages representing
+  // a change that affects multiple pointers.
+  private static final int POINTER_DATA_FLAG_MULTIPLE = 2;
+
+  // Bit shift for encoding the pointer count when using POINTER_DATA_FLAG_MULTIPLE
+  private static final int POINTER_DATA_MULTIPLE_POINTER_COUNT_SHIFT = 8;
 
   // The view ID for the only view in a single-view Flutter app.
   private static final int IMPLICIT_VIEW_ID = 0;
@@ -212,7 +218,10 @@ public boolean onTouchEvent(@NonNull MotionEvent event, @NonNull Matrix transfor
       // but it's the responsibility of a later part of the system to
       // ignore 0-deltas if desired.
       for (int p = 0; p < originalPointerCount; p++) {
-        addPointerForIndex(event, p, pointerChange, 0, transformMatrix, packet);
+        int pointerData =
+            POINTER_DATA_FLAG_MULTIPLE
+                | (originalPointerCount << POINTER_DATA_MULTIPLE_POINTER_COUNT_SHIFT);
+        addPointerForIndex(event, p, pointerChange, pointerData, transformMatrix, packet);
       }
     }
 

packages/flutter/lib/src/services/platform_views.dart

@@ -619,19 +619,32 @@ class _AndroidMotionEventConverter {
     final int pointerIdx = pointers.indexOf(event.pointer);
     final int numPointers = pointers.length;
 
-    // This value must match the value in engine's FlutterView.java.
+    // These values must match the values in the engine's AndroidTouchProcessor.java.
     // This flag indicates whether the original Android pointer events were batched together.
     const int kPointerDataFlagBatched = 1;
+    // This flag indicates that this event is part of a group of events representing a change
+    // that affects multiple pointers.
+    const int kPointerDataFlagMultiple = 2;
+
+    // Mask for extracting the flag value from the event's platformData
+    const int kPointerDataFlagMask = 0xff;
+    const int kPointerDataMultiplePointerCountShift = 8;
 
     // Android MotionEvent objects can batch information on multiple pointers.
     // Flutter breaks these such batched events into multiple PointerEvent objects.
     // When there are multiple active pointers we accumulate the information for all pointers
     // as we get PointerEvents, and only send it to the embedded Android view when
     // we see the last pointer. This way we achieve the same batching as Android.
-    if (event.platformData == kPointerDataFlagBatched ||
-        (isSinglePointerAction(event) && pointerIdx < numPointers - 1)) {
+    final int platformDataFlag = event.platformData & kPointerDataFlagMask;
+    if (platformDataFlag == kPointerDataFlagBatched) {
       return null;
     }
+    if (platformDataFlag == kPointerDataFlagMultiple) {
+      final int originalPointerCount = event.platformData >> kPointerDataMultiplePointerCountShift;
+      if (pointerIdx != originalPointerCount - 1) {
+        return null;
+      }
+    }
 
     final int? action = switch (event) {
       PointerDownEvent() when numPointers == 1 => AndroidViewController.kActionDown,
@@ -697,9 +710,6 @@ class _AndroidMotionEventConverter {
       },
     );
   }
-
-  bool isSinglePointerAction(PointerEvent event) =>
-      event is! PointerDownEvent && event is! PointerUpEvent;
 }
 
 class _CreationParams {

packages/flutter/test/services/platform_views_test.dart

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'package:flutter/gestures.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 
@@ -439,6 +440,62 @@ void main() {
       await viewController.setOffset(const Offset(10, 20));
       expect(viewsController.offsets, equals(<int, Offset>{}));
     });
+
+    testWidgets('motion event converter does not duplicate move events', (
+      WidgetTester tester,
+    ) async {
+      final List<MethodCall> log = <MethodCall>[];
+      tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
+        SystemChannels.platform_views,
+        (MethodCall methodCall) async {
+          log.add(methodCall);
+          return null;
+        },
+      );
+
+      final AndroidViewController viewController = PlatformViewsService.initSurfaceAndroidView(
+        id: 7,
+        viewType: 'web',
+        layoutDirection: TextDirection.ltr,
+      );
+      viewController.pointTransformer = (Offset offset) => offset;
+
+      const int pointerCount = 10;
+      for (int i = 0; i < pointerCount; i++) {
+        final PointerEvent event = PointerDownEvent(
+          timeStamp: const Duration(milliseconds: 1),
+          pointer: i,
+        );
+        viewController.dispatchPointerEvent(event);
+      }
+
+      // Pointer event platform data constant from _AndroidMotionEventConverter
+      const int kPointerDataFlagMultiple = 2;
+
+      for (int i = 0; i < pointerCount; i++) {
+        final PointerEvent event = PointerMoveEvent(
+          timeStamp: const Duration(milliseconds: 2),
+          pointer: i,
+          platformData: kPointerDataFlagMultiple | (pointerCount << 8),
+        );
+        viewController.dispatchPointerEvent(event);
+      }
+
+      // Indexes in the list returned by AndroidMotionEvent._asList
+      const int kAndroidMotionEventListIndexAction = 3;
+      const int kAndroidMotionEventListIndexPointerCount = 4;
+
+      final List<MethodCall> moveCalls = log.where((MethodCall call) {
+        final List<dynamic> args = call.arguments as List<dynamic>;
+        return call.method == 'touch' &&
+            args[kAndroidMotionEventListIndexAction] == AndroidViewController.kActionMove;
+      }).toList();
+
+      // The _AndroidMotionEventConverter should yield one touch event containing all of the pointers.
+      expect(moveCalls.length, equals(1));
+      final List<dynamic> moveArgs = moveCalls.single.arguments as List<dynamic>;
+      expect(moveArgs[kAndroidMotionEventListIndexPointerCount], equals(pointerCount));
+    });
   });
 
   group('iOS', () {