appium-flutter-driver/lib/commands/execute.ts

Appium Flutter driver

/* eslint-disable @typescript-eslint/no-non-null-assertion */
import type { FlutterDriver } from '../driver';
import { reConnectFlutterDriver } from '../sessions/session';
import {
  longTap,
  scroll,
  scrollIntoView,
  scrollUntilVisible,
  scrollUntilTapable
} from './execute/scroll';
import {
  waitFor,
  waitForAbsent,
  waitForTappable
} from './execute/wait';
import {
  assertVisible,
  assertNotVisible,
  assertTappable,
  type FinderInput
} from './assertions';

import { launchApp } from './../ios/app';
import B from 'bluebird';

const flutterCommandRegex = /^[\s]*flutter[\s]*:(.+)/;



// Define types for better type safety
type CommandHandler = (driver: FlutterDriver, ...args: any[]) => Promise<any>;
type CommandMap = Record<string, CommandHandler>;

interface DragAndDropParams {
  startX: string;
  startY: string;
  endX: string;
  endY: string;
  duration: string;
}

interface DiagnosticsOptions {
  subtreeDepth?: number;
  includeProperties?: boolean;
}



interface LongTapOptions {
  durationMilliseconds: number;
  frequency?: number;
}

interface OffsetOptions {
  offsetType: 'bottomLeft' | 'bottomRight' | 'center' | 'topLeft' | 'topRight';
}

// Extract command handlers into a separate object for better organization
const commandHandlers: CommandMap = {
  launchApp: async (driver, appId: string, opts = {}) => {
    const { arguments: args = [], environment: env = {} } = opts;
    await launchApp(driver.internalCaps.udid!, appId, args, env);
    await reConnectFlutterDriver.bind(driver)(driver.internalCaps);
  },
  connectObservatoryWsUrl: async (driver) => {
    await reConnectFlutterDriver.bind(driver)(driver.internalCaps);
  },
  checkHealth: async (driver) => (await driver.executeElementCommand('get_health')).status,
  getVMInfo: async (driver) => await driver.executeGetVMCommand(),
  getRenderTree: async (driver) => (await driver.executeElementCommand('get_render_tree')).tree,
  getOffset: async (driver, elementBase64: string, options: OffsetOptions) =>
    await driver.executeElementCommand('get_offset', elementBase64, options),
  waitForCondition: async (driver, conditionName: string) =>
    await driver.executeElementCommand('waitForCondition', '', { conditionName }),
  forceGC: async (driver) => {
    const response = await driver.socket!.call('_collectAllGarbage', {
      isolateId: driver.socket!.isolateId,
    }) as { type: string };
    if (response.type !== 'Success') {
      throw new Error(`Could not forceGC, response was ${JSON.stringify(response)}`);
    }
  },
  setIsolateId: async (driver, isolateId: string) => {
    driver.socket!.isolateId = isolateId;
    return await driver.socket!.call('getIsolate', { isolateId });
  },
  getIsolate: async (driver, isolateId?: string) =>
    await driver.executeGetIsolateCommand(isolateId || driver.socket!.isolateId!),
  clearTimeline: async (driver) => {
    const call1 = driver.socket!.call('_clearVMTimeline');
    const call2 = driver.socket!.call('clearVMTimeline');
    const response = await B.any([call1, call2]);
    if (response.type !== 'Success') {
      throw new Error(`Could not clear timeline, response was ${JSON.stringify(response)}`);
    }
  },
  getRenderObjectDiagnostics: async (driver, elementBase64: string, opts: DiagnosticsOptions = {}) => {
    const { subtreeDepth = 0, includeProperties = true } = opts;
    return await driver.executeElementCommand('get_diagnostics_tree', elementBase64, {
      diagnosticsType: 'renderObject',
      includeProperties,
      subtreeDepth,
    });
  },
  getWidgetDiagnostics: async (driver, elementBase64: string, opts: DiagnosticsOptions = {}) => {
    const { subtreeDepth = 0, includeProperties = true } = opts;
    return await driver.executeElementCommand('get_diagnostics_tree', elementBase64, {
      diagnosticsType: 'widget',
      includeProperties,
      subtreeDepth,
    });
  },
  getSemanticsId: async (driver, elementBase64: string) =>
    (await driver.executeElementCommand('get_semantics_id', elementBase64)).id,
  waitForAbsent: async (driver, finder: string, timeout?: number) =>
    await waitForAbsent(driver, finder, timeout),
  waitFor: async (driver, finder: string, timeout?: number) =>
    await waitFor(driver, finder, timeout),
  waitForTappable: async (driver, finder: string, timeout?: number) =>
    await waitForTappable(driver, finder, timeout),
  scroll: async (driver, finder: string, opts: any) =>
    await scroll(driver, finder, opts),
  scrollUntilVisible: async (driver, finder: string, opts: any) =>
    await scrollUntilVisible(driver, finder, opts),
  scrollUntilTapable: async (driver, finder: string, opts: any) =>
    await scrollUntilTapable(driver, finder, opts),
  scrollIntoView: async (driver, finder: string, opts: any) =>
    await scrollIntoView(driver, finder, opts),
  setTextEntryEmulation: async (driver, enabled: boolean) =>
    await driver.socket!.executeSocketCommand({ command: 'set_text_entry_emulation', enabled }),
  enterText: async (driver, text: string) =>
    await driver.socket!.executeSocketCommand({ command: 'enter_text', text }),
  requestData: async (driver, message: string) =>
    await driver.socket!.executeSocketCommand({ command: 'request_data', message }),
  longTap: async (driver, finder: string, durationOrOptions: LongTapOptions) =>
    await longTap(driver, finder, durationOrOptions),
  waitForFirstFrame: async (driver) =>
    await driver.executeElementCommand('waitForCondition', '', { conditionName: 'FirstFrameRasterizedCondition' }),
  setFrameSync: async (driver, enabled: boolean, durationMilliseconds: number) =>
    await driver.socket!.executeSocketCommand({
      command: 'set_frame_sync',
      enabled,
      timeout: durationMilliseconds,
    }),
  clickElement: async (driver, finder: string, opts: { timeout?: number } = {}) => {
    const { timeout = 1000 } = opts;
    return await driver.executeElementCommand('tap', finder, { timeout });
  },
  dragAndDropWithCommandExtension: async (driver, params: DragAndDropParams) =>
    await driver.socket!.executeSocketCommand({
      command: 'dragAndDropWithCommandExtension',
      ...params,
    }),
  assertVisible: async (driver, input: FinderInput, timeout = 5000) =>
    await assertVisible(driver, input, timeout),
  assertNotVisible: async (driver, input: FinderInput, timeout = 5000) =>
    await assertNotVisible(driver, input, timeout),
  assertTappable: async (driver, input: FinderInput, timeout = 5000) =>
    await assertTappable(driver, input, timeout),
  getTextWithCommandExtension: async (driver, params: { findBy: string }) =>
    await driver.socket!.executeSocketCommand({
      command: 'getTextWithCommandExtension',
      findBy: params.findBy,
    }),
};
export const execute = async function (
  this: FlutterDriver,
  rawCommand: string,
  args: any[],
) {
  const matching = rawCommand.match(flutterCommandRegex);
  if (!matching) {
    throw new Error(`Command not supported: "${rawCommand}"`);
  }

  const command = matching[1].trim();
  const handler = commandHandlers[command];

  if (!handler) {
    throw new Error(`Command not supported: "${rawCommand}"`);
  }

  return await handler(this, ...args);
};