@aiot-toolkit/emulator 2.0.6-beta.1 → 2.0.6-beta.10

package/lib/vvd/grpc/index.js

@@ -3,18 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.GrpcEmulator = exports.AuthorizationKey = void 0;
 exports.createGrpcClient = createGrpcClient;
-exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
 var _protoLoader = require("@grpc/proto-loader");
 var _grpcError = require("./grpcError");
 var _grpcJs = require("@grpc/grpc-js");
+var _protoTypes = require("./types/proto-types");
+var _connectivityState = require("@grpc/grpc-js/build/src/connectivity-state");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// eslint-disable-next-line no-restricted-imports
+
+const AuthorizationKey = exports.AuthorizationKey = 'Authorization';
 class GrpcEmulator {
   connected = false;
   constructor(eConf, protoPath) {
+    let ip = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '127.0.0.1';
     this.eConf = eConf;
     this.protoPath = protoPath;
+    this.ip = ip;
     this.token = eConf['grpc.token'];
     const packageDefinition = (0, _protoLoader.loadSync)(this.protoPath, {
       keepCase: true,
@@ -23,51 +30,89 @@ class GrpcEmulator {
       defaults: true,
       oneofs: true
     });
-    this.deadline = new Date();
-    this.deadline.setMinutes(this.deadline.getMinutes() + 2);
     this.controller = (0, _grpcJs.loadPackageDefinition)(packageDefinition).android.emulation.control;
     const mateInfo = new _grpcJs.Metadata();
-    mateInfo.set('Authorization', `Bearer ${this.token}`);
+    mateInfo.set(AuthorizationKey, `Bearer ${this.token}`);
     this.authMate = mateInfo;
-    this.client = new this.controller.EmulatorController(`127.0.0.1:${eConf['grpc.port']}`, _grpcJs.credentials.createInsecure());
+    this.client = new this.controller.EmulatorController(`${this.ip}:${eConf['grpc.port']}`, _grpcJs.credentials.createInsecure(), {
+      'grpc.max_receive_message_length': 32 * 1024 * 1024,
+      // 32MB
+      'grpc.max_send_message_length': 32 * 1024 * 1024 // 32MB
+    });
+    this.uiClient = new this.controller.UiController(`127.0.0.1:${eConf['grpc.port']}`, _grpcJs.credentials.createInsecure());
   }
   close() {
+    this.screenshotStream?.destroy();
+    this.logcatStream?.destroy();
+    this.client.getChannel().close();
     this.client.close();
   }
   getAuthMeta() {
-    const token = this.eConf['grpc.token'];
-    const mateInfo = new _grpcJs.Metadata();
-    mateInfo.set('Authorization', `Bearer ${token}`);
-    return mateInfo;
+    return this.authMate;
   }
-  waitForReady() {
+  async waitForReady() {
     if (this.connected) {
-      return Promise.resolve(true);
+      return true;
     }
-    return new Promise((resolve, reject) => {
-      this.client.waitForReady(this.deadline, err => {
-        if (err) {
-          this.connected = false;
-          console.error(err);
-          return reject(err);
+    const channel = this.client.getChannel();
+    const curState = channel.getConnectivityState(true);
+    if (curState === _connectivityState.ConnectivityState.READY) {
+      return true;
+    }
+    const {
+      resolve,
+      reject,
+      promise
+    } = Promise.withResolvers();
+    let count = 0;
+    const watcher = () => {
+      if (++count >= 5) {
+        return reject(new Error('gRPC connection failed'));
+      }
+      const deadline = new Date();
+      deadline.setMinutes(deadline.getMinutes() + 2); // 2 minutes timeout
+
+      channel.watchConnectivityState(curState, deadline, e => {
+        if (e) {
+          reject(e);
+        }
+        const newState = channel.getConnectivityState(true);
+        switch (newState) {
+          case _connectivityState.ConnectivityState.TRANSIENT_FAILURE:
+            reject(new Error('gRPC connection failed'));
+            break;
+          case _connectivityState.ConnectivityState.READY:
+            this.connected = true;
+            resolve(true);
+            break;
+          case _connectivityState.ConnectivityState.SHUTDOWN:
+            reject(new Error('gRPC connection shutdown'));
+            break;
+          case _connectivityState.ConnectivityState.CONNECTING:
+            watcher();
+          default:
+            break;
         }
-        this.connected = true;
-        resolve(true);
       });
-    });
+    };
+    watcher();
+    return promise;
   }
-  async startStream(onStreamScreenshot) {
+  async streamScreenshot(imageFormat) {
     await this.waitForReady();
     if (this.screenshotStream) {
       this.screenshotStream.destroy();
     }
-    this.screenshotStream = this.client.streamScreenshot(this.controller.Image, this.authMate);
-    this.screenshotStream.on('data', response => {
-      onStreamScreenshot(response.image);
-    });
-    this.screenshotStream.on('error', err => {
-      console.error(err.message);
+    const params = imageFormat || {
+      format: _protoTypes.ImageFormatType.PNG
+    };
+    this.screenshotStream = this.client.streamScreenshot(params, this.authMate);
+    // don't delete it, otherwise crash process when emulator exit
+    this.screenshotStream.on('error', () => {
+      // TODO: not care at now
+      // console.error('streamScreenshot error:', err)
     });
+    return this.screenshotStream;
   }
   getScreenshot() {
     return new Promise((resolve, reject) => {
@@ -109,9 +154,60 @@ class GrpcEmulator {
       if (err) console.error(err);
     });
   }
+  showExtendedControls() {
+    let paneIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    if (!this.uiClient) return Promise.reject('UiController not available');
+    return new Promise((resolve, reject) => {
+      this.uiClient.showExtendedControls({
+        index: paneIndex
+      }, this.authMate, (err, response) => {
+        if (err) return reject(err);
+        resolve(response);
+      });
+    });
+  }
+  closeExtendedControls() {
+    if (!this.uiClient) return Promise.reject('UiController not available');
+    return new Promise((resolve, reject) => {
+      this.uiClient.closeExtendedControls({}, this.authMate, (err, response) => {
+        if (err) return reject(err);
+        resolve(response);
+      });
+    });
+  }
+  setSensor(sensorValue) {
+    if (!this.client) return Promise.reject('grpc client not available');
+    return new Promise((resolve, reject) => {
+      this.client.setSensor(sensorValue, this.authMate, (err, response) => {
+        if (err) return reject(err);
+        resolve(response);
+      });
+    });
+  }
+  getSensor(sensorValue) {
+    if (!this.client) return Promise.reject('grpc client not available');
+    return new Promise((resolve, reject) => {
+      this.client.getSensor(sensorValue, this.authMate, (err, response) => {
+        if (err) return reject(err);
+        resolve(response);
+      });
+    });
+  }
+  async streamLogcat(params) {
+    await this.waitForReady();
+    if (this.logcatStream) {
+      this.logcatStream.destroy();
+    }
+    const logMessage = params || {};
+    this.logcatStream = this.client.streamLogcat(logMessage, this.authMate);
+    this.logcatStream.on('error', err => {
+      console.error('streamLogcat error:', err?.message || err);
+    });
+    return this.logcatStream;
+  }
 }
-exports.default = GrpcEmulator;
+exports.GrpcEmulator = GrpcEmulator;
 function createGrpcClient(eConf) {
-  const protoPath = _path.default.join(__dirname, '../../static/proto/emulator_controller.proto');
+  const protoPath = [_path.default.resolve(__dirname, '../../static/proto/emulator_controller.proto'), _path.default.resolve(__dirname, '../../static/proto/ui_controller_service.proto')];
   return new GrpcEmulator(eConf, protoPath);
 }

package/lib/vvd/grpc/types/GrpcClient.d.ts

@@ -1,4 +1,45 @@
-import { Client } from '@grpc/grpc-js';
+import { Client, Metadata, ServiceError, ClientUnaryCall } from '@grpc/grpc-js';
+import type { PhysicalModelValue, ClipData, BatteryState, GpsState, Fingerprint, TouchEvent, PhoneCall, PhoneResponse, SmsMessage, PhoneNumber, EmulatorStatus, ImageFormat, Image, AudioFormat, LogMessage, VmRunState, DisplayConfigurations, BrightnessValue, DisplayMode, RotationRadian, Velocity, Posture, SensorValue, KeyboardEvent, MouseEvent } from './proto-types';
 export interface GrpcClient extends Client {
-    [i: string]: any;
+    setSensor(request: SensorValue, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getSensor(request: SensorValue, metadata: Metadata, callback: (error: ServiceError | null, response: SensorValue) => void): ClientUnaryCall;
+    streamSensor(request: SensorValue, metadata: Metadata): NodeJS.ReadStream;
+    setPhysicalModel(request: PhysicalModelValue, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getPhysicalModel(request: PhysicalModelValue, metadata: Metadata, callback: (error: ServiceError | null, response: PhysicalModelValue) => void): ClientUnaryCall;
+    streamPhysicalModel(request: PhysicalModelValue, metadata: Metadata): NodeJS.ReadStream;
+    setClipboard(request: ClipData, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getClipboard(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: ClipData) => void): ClientUnaryCall;
+    streamClipboard(request: {}, metadata: Metadata): NodeJS.ReadStream;
+    setBattery(request: BatteryState, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getBattery(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: BatteryState) => void): ClientUnaryCall;
+    setGps(request: GpsState, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getGps(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: GpsState) => void): ClientUnaryCall;
+    sendFingerprint(request: Fingerprint, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    sendKey(request: KeyboardEvent, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    sendTouch(request: TouchEvent, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    sendMouse(request: MouseEvent, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    injectWheel(metadata: Metadata): NodeJS.WritableStream;
+    streamInputEvent(metadata: Metadata): NodeJS.WritableStream;
+    sendPhone(request: PhoneCall, metadata: Metadata, callback: (error: ServiceError | null, response: PhoneResponse) => void): ClientUnaryCall;
+    sendSms(request: SmsMessage, metadata: Metadata, callback: (error: ServiceError | null, response: PhoneResponse) => void): ClientUnaryCall;
+    setPhoneNumber(request: PhoneNumber, metadata: Metadata, callback: (error: ServiceError | null, response: PhoneResponse) => void): ClientUnaryCall;
+    getStatus(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: EmulatorStatus) => void): ClientUnaryCall;
+    getScreenshot(request: ImageFormat, metadata: Metadata, callback: (error: ServiceError | null, response: Image) => void): ClientUnaryCall;
+    streamScreenshot(request: ImageFormat, metadata: Metadata): NodeJS.ReadStream;
+    streamAudio(request: AudioFormat, metadata: Metadata): NodeJS.ReadStream;
+    injectAudio(metadata: Metadata): NodeJS.WritableStream;
+    getLogcat(request: LogMessage, metadata: Metadata, callback: (error: ServiceError | null, response: LogMessage) => void): ClientUnaryCall;
+    streamLogcat(request: LogMessage, metadata: Metadata): NodeJS.ReadStream;
+    setVmState(request: VmRunState, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getVmState(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: VmRunState) => void): ClientUnaryCall;
+    setDisplayConfigurations(request: DisplayConfigurations, metadata: Metadata, callback: (error: ServiceError | null, response: DisplayConfigurations) => void): ClientUnaryCall;
+    getDisplayConfigurations(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: DisplayConfigurations) => void): ClientUnaryCall;
+    streamNotification(request: {}, metadata: Metadata): NodeJS.ReadStream;
+    getBrightness(request: BrightnessValue, metadata: Metadata, callback: (error: ServiceError | null, response: BrightnessValue) => void): ClientUnaryCall;
+    setBrightness(request: BrightnessValue, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getDisplayMode(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: DisplayMode) => void): ClientUnaryCall;
+    setDisplayMode(request: DisplayMode, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    rotateVirtualSceneCamera(request: RotationRadian, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    setVirtualSceneCameraVelocity(request: Velocity, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    setPosture(request: Posture, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
 }

package/lib/vvd/grpc/types/UiControllerClient.d.ts

@@ -0,0 +1,23 @@
+import { Metadata, ServiceError, ClientUnaryCall } from '@grpc/grpc-js';
+export interface PaneEntry {
+    index: number;
+}
+export interface ThemingStyle {
+    style: number;
+}
+export interface ExtendedControlsStatus {
+    visibilityChanged: boolean;
+}
+export interface UserConfigEntry {
+    key: string;
+    value: string;
+}
+export interface UserConfig {
+    entries: UserConfigEntry[];
+}
+export interface UiControllerClient {
+    showExtendedControls(request: PaneEntry, metadata: Metadata, callback: (error: ServiceError | null, response: ExtendedControlsStatus) => void): ClientUnaryCall;
+    closeExtendedControls(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: ExtendedControlsStatus) => void): ClientUnaryCall;
+    setUiTheme(request: ThemingStyle, metadata: Metadata, callback: (error: ServiceError | null, response: {}) => void): ClientUnaryCall;
+    getUserConfig(request: {}, metadata: Metadata, callback: (error: ServiceError | null, response: UserConfig) => void): ClientUnaryCall;
+}

package/lib/vvd/grpc/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './GrpcClient';
+export * from './proto-types';
+export * from './UiControllerClient';

package/lib/vvd/grpc/types/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _GrpcClient = require("./GrpcClient");
+Object.keys(_GrpcClient).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _GrpcClient[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _GrpcClient[key];
+    }
+  });
+});
+var _protoTypes = require("./proto-types");
+Object.keys(_protoTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _protoTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _protoTypes[key];
+    }
+  });
+});
+var _UiControllerClient = require("./UiControllerClient");
+Object.keys(_UiControllerClient).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _UiControllerClient[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _UiControllerClient[key];
+    }
+  });
+});

package/lib/vvd/grpc/types/proto-types.d.ts

@@ -0,0 +1,178 @@
+export interface PhysicalModelValue {
+    target: number;
+    status?: number;
+    value?: {
+        data: number[];
+    };
+}
+export interface ClipData {
+    text: string;
+}
+export interface BatteryState {
+    hasBattery: boolean;
+    isPresent: boolean;
+    charger: number;
+    chargeLevel: number;
+    health: number;
+    status: number;
+}
+export interface GpsState {
+    passiveUpdate: boolean;
+    latitude: number;
+    longitude: number;
+    speed?: number;
+    bearing?: number;
+    altitude?: number;
+    satellites?: number;
+}
+export interface Fingerprint {
+    isTouching: boolean;
+    touchId: number;
+}
+export interface TouchEvent {
+    touches: Array<{
+        x: number;
+        y: number;
+        identifier: number;
+        pressure: number;
+        touch_major?: number;
+        touch_minor?: number;
+        expiration?: number;
+    }>;
+    display?: number;
+}
+export interface PhoneCall {
+    operation: number;
+    number: string;
+}
+export interface PhoneResponse {
+    response: number;
+}
+export interface SmsMessage {
+    srcAddress: string;
+    text: string;
+}
+export interface PhoneNumber {
+    number: string;
+}
+export interface EmulatorStatus {
+    version: string;
+    uptime: number;
+    booted: boolean;
+    vmConfig: any;
+    hardwareConfig: Record<string, any>;
+}
+export interface ImageFormat {
+    format: number;
+    rotation?: any;
+    width?: number;
+    height?: number;
+    display?: number;
+    transport?: any;
+}
+export interface Image {
+    format: ImageFormat;
+    image: Buffer;
+    seq?: number;
+    timestampUs?: number;
+}
+export interface AudioFormat {
+    samplingRate: number;
+    channels: number;
+    format: number;
+    mode?: number;
+}
+export interface LogMessage {
+    contents?: string;
+    start?: number;
+    next?: number;
+    sort?: number;
+    entries?: any[];
+}
+export interface VmRunState {
+    state: number;
+}
+export interface DisplayConfigurations {
+    displays: any[];
+    userConfigurable: number;
+    maxDisplays: number;
+}
+export interface BrightnessValue {
+    target: number;
+    value: number;
+}
+export interface DisplayMode {
+    value: number;
+}
+export interface RotationRadian {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Velocity {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Posture {
+    value: number;
+}
+export interface SensorValue {
+    target: number;
+    status?: number;
+    value?: {
+        data: number[];
+    };
+}
+export interface KeyboardEvent {
+    codeType?: number;
+    eventType?: number;
+    keyCode?: number | string;
+    key?: string;
+    text?: string;
+}
+export interface MouseEvent {
+    x?: number;
+    y?: number;
+    buttons?: number;
+    display?: number;
+}
+export declare enum SensorType {
+    ACCELERATION = 0,
+    GYROSCOPE = 1,
+    MAGNETIC_FIELD = 2,
+    ORIENTATION = 3,
+    TEMPERATURE = 4,
+    PROXIMITY = 5,
+    LIGHT = 6,
+    PRESSURE = 7,
+    HUMIDITY = 8,
+    MAGNETIC_FIELD_UNCALIBRATED = 9,
+    GYROSCOPE_UNCALIBRATED = 10,
+    HEART_RATE = 14,
+    RGBC_LIGHT = 15,
+    ACCELERATION_UNCALIBRATED = 17
+}
+export declare enum SensorState {
+    OK = 0,
+    NO_SERVICE = -3,
+    DISABLED = -2,
+    UNKNOWN = -1
+}
+export declare enum KeyEventType {
+    KEYDOWN = 0,
+    KEYUP = 1,
+    KEYPRESS = 2
+}
+export declare enum KeyCodeType {
+    USB = 0,
+    EVDEV = 1,
+    XKB = 2,
+    WIN = 3,
+    MAC = 4
+}
+export declare enum ImageFormatType {
+    PNG = 0,
+    RGBA8888 = 1,
+    RGB888 = 2
+}

package/lib/vvd/grpc/types/proto-types.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SensorType = exports.SensorState = exports.KeyEventType = exports.KeyCodeType = exports.ImageFormatType = void 0;
+let SensorType = exports.SensorType = /*#__PURE__*/function (SensorType) {
+  SensorType[SensorType["ACCELERATION"] = 0] = "ACCELERATION";
+  SensorType[SensorType["GYROSCOPE"] = 1] = "GYROSCOPE";
+  SensorType[SensorType["MAGNETIC_FIELD"] = 2] = "MAGNETIC_FIELD";
+  SensorType[SensorType["ORIENTATION"] = 3] = "ORIENTATION";
+  SensorType[SensorType["TEMPERATURE"] = 4] = "TEMPERATURE";
+  SensorType[SensorType["PROXIMITY"] = 5] = "PROXIMITY";
+  SensorType[SensorType["LIGHT"] = 6] = "LIGHT";
+  SensorType[SensorType["PRESSURE"] = 7] = "PRESSURE";
+  SensorType[SensorType["HUMIDITY"] = 8] = "HUMIDITY";
+  SensorType[SensorType["MAGNETIC_FIELD_UNCALIBRATED"] = 9] = "MAGNETIC_FIELD_UNCALIBRATED";
+  SensorType[SensorType["GYROSCOPE_UNCALIBRATED"] = 10] = "GYROSCOPE_UNCALIBRATED";
+  SensorType[SensorType["HEART_RATE"] = 14] = "HEART_RATE";
+  SensorType[SensorType["RGBC_LIGHT"] = 15] = "RGBC_LIGHT";
+  SensorType[SensorType["ACCELERATION_UNCALIBRATED"] = 17] = "ACCELERATION_UNCALIBRATED";
+  return SensorType;
+}({});
+let SensorState = exports.SensorState = /*#__PURE__*/function (SensorState) {
+  SensorState[SensorState["OK"] = 0] = "OK";
+  SensorState[SensorState["NO_SERVICE"] = -3] = "NO_SERVICE";
+  SensorState[SensorState["DISABLED"] = -2] = "DISABLED";
+  SensorState[SensorState["UNKNOWN"] = -1] = "UNKNOWN";
+  return SensorState;
+}({});
+let KeyEventType = exports.KeyEventType = /*#__PURE__*/function (KeyEventType) {
+  KeyEventType[KeyEventType["KEYDOWN"] = 0] = "KEYDOWN";
+  KeyEventType[KeyEventType["KEYUP"] = 1] = "KEYUP";
+  KeyEventType[KeyEventType["KEYPRESS"] = 2] = "KEYPRESS";
+  return KeyEventType;
+}({});
+let KeyCodeType = exports.KeyCodeType = /*#__PURE__*/function (KeyCodeType) {
+  KeyCodeType[KeyCodeType["USB"] = 0] = "USB";
+  KeyCodeType[KeyCodeType["EVDEV"] = 1] = "EVDEV";
+  KeyCodeType[KeyCodeType["XKB"] = 2] = "XKB";
+  KeyCodeType[KeyCodeType["WIN"] = 3] = "WIN";
+  KeyCodeType[KeyCodeType["MAC"] = 4] = "MAC";
+  return KeyCodeType;
+}({});
+let ImageFormatType = exports.ImageFormatType = /*#__PURE__*/function (ImageFormatType) {
+  ImageFormatType[ImageFormatType["PNG"] = 0] = "PNG";
+  ImageFormatType[ImageFormatType["RGBA8888"] = 1] = "RGBA8888";
+  ImageFormatType[ImageFormatType["RGB888"] = 2] = "RGB888";
+  return ImageFormatType;
+}({});

package/lib/vvd/index.d.ts

@@ -3,13 +3,24 @@ import { IStartOptions, IStartWithSerialPort } from '../typing/Instance';
 import { EmulatorConfig } from '../emulatorutil';
 import { findInstance } from '../instance';
 import type { DownloadFileOptions } from 'ipull';
-import GrpcEmulator from './grpc';
+import { GrpcEmulator } from './grpc';
 export declare const isHeadlessEnvironment: () => boolean;
+export interface StartVvdRes {
+    coldBoot: boolean;
+    emulatorInstance: ReturnType<typeof findInstance>;
+    /**
+     * @deprecated use velaAgent instead
+     */
+    getAgent: () => GrpcEmulator;
+    grpcConfig: EmulatorConfig;
+    velaAgent: GrpcEmulator;
+    imageType: VelaImageType;
+}
 export declare class VvdManager {
     private vvdHome;
     private sdkHome;
     binFiles: string[];
-    constructor(vvdResourcePaths: IVvdResourcePaths);
+    constructor(vvdResourcePaths?: IVvdResourcePaths);
     static getDebuggerCfgFile(): string;
     /**
      * 创建Vela端的 VVD ，统一保存在 .vela/vvd 目录下
@@ -53,12 +64,7 @@ export declare class VvdManager {
     getEmulatorBinPath(sdkHome: string): string;
     oldEmulatorMigrate(vvdName: string): Promise<void>;
     getVvdStartCmd(options: IStartOptions | IStartWithSerialPort): Promise<string>;
-    startVvd(options: IStartOptions | IStartWithSerialPort): Promise<{
-        coldBoot: boolean;
-        emulatorInstance: ReturnType<typeof findInstance>;
-        getAgent: () => GrpcEmulator;
-        grpcConfig: EmulatorConfig;
-    }>;
+    startVvd(options: IStartOptions | IStartWithSerialPort): Promise<StartVvdRes>;
     stopVvd(name: string, timeout?: number): Promise<void>;
     /** 获取模拟器平台的名称，darwin-aarch64 linux-aarch64 windows-x86_64等 */
     getEmulatorPlatform(): string;