refactor: consolidate android gesture backend selection

Author: thymikee

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

@@ -8,12 +8,10 @@ import { ANDROID_EMULATOR } from '../../../__tests__/test-utils/index.ts';
 import {
   ensureAndroidMultiTouchHelper,
   parseAndroidMultiTouchHelperOutput,
-  pinchAndroid,
   resetAndroidMultiTouchHelperInstallCache,
   rotateGestureAndroid,
   runAndroidMultiTouchHelperGesture,
   swipeGestureAndroid,
-  transformGestureAndroid,
 } from '../multitouch-helper.ts';
 import {
   withAndroidAdbProvider,
@@ -109,9 +107,7 @@ test('runAndroidMultiTouchHelperGesture encodes one-finger swipe payloads', asyn
       capturedPayload = JSON.parse(Buffer.from(args[6]!, 'base64').toString('utf8'));
       return {
         exitCode: 0,
-        stdout: [resultRecord({ ok: 'true', kind: 'swipe' }), 'INSTRUMENTATION_CODE: 0'].join(
-          '\n',
-        ),
+        stdout: [resultRecord({ ok: 'true', kind: 'swipe' }), 'INSTRUMENTATION_CODE: 0'].join('\n'),
         stderr: '',
       };
     },
@@ -166,66 +162,6 @@ test('runAndroidMultiTouchHelperGesture preserves helper failure messages', asyn
   );
 });
 
