incyclist-devices 2.1.0 → 2.1.2

package/lib/serial/base/comms.js

@@ -0,0 +1,280 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../daum/premium/utils");
+const utils_2 = require("../../utils/utils");
+const DEFAULT_BUSY_TIMEOUT = 5000;
+class SerialPortComms {
+    constructor(props) {
+        this.props = props;
+        const { logger, serial, path } = props;
+        this.serial = serial;
+        this.path = this.validatePath(path);
+        const w = global.window;
+        this.logger = logger || ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.DEBUG ? utils_1.DEBUG_LOGGER : new gd_eventlog_1.EventLogger(this.getDefaultLoggerName()));
+        this.resetState();
+    }
+    getBusyTimeout() {
+        return DEFAULT_BUSY_TIMEOUT;
+    }
+    getDefaultLoggerName() {
+        return 'Serial';
+    }
+    getInitialCommsState() {
+        return { data: new utils_2.Queue() };
+    }
+    validatePath(path) {
+        return path;
+    }
+    getInterface() {
+        var _a;
+        return (_a = this.serial) === null || _a === void 0 ? void 0 : _a.ifaceName;
+    }
+    getPort() {
+        return this.path;
+    }
+    isConnected() {
+        return this.connectState === 'Connected' || this.connectState === 'Disconnecting';
+    }
+    pauseLogging() {
+        this.isLoggingPaused = true;
+    }
+    resumeLogging() {
+        this.isLoggingPaused = false;
+    }
+    logEvent(e) {
+        if (this.isLoggingPaused)
+            return;
+        this.logger.logEvent(e);
+        const w = global.window;
+        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
+            console.log(`~~~ ${this.getDefaultLoggerName()}`, e);
+        }
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected() && this.sp) {
+                return true;
+            }
+            if (this.connectState === 'Connecting') {
+                if (this.connectPromise) {
+                    try {
+                        yield this.connectPromise;
+                    }
+                    catch (_a) {
+                    }
+                }
+                return this.isConnected();
+            }
+            try {
+                this.connectState = 'Connecting';
+                this.connectPromise = this.serial.openPort(this.path);
+                const port = yield this.connectPromise;
+                this.connectPromise = null;
+                if (port !== null) {
+                    this.connectState = 'Connected';
+                    this.sp = port;
+                    this.sp.on('close', this.onPortClose.bind(this));
+                    this.sp.on('error', this.onPortError.bind(this));
+                    this.onConnected();
+                    return true;
+                }
+                else {
+                    this.connectState = 'Disconnected';
+                    return false;
+                }
+            }
+            catch (_b) {
+                this.connectState = 'Disconnected';
+                return false;
+            }
+        });
+    }
+    onConnected() {
+    }
+    portFlush() {
+        if (this.sp)
+            this.sp.flush();
+    }
+    portPipe(destination, options) {
+        if (this.sp)
+            return this.sp.pipe(destination, options);
+    }
+    portUnpipe(destination) {
+        if (this.sp)
+            this.sp.unpipe(destination);
+    }
+    closePort() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sp)
+                return true;
+            try {
+                yield this.flush();
+                yield this.serial.closePort(this.path);
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not close ', reason: err.message });
+                return false;
+            }
+        });
+    }
+    resetState(isDisconnected = true) {
+        this.isLoggingPaused = false;
+        this.recvState = this.getInitialCommsState();
+        this.connectPromise = null;
+        this.disconnectPromise = null;
+        this.writePromise = null;
+        this.sendCmdPromise = null;
+        if (isDisconnected)
+            this.connectState = 'Disconnected';
+    }
+    cleanupPort(isDisconnected = true) {
+        if (this.sp) {
+            this.sp.removeAllListeners();
+        }
+        this.sp = null;
+        this.resetState(isDisconnected);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let isDisconnected = false;
+            if (this.disconnectPromise) {
+                try {
+                    isDisconnected = yield this.disconnectPromise;
+                }
+                catch (_a) {
+                }
+                return isDisconnected;
+            }
+            if (this.connectState === 'Disconnected') {
+                this.cleanupPort();
+                return true;
+            }
+            else if (this.connectState === 'Disconnecting' || this.connectState === 'Connected' || this.connectState === 'Connecting') {
+                this.connectState = 'Disconnecting';
+                this.disconnectPromise = this.closePort();
+                isDisconnected = yield this.disconnectPromise;
+                if (isDisconnected) {
+                    this.connectState = 'Disconnected';
+                    this.logEvent({ message: "port closed:", port: this.path });
+                }
+                this.cleanupPort(isDisconnected);
+            }
+            return isDisconnected;
+        });
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.writePromise) {
+                yield (0, utils_2.waitWithTimeout)(this.writePromise, 1000);
+                this.writePromise = null;
+            }
+        });
+    }
+    onPortClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connectState !== 'Disconnected' && this.connectState !== 'Disconnecting')
+                this.logEvent({ message: "port closed:", port: this.path });
+            this.connectState = 'Disconnected';
+            this.cleanupPort();
+        });
+    }
+    onPortError(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connectState === 'Disconnecting' || this.connectState === 'Disconnected') {
+                return;
+            }
+            this.logEvent({ message: "port error:", port: this.path, error: error.message, connected: this.isConnected(), state: this.connectState });
+            if (this.isSending()) {
+                this.rejectCurrent(error);
+            }
+            if (this.connectState === 'Connected')
+                this.close();
+        });
+    }
+    isSending() {
+        return (this.writePromise !== undefined && this.writePromise !== null) || (this.sendCmdPromise !== null && this.sendCmdPromise !== undefined);
+    }
+    rejectCurrent(error) {
+        this.recvState.data.enqueue({ type: 'Error', error });
+    }
+    getTimeoutValue() {
+        throw new Error('method not implemented');
+    }
+    onData(data, depth = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    send(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('method not implemented');
+        });
+    }
+    portWrite(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sp) {
+                this.logEvent({ message: 'write failed', error: 'port is not opened' });
+                return;
+            }
+            try {
+                yield this.sp.write(buffer);
+            }
+            catch (err) {
+                this.logEvent({ message: 'write failed', error: err.message });
+            }
+        });
+    }
+    write(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.writePromise) {
+                try {
+                    yield this.writePromise;
+                }
+                catch (_a) {
+                }
+                this.writePromise = null;
+            }
+            this.writePromise = this.portWrite(buffer);
+            yield this.writePromise;
+            this.writePromise = null;
+        });
+    }
+    ensurePrevCmdFinish(logPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sendCmdPromise) {
+                const tsRequest = Date.now();
+                this.logEvent(Object.assign({ message: 'sendCommand:waiting:' }, logPayload));
+                let busyTimedOut = false;
+                const onTimeout = () => {
+                    this.logEvent(Object.assign(Object.assign({ message: 'sendCommand:error:' }, logPayload), { error: 'BUSY timeout', duration: Date.now() - tsRequest }));
+                    busyTimedOut = true;
+                };
+                yield (0, utils_2.waitWithTimeout)(this.sendCmdPromise, this.getBusyTimeout(), onTimeout);
+                this.sendCmdPromise = null;
+                if (busyTimedOut)
+                    throw new Error('BUSY timeout');
+            }
+        });
+    }
+    ensureConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                const connected = yield this.connect();
+                if (!connected) {
+                    throw new Error('not connected');
+                }
+            }
+        });
+    }
+}
+exports.default = SerialPortComms;

