fix: stabilize Android transform injection

Author: thymikee

android-multitouch-helper/src/main/java/com/callstack/agentdevice/multitouchhelper/MultiTouchInstrumentation.java

@@ -18,6 +18,9 @@ public final class MultiTouchInstrumentation extends Instrumentation {
   private static final int MAX_RADIUS = 1200;
   private static final int MIN_DURATION_MS = 16;
   private static final int MAX_DURATION_MS = 10_000;
+  private static final int MOVE_FRAME_INTERVAL_MS = 32;
+  private static final int MAX_MOVE_FRAMES = 60;
+  private static final boolean WAIT_FOR_INPUT_DISPATCH = false;
   private Bundle arguments;
 
   @Override
@@ -91,57 +94,83 @@ private int injectGesture(GestureSpec spec) {
     long eventTime = downTime;
     PointerPair start = pointerPairAt(spec, 0);
     PointerPair end = pointerPairAt(spec, 1);
+    PointerPair activePointers = start.firstOnly();
     int count = 0;
 
-    inject(
-        automation,
-        motionEvent(downTime, eventTime, MotionEvent.ACTION_DOWN, start.firstOnly()));
-    count += 1;
-    eventTime += 8;
-    inject(
-        automation,
-        motionEvent(
-            downTime,
-            eventTime,
-            MotionEvent.ACTION_POINTER_DOWN | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
-            start));
-    count += 1;
+    try {
+      inject(
+          automation,
+          motionEvent(downTime, eventTime, MotionEvent.ACTION_DOWN, activePointers));
+      count += 1;
+      eventTime += 8;
+      inject(
+          automation,
+          motionEvent(
+              downTime,
+              eventTime,
+              MotionEvent.ACTION_POINTER_DOWN | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
+              start));
+      count += 1;
+      activePointers = start;
+
+      int frameCount =
+          Math.max(
+              3,
+              Math.min(
+                  MAX_MOVE_FRAMES,
+                  Math.round(spec.durationMs / (float) MOVE_FRAME_INTERVAL_MS)));
+      for (int index = 1; index < frameCount; index += 1) {
+        double t = (double) index / (double) frameCount;
+        PointerPair frame = pointerPairAt(spec, t);
+        eventTime = downTime + Math.round(spec.durationMs * t);
+        inject(automation, motionEvent(downTime, eventTime, MotionEvent.ACTION_MOVE, frame));
+        count += 1;
+        activePointers = frame;
+      }
 
-    int frameCount = Math.max(3, Math.round(spec.durationMs / 16.0f));
-    for (int index = 1; index < frameCount; index += 1) {
-      double t = (double) index / (double) frameCount;
-      PointerPair frame = pointerPairAt(spec, t);
-      eventTime = downTime + Math.round(spec.durationMs * t);
-      inject(automation, motionEvent(downTime, eventTime, MotionEvent.ACTION_MOVE, frame));
+      eventTime = downTime + spec.durationMs;
+      inject(
+          automation,
+          motionEvent(
+              downTime,
+              eventTime,
+              MotionEvent.ACTION_POINTER_UP | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
+              end));
+      count += 1;
+      activePointers = end.firstOnly();
+      inject(
+          automation,
+          motionEvent(downTime, eventTime + 8, MotionEvent.ACTION_UP, activePointers));
       count += 1;
+      SystemClock.sleep(32);
+      return count;
+    } catch (RuntimeException error) {
+      if (count > 0) {
+        injectCancel(automation, downTime, eventTime + 16, activePointers);
+      }
+      throw error;
     }
-
-    eventTime = downTime + spec.durationMs;
-    inject(
-        automation,
-        motionEvent(
-            downTime,
-            eventTime,
-            MotionEvent.ACTION_POINTER_UP | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
-            end));
-    count += 1;
-    inject(
-        automation,
-        motionEvent(downTime, eventTime + 8, MotionEvent.ACTION_UP, end.firstOnly()));
-    count += 1;
-    return count;
   }
 
   private static void inject(UiAutomation automation, MotionEvent event) {
     try {
-      if (!automation.injectInputEvent(event, true)) {
+      if (!automation.injectInputEvent(event, WAIT_FOR_INPUT_DISPATCH)) {
         throw new IllegalStateException("injectInputEvent returned false");
       }
     } finally {
       event.recycle();
     }
   }
 
+  private static void injectCancel(
+      UiAutomation automation, long downTime, long eventTime, PointerPair pair) {
+    try {
+      inject(automation, motionEvent(downTime, eventTime, MotionEvent.ACTION_CANCEL, pair));
+    } catch (RuntimeException ignored) {
+      // Best-effort cleanup; preserve the original injection failure.
+    }
+  }
+
   private static MotionEvent motionEvent(long downTime, long eventTime, int action, PointerPair pair) {
     MotionEvent.PointerProperties[] properties =
         new MotionEvent.PointerProperties[pair.pointerCount];

src/platforms/android/__tests__/multitouch-helper.test.ts

@@ -59,9 +59,11 @@ test('parseAndroidMultiTouchHelperOutput returns final instrumentation gesture m
 
 test('runAndroidMultiTouchHelperGesture encodes protocol payload for instrumentation', async () => {
   let capturedArgs: string[] | undefined;
+  let capturedOptions: Parameters<AndroidAdbExecutor>[1];
   const result = await runAndroidMultiTouchHelperGesture({
-    adb: async (args) => {
+    adb: async (args, options) => {
       capturedArgs = args;
+      capturedOptions = options;
       return {
         exitCode: 0,
         stdout: [resultRecord({ ok: 'true', kind: 'rotate' }), 'INSTRUMENTATION_CODE: 0'].join(
@@ -96,6 +98,34 @@ test('runAndroidMultiTouchHelperGesture encodes protocol payload for instrumenta
     durationMs: 250,
   });
   assert.equal(capturedArgs.at(-1), manifest.instrumentationRunner);
+  assert.equal(capturedOptions?.timeoutMs, 90_000);
+});
+
+test('runAndroidMultiTouchHelperGesture preserves helper failure messages', async () => {
+  await assert.rejects(
+    () =>
+      runAndroidMultiTouchHelperGesture({
+        adb: async () => ({
+          exitCode: 1,
+          stdout: [
+            resultRecord({
+              ok: 'false',
+              errorType: 'java.lang.IllegalStateException',
+              message: 'injectInputEvent returned false',
+            }),
+            'INSTRUMENTATION_CODE: 1',
+          ].join('\n'),
+          stderr: '',
+        }),
+        request: { kind: 'pinch', x: 100, y: 200, scale: 1.5, radius: 120, durationMs: 250 },
+        packageName: manifest.packageName,
+        instrumentationRunner: manifest.instrumentationRunner,
+      }),
+    {
+      code: 'COMMAND_FAILED',
+      message: 'injectInputEvent returned false',
+    },
+  );
 });
 
 test('pinchAndroid, rotateGestureAndroid, and transformGestureAndroid prefer provider-native touch injection', async () => {

src/platforms/android/multitouch-helper.ts

@@ -22,7 +22,7 @@ const ANDROID_MULTITOUCH_HELPER_RUNNER =
   'com.callstack.agentdevice.multitouchhelper/.MultiTouchInstrumentation';
 const ANDROID_MULTITOUCH_HELPER_PROTOCOL = 'android-multitouch-helper-v1';
 const ANDROID_MULTITOUCH_HELPER_INSTALL_TIMEOUT_MS = 30_000;
-const ANDROID_MULTITOUCH_HELPER_GESTURE_TIMEOUT_MS = 15_000;
+const ANDROID_MULTITOUCH_HELPER_GESTURE_TIMEOUT_MS = 90_000;
 const ANDROID_MULTITOUCH_HELPER_DEFAULT_DURATION_MS = 300;
 const ANDROID_MULTITOUCH_HELPER_DEFAULT_RADIUS = 160;
 const ANDROID_MULTITOUCH_HELPER_ROTATE_MAX_DEGREES_PER_FRAME = 3;
@@ -309,6 +309,12 @@ export async function runAndroidMultiTouchHelperGesture(options: {
   try {
     output = parseAndroidMultiTouchHelperOutput(`${result.stdout}\n${result.stderr}`);
   } catch (error) {
+    if (
+      error instanceof AppError &&
+      error.message !== 'Android multi-touch helper did not return a final result'
+    ) {
+      throw error;
+    }
     throw new AppError(
       'COMMAND_FAILED',
       result.exitCode === 0