intchains_ibctminer/src/detect.js

```js const IntMiner = require('./src'); const Debug = require('./src/log')(); const fs = require('fs'); const COMP = '[SIPC]';

const EventEmitter = require('events');
const UsbDetect = require('usb-detection');
const SerialPort = require('serialport');
const Fs = require('fs')
const Debug = require('./log')();
const COMP = '[Detect]';

class UsbMiner extends EventEmitter {
  constructor({}) {
    super();
    var _this = this
    _this.devices = [];
    _this.runDevices = [];
    _this.id = 0;

    UsbDetect.startMonitoring();

    _this.on('error', function (error) {
      Debug.IbctLogErr(COMP, "error:", error);
    });

    UsbDetect.on('add', function (Device) {
      if (_this.IsUsbMiner(Device)) {
        Debug.IbctLogDbg(COMP, 'add:', JSON.stringify(Device));
        _this.AddUsbMiner(Device);
      }
    });
    UsbDetect.on('remove', function (Device) {
      if (_this.hasExistUsbMiner(Device)) {
        Debug.IbctLogDbg(COMP, 'remove:', JSON.stringify(Device));
        _this.RemoveUsbMiner(Device);
      }
    });
  }
  async ExitUsbMiner() {
    await UsbDetect.stopMonitoring();
  }
  GetUsbMiner() {
    return this.devices;
  }
  async ListUsbMiner() {
    var _this = this;
    var UsbMiner = [];

    await UsbDetect.find().then(function (Devices) {
      UsbMiner = Devices;
    }).catch(function (err) {
      Debug.IbctLogErr(COMP, err);
    });

    for (var i = 0; i < UsbMiner.length; i++) {
      if (_this.IsUsbMiner(UsbMiner[i])) {
        await _this.getUsbMinerPort(UsbMiner[i], 0, function (err, port) {
          if (err) {
            return;
          }
          _this.devices.push({
            devID: _this.id++,
            port: port,
            miner: UsbMiner[i]
          });
        });
      }
    }
  }

  findMacUsbMinerPort(Device, callback) {
    var point = 'tty.usbmodem' + Device.serialNumber
    var files = Fs.readdirSync('/dev/');
    if (!files) {
      callback('Cannot Find Port');
      return
    }
    for (var i = 0; i < files.length; i++) {
      if (files[i].match(point)) {
        callback(null, '/dev/' + files[i]);
        return
      }
    }
    callback('Cannot Find Port');
  }

  async getUsbMinerPort(Device, Timeout, callback) {
    var portName = null;
    var _this = this;
    if (!Device) {
      callback('Device Error')
      return;
    }
    if (process.platform !== 'darwin') {
      await SerialPort.list(function (err, ports) {
        if (err) {
          callback(err);
          return;
        }
        ports.forEach(function (port) {
          if (port.serialNumber === Device.serialNumber) {
            portName = port.comName;
            callback(null, portName);
            return;
          }
        })
        callback('Cannot Find Port');
      })
    } else {
      // In darwin, serialport have some bug
      if (!Timeout)
	      this.findMacUsbMinerPort(Device, callback)
      else {
	      setTimeout(function() {
          _this.findMacUsbMinerPort(Device, callback)
        }, Timeout);
      }
    }
  }
  IsUsbMiner(Device) {
    return (Device && Device.manufacturer.slice(0, 18) === 'STMicroelectronics');
  }
  hasExistUsbMiner(Device) {
    return this.devices.some(function (dev) {
      return JSON.stringify(dev.miner) === JSON.stringify(Device);
    });
  }
  hasUsbMiner() {
    return ((this.devices.length > 0) ? true : false);
  }
  AddUsbMiner(Device) {
    var _this = this;
    var device = {
      devID: _this.id++,
      port: null,
      miner: Device
    };
    _this.getUsbMinerPort(Device, 3000, function (err, port) {
      if (err) {
        return;
      }
      device.port = port;
      _this.devices.push(device);
      _this.emit('plug-in', device);
    })
  }
  RemoveUsbMiner(Device) {
    var delDevice = {}
    this.devices = this.devices.filter(function (dev) {
      if (JSON.stringify(dev.miner) !== JSON.stringify(Device)) {
        return true;
      } else {
        delDevice = dev;
        return false;
      }
    });
    this.emit('plug-out', delDevice);
  }
}

module.exports = function DectectUsbMiner(options = {}) {
  return new UsbMiner(options);
};