package/lib/serial/base/serial-interface.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
+import { BindingInterface } from "@serialport/bindings-interface";
+import { SerialPortStream } from '@serialport/stream';
+import { SerialDeviceSettings, SerialScannerProps, PortMapping, SerialInterfaceProps } from "../types";
+import { IncyclistInterface } from "../../types";
+import { EventLogger } from "gd-eventlog";
+export default class SerialInterface extends EventEmitter implements IncyclistInterface {
+    ifaceName: string;
+    binding: BindingInterface;
+    ports: PortMapping[];
+    isScanning: boolean;
+    isStopScanRequested: boolean;
+    scanEvents: EventEmitter;
+    logger: EventLogger;
+    toScan: NodeJS.Timeout;
+    connected: boolean;
+    inUse: string[];
+    static _instances: SerialInterface[];
+    static getInstance(props: SerialInterfaceProps): SerialInterface;
+    static _add(instance: SerialInterface): void;
+    constructor(props: SerialInterfaceProps);
+    logEvent(event: any): void;
+    setBinding(binding: BindingInterface): void;
+    getName(): string;
+    isConnected(): boolean;
+    setInUse(path: string): void;
+    releaseInUse(path: string): void;
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    openPort(path: string): Promise<SerialPortStream | null>;
+    closePort(path: string): Promise<Boolean>;
+    scan(props: SerialScannerProps): Promise<SerialDeviceSettings[]>;
+    stopScan(): Promise<boolean>;
+}

package/lib/serial/base/serial-interface.js