-test('swipeGestureAndroid and multi-touch gestures prefer provider-native touch injection', async () => {
-  const calls: unknown[] = [];
-  await withAndroidAdbProvider(
-    {
-      exec: async () => {
-        throw new Error('adb should not run when native touch is available');
-      },
-      touch: async (request) => {
-        calls.push(request);
-        return { backendDetail: 'native' };
-      },
-    },
-    { serial: ANDROID_EMULATOR.id },
-    async () => {
-      const swipe = await swipeGestureAndroid(ANDROID_EMULATOR, {
-        x1: 340,
-        y1: 400,
-        x2: 60,
-        y2: 400,
-        durationMs: 300,
-      });
-      const pinch = await pinchAndroid(ANDROID_EMULATOR, { scale: 2, x: 100, y: 200 });
-      const rotate = await rotateGestureAndroid(ANDROID_EMULATOR, {
-        degrees: -215,
-        x: 100,
-        y: 200,
-      });
-      const transform = await transformGestureAndroid(ANDROID_EMULATOR, {
-        x: 100,
-        y: 200,
-        dx: 30,
-        dy: -20,
-        scale: 1.5,
-        degrees: 35,
-      });
-
-      assert.equal(swipe?.backend, 'provider-native-touch');
-      assert.equal(pinch.backend, 'provider-native-touch');
-      assert.equal(rotate.backend, 'provider-native-touch');
-      assert.equal(transform.backend, 'provider-native-touch');
-    },
-  );
-
-  assert.deepEqual(calls, [
-    { kind: 'swipe', x1: 340, y1: 400, x2: 60, y2: 400, durationMs: 300 },
-    { kind: 'pinch', x: 100, y: 200, scale: 2, durationMs: undefined },
-    { kind: 'rotate', x: 100, y: 200, degrees: -215, durationMs: undefined },
-    {
-      kind: 'transform',
-      x: 100,
-      y: 200,
-      dx: 30,
-      dy: -20,
-      scale: 1.5,
-      degrees: 35,
-      durationMs: undefined,
-    },
-  ]);
-});
-
 test('swipeGestureAndroid falls back to adb input swipe when helper path is unavailable', async () => {
   const adbCalls: string[][] = [];
   const result = await withAndroidAdbProvider(

src/platforms/android/multitouch-helper.ts

@@ -120,27 +120,28 @@ export async function swipeGestureAndroid(
   device: DeviceInfo,
   options: AndroidSwipeGestureOptions,
 ): Promise<Record<string, unknown> | void> {
-  const providerTouch = resolveAndroidTouchInjector(device);
-  if (providerTouch) {
-    return {
-      backend: 'provider-native-touch',
-      ...((await providerTouch({ kind: 'swipe', ...options })) ?? {}),
-    };
-  }
-
-  try {
-    return await runAndroidMultiTouchGesture(device, { kind: 'swipe', ...options });
-  } catch (error) {
-    emitDiagnostic({
-      level: 'warn',
-      phase: 'android_swipe_helper_fallback',
-      data: {
-        error: normalizeError(error).message,
-      },
-    });
-    await swipeAndroid(device, options.x1, options.y1, options.x2, options.y2, options.durationMs);
-    return { backend: 'adb-input-swipe-fallback' };
-  }
+  return await performAndroidTouchGestureWithFallback(
+    device,
+    { kind: 'swipe', ...options },
+    async (error) => {
+      emitDiagnostic({
+        level: 'warn',
+        phase: 'android_swipe_helper_fallback',
+        data: {
+          error: normalizeError(error).message,
+        },
+      });
+      await swipeAndroid(
+        device,
+        options.x1,
+        options.y1,
+        options.x2,
+        options.y2,
+        options.durationMs,
+      );
+      return { backend: 'adb-input-swipe-fallback' };
+    },
+  );
 }
 
 export async function pinchAndroid(
@@ -151,7 +152,7 @@ export async function pinchAndroid(
     throw new AppError('INVALID_ARGS', 'gesture pinch requires scale > 0');
   }
   const center = await resolveGestureCenter(device, options.x, options.y);
-  return await runAndroidMultiTouchGesture(device, {
+  return await performAndroidTouchGesture(device, {
     kind: 'pinch',
     x: center.x,
     y: center.y,
@@ -175,7 +176,7 @@ export async function rotateGestureAndroid(
   }
   const center = await resolveGestureCenter(device, options.x, options.y);
   const degrees = options.degrees;
-  return await runAndroidMultiTouchGesture(device, {
+  return await performAndroidTouchGesture(device, {
     kind: 'rotate',
     x: center.x,
     y: center.y,
@@ -197,7 +198,7 @@ export async function transformGestureAndroid(
   if (![options.x, options.y, options.dx, options.dy].every(Number.isFinite)) {
     throw new AppError('INVALID_ARGS', 'gesture transform requires finite x y dx dy');
   }
-  return await runAndroidMultiTouchGesture(device, {
+  return await performAndroidTouchGesture(device, {
     kind: 'transform',
     x: options.x,
     y: options.y,
@@ -219,7 +220,19 @@ async function resolveGestureCenter(
   return { x: Math.round(size.width / 2), y: Math.round(size.height / 2) };
 }
 
-async function runAndroidMultiTouchGesture(
+async function performAndroidTouchGestureWithFallback(
+  device: DeviceInfo,
+  request: AndroidTouchGestureRequest,
+  fallback: (error: unknown) => Promise<Record<string, unknown> | void>,
+): Promise<Record<string, unknown> | void> {
+  try {
+    return await performAndroidTouchGesture(device, request);
+  } catch (error) {
+    return await fallback(error);
+  }
+}
+
+async function performAndroidTouchGesture(
   device: DeviceInfo,
   request: AndroidTouchGestureRequest,
 ): Promise<Record<string, unknown>> {
@@ -229,6 +242,13 @@ async function runAndroidMultiTouchGesture(
     return { backend: 'provider-native-touch', ...result };
   }
 
+  return await runAndroidMultiTouchHelperGestureForDevice(device, request);
+}
+
+async function runAndroidMultiTouchHelperGestureForDevice(
+  device: DeviceInfo,
+  request: AndroidTouchGestureRequest,
+): Promise<Record<string, unknown>> {
   const adb = resolveAndroidAdbExecutor(device);
   const artifact = await resolveAndroidMultiTouchHelperArtifact();
   const adbProvider = resolveAndroidAdbProvider(device);

test/integration/provider-scenarios/android-lifecycle.test.ts

@@ -85,6 +85,13 @@ test('Provider-backed integration Android touch provider handles multi-touch ges
       const client = world.daemon.client();
       await client.apps.open({ app: 'settings', ...world.selection });
 
+      await client.interactions.swipe({
+        from: { x: 340, y: 400 },
+        to: { x: 60, y: 400 },
+        durationMs: 300,
+        ...world.selection,
+      });
+
       const pinch = await client.interactions.pinch({
         scale: 2,
         x: 195,
@@ -118,6 +125,7 @@ test('Provider-backed integration Android touch provider handles multi-touch ges
       assert.equal(transform.backend, 'provider-native-touch');
 
       assert.deepEqual(world.touchInjectionCalls, [
+        { kind: 'swipe', x1: 340, y1: 400, x2: 60, y2: 400, durationMs: 300 },
         { kind: 'pinch', x: 195, y: 320, scale: 2, durationMs: undefined },
         { kind: 'rotate', x: 195, y: 320, degrees: 145, durationMs: undefined },
         {