@aiot-toolkit/emulator/lib/vvd/grpc/index.js

vela emulator tool.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
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");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
class GrpcEmulator {
  connected = false;
  constructor(eConf, protoPath) {
    this.eConf = eConf;
    this.protoPath = protoPath;
    this.token = eConf['grpc.token'];
    const packageDefinition = (0, _protoLoader.loadSync)(this.protoPath, {
      keepCase: true,
      longs: String,
      enums: String,
      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}`);
    this.authMate = mateInfo;
    this.client = new this.controller.EmulatorController(`127.0.0.1:${eConf['grpc.port']}`, _grpcJs.credentials.createInsecure());
  }
  close() {
    this.client.close();
  }
  getAuthMeta() {
    const token = this.eConf['grpc.token'];
    const mateInfo = new _grpcJs.Metadata();
    mateInfo.set('Authorization', `Bearer ${token}`);
    return mateInfo;
  }
  waitForReady() {
    if (this.connected) {
      return Promise.resolve(true);
    }
    return new Promise((resolve, reject) => {
      this.client.waitForReady(this.deadline, err => {
        if (err) {
          this.connected = false;
          console.error(err);
          return reject(err);
        }
        this.connected = true;
        resolve(true);
      });
    });
  }
  async startStream(onStreamScreenshot) {
    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);
    });
  }
  getScreenshot() {
    return new Promise((resolve, reject) => {
      this.client.getScreenshot(this.controller.Image, this.authMate, (err, response) => {
        if (err) {
          reject(err);
        }
        resolve(response.image);
      });
    });
  }
  getStatus() {
    return new Promise((resolve, reject) => {
      this.client.getStatus(this.controller.EmulatorStatus, this.authMate, (err, response) => {
        if (err) {
          console.error(err);
          (0, _grpcError.handleGrpcErrorMsg)(err);
          return reject(err);
        }
        response.hardwareConfig = Object.fromEntries(response.hardwareConfig.entry.map(t => [t.key, t.value]));
        return resolve(response);
      });
    });
  }
  sendMouse(message) {
    if (!this.connected) return;
    const e = {
      x: message.x,
      y: message.y,
      buttons: message.buttons
    };
    this.client.sendMouse(e, this.authMate, err => {
      if (err) console.error(err);
    });
  }
  sendKey(data) {
    if (!this.connected) return;
    this.client.sendKey(data, this.authMate, err => {
      if (err) console.error(err);
    });
  }
}
exports.default = GrpcEmulator;
function createGrpcClient(eConf) {
  const protoPath = _path.default.join(__dirname, '../../static/proto/emulator_controller.proto');
  return new GrpcEmulator(eConf, protoPath);
}