@@ -0,0 +1,288 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+const serialport_1 = __importDefault(require("./serialport"));
+const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../../utils/utils");
+const adapter_factory_1 = __importDefault(require("../factories/adapter-factory"));
+const serial_scanner_1 = require("./serial-scanner");
+const DEFAULT_SCAN_TIMEOUT = 10000;
+class SerialInterface extends events_1.default {
+    static getInstance(props) {
+        const { ifaceName, binding, logger } = props;
+        let instance = SerialInterface._instances.find(i => i.ifaceName === ifaceName);
+        if (!instance) {
+            if (binding)
+                instance = new SerialInterface(props);
+            else {
+                instance = new SerialInterface({ ifaceName, binding: serialport_1.default.getInstance().getBinding(ifaceName), logger });
+                if (instance)
+                    SerialInterface._instances.push(instance);
+            }
+        }
+        return instance;
+    }
+    static _add(instance) {
+        let existingIdx = SerialInterface._instances.findIndex(i => i.ifaceName === instance.ifaceName);
+        if (existingIdx !== -1)
+            SerialInterface._instances[existingIdx] = instance;
+        else
+            SerialInterface._instances.push(instance);
+    }
+    constructor(props) {
+        super();
+        const { ifaceName, binding } = props;
+        this.ifaceName = ifaceName;
+        this.binding = undefined;
+        this.ports = [];
+        this.inUse = [];
+        this.isScanning = false;
+        this.isStopScanRequested = false;
+        this.scanEvents = new events_1.default();
+        this.scanEvents.setMaxListeners(100);
+        this.logger = props.logger || new gd_eventlog_1.EventLogger(`Serial:${ifaceName}`);
+        this.connected = false;
+        this.logEvent({ message: 'new serial interface', ifaceName });
+        if (binding) {
+            this.setBinding(binding);
+        }
+        SerialInterface._add(this);
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.SERIAL_DEBUG || process.env.ANT_DEBUG || process.env.BLE_DEBUG) {
+            console.log('~~~ Serial', event);
+        }
+    }
+    setBinding(binding) {
+        this.binding = binding;
+        serialport_1.default.getInstance().setBinding(this.ifaceName, binding);
+    }
+    getName() {
+        return this.ifaceName;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    setInUse(path) {
+        this.logEvent({ message: 'block port for further scans', port: path });
+        if (!this.inUse.includes(path))
+            this.inUse.push(path);
+    }
+    releaseInUse(path) {
+        if (this.inUse.includes(path)) {
+            this.logEvent({ message: 're-enable port for further scans', port: path });
+            const idx = this.inUse.findIndex(r => r === path);
+            this.inUse.splice(idx, 1);
+        }
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'connecting', interface: this.ifaceName });
+            const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
+            if (!binding || !this.binding) {
+                this.connected = false;
+                this.logEvent({ message: 'connecting error', interface: this.ifaceName, reason: 'no binfing found' });
+                return false;
+            }
+            try {
+                const SerialPort = this.binding;
+                yield SerialPort.list();
+                this.connected = true;
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'connecting error', interface: this.ifaceName, reason: err.message });
+                this.connected = false;
+                return false;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connected = false;
+            return true;
+        });
+    }
+    openPort(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'opening port', port: path });
+            const existing = this.ports.findIndex(p => p.path === path);
+            if (existing !== -1) {
+                const port = this.ports[existing].port;
+                if (port.isOpen) {
+                    this.logEvent({ message: 'opening port - port already exists', port: path });
+                    return port;
+                }
+                else {
+                    this.ports.splice(existing, 1);
+                }
+            }
+            const port = serialport_1.default.getInstance().getSerialPort(this.ifaceName, { path });
+            if (!port) {
+                this.logEvent({ message: 'opening port - port does not exist', port: path });
+                return null;
+            }
+            return new Promise((resolve) => {
+                port.once('error', (err) => {
+                    this.logEvent({ message: 'error', path, error: err.message || err, stack: err.stack });
+                    port.removeAllListeners();
+                    resolve(null);
+                });
+                port.once('open', () => {
+                    this.logEvent({ message: 'port opened', path });
+                    port.removeAllListeners();
+                    this.ports.push({ path, port });
+                    resolve(port);
+                });
+                port.open();
+            });
+        });
+    }
+    closePort(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'closing port', port: path });
+            const existing = this.ports.findIndex(p => p.path === path);
+            if (existing === -1)
+                return true;
+            const port = this.ports[existing].port;
+            if (!port.isOpen)
+                return true;
+            port.on('error', () => { });
+            try {
+                port.flush();
+                yield port.drain();
+            }
+            catch (_a) { }
+            return new Promise(resolve => {
+                port.close(err => {
+                    if (!err) {
+                        this.ports.splice(existing, 1);
+                        port.removeAllListeners();
+                        resolve(true);
+                    }
+                    resolve(false);
+                });
+            });
+        });
+    }
+    scan(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isScanning)
+                return [];
+            if (!this.isConnected())
+                yield this.connect();
+            const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
+            if (!binding || !this.binding)
+                return [];
+            const { port, timeout = DEFAULT_SCAN_TIMEOUT } = props;
+            let paths;
+            const detected = [];
+            let timeOutExpired = false;
+            let toExpiresAt = Date.now() + timeout;
+            if (timeout) {
+                this.toScan = setTimeout(() => {
+                    timeOutExpired = true;
+                    this.scanEvents.emit('timeout');
+                }, timeout);
+            }
+            this.isScanning = true;
+            let attemptNo = 0;
+            const isTcpip = this.getName() === 'tcpip';
+            do {
+                if (attemptNo === 0)
+                    this.logEvent({ message: 'checking for ports', interface: this.ifaceName, port, excludes: this.inUse });
+                else
+                    this.logEvent({ message: 'checking for ports retry', interface: this.ifaceName, retry: attemptNo });
+                attemptNo++;
+                try {
+                    if (isTcpip) {
+                        const _binding = binding;
+                        paths = (yield _binding.list(port, this.inUse)) || [];
+                    }
+                    else {
+                        paths = (yield binding.list()) || [];
+                    }
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error', fn: 'scan#detect ports', error: err.message, interface: this.ifaceName, port, excludes: this.inUse });
+                }
+                paths = paths.filter(p => !this.inUse.includes(p.path));
+                if (!paths || paths.length === 0) {
+                    this.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
+                    yield (0, utils_1.sleep)(1000);
+                }
+                if (Date.now() > toExpiresAt)
+                    timeOutExpired = true;
+            } while (this.isScanning && !timeOutExpired && paths.length === 0);
+            if (paths.length === 0) {
+                this.logEvent({ message: 'nothing to scan ' });
+                if (this.toScan) {
+                    clearTimeout(this.toScan);
+                    this.toScan = null;
+                }
+                return [];
+            }
+            this.logEvent({ message: 'scanning on ', interface: this.ifaceName, paths: paths.map(p => p.path).join(','), timeout });
+            const scanners = paths.map(p => new serial_scanner_1.SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
+            try {
+                yield Promise.all(scanners.map(s => s.scan()
+                    .then((device) => __awaiter(this, void 0, void 0, function* () {
+                    if (device) {
+                        const adapter = adapter_factory_1.default.getInstance().createInstance(device);
+                        const path = adapter.getPort();
+                        this.inUse.push(path);
+                        yield adapter.pause();
+                        detected.push(device);
+                        this.emit('device', device);
+                    }
+                }))
+                    .catch()));
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+            }
+            if (this.toScan) {
+                clearTimeout(this.toScan);
+                this.toScan = null;
+            }
+            this.isScanning = false;
+            this.logEvent({ message: 'scan finished on', interface: this.ifaceName, paths: paths.map(p => p.path), devices: detected.map(d => {
+                    const res = Object.assign({}, d);
+                    res.interface = this.ifaceName;
+                    return res;
+                }) });
+            return detected;
+        });
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isScanning)
+                return true;
+            if (this.toScan) {
+                clearTimeout(this.toScan);
+                this.toScan = null;
+            }
+            this.isScanning = false;
+            this.scanEvents.emit('stop');
+            return true;
+        });
+    }
+}
+SerialInterface._instances = [];
+exports.default = SerialInterface;

package/lib/serial/base/serial-scanner.d.ts

@@ -0,0 +1,16 @@
+import { EventLogger } from "gd-eventlog";
+import SerialInterface from "./serial-interface";
+import { SerialDeviceSettings, SerialScannerProps } from "../types";
+export declare class SinglePathScanner {
+    path: string;
+    serial: SerialInterface;
+    result: SerialDeviceSettings;
+    isScanning: boolean;
+    props: SerialScannerProps;
+    logger: EventLogger;
+    isFound: boolean;
+    constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
+    logEvent(event: any): void;
+    onStopRequest(resolve: any): Promise<void>;
+    scan(): Promise<SerialDeviceSettings | undefined>;
+}