@huddly/device-api-usb/lib/src/index.js

Huddly SDK device api which uses node-usb wrapper responsible for handling the transport layer of the communication and discovering the physical device/camera

"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 });
exports.defaultPidsToIgnore = void 0;
const HuddlyHex_1 = __importDefault(require("@huddly/sdk-interfaces/lib/enums/HuddlyHex"));
const Logger_1 = __importDefault(require("@huddly/sdk-interfaces/lib/statics/Logger"));
const transport_1 = __importDefault(require("./transport"));
const manager_1 = __importDefault(require("./manager"));
const usb_1 = require("usb");
exports.defaultPidsToIgnore = [
    HuddlyHex_1.default.GO_PID,
    HuddlyHex_1.default.L1_PID,
    HuddlyHex_1.default.S1_PID,
    HuddlyHex_1.default.BASE_PID,
];
class HuddlyDeviceAPIUSB {
    constructor(opts = {}) {
        this.className = 'Device-API-USB';
        this.deviceDiscoveryManager = opts.manager || new manager_1.default(opts.pidsToIgnore);
        this.maxSearchRetries = opts.maxSearchRetries || 10;
        this.alwaysRetry = opts.alwaysRetry || false;
    }
    initialize() {
        // Poke discovery manager to check for new devices on the system and fire attach events
        this.deviceDiscoveryManager.deviceList(true);
    }
    registerForHotplugEvents(eventEmitter) {
        this.eventEmitter = eventEmitter;
        this.deviceDiscoveryManager.registerForHotplugEvents(eventEmitter);
    }
    getDeviceDiscoveryAPI() {
        return __awaiter(this, void 0, void 0, function* () {
            return this.deviceDiscoveryManager;
        });
    }
    getValidatedTransport(device) {
        return __awaiter(this, void 0, void 0, function* () {
            if (exports.defaultPidsToIgnore.includes(device.productId)) {
                Logger_1.default.warn(`HLink is not supported for Huddly device with PID ${device.productId}`, this.className);
                return undefined;
            }
            try {
                const transport = yield this.getTransport(device);
                yield transport.performHlinkHandshake();
                Logger_1.default.debug('Transport Protocol is Hlink', this.className);
                return transport;
            }
            catch (e) {
                Logger_1.default.warn(`Transport not supported or handshake failed! ERROR: ${e}`, this.className);
                return undefined;
            }
        });
    }
    getTransport(device) {
        return __awaiter(this, void 0, void 0, function* () {
            let transport;
            if (device instanceof usb_1.usb.Device) {
                transport = new transport_1.default(device);
            }
            else {
                const otherDevice = device;
                if (!otherDevice.serialNumber) {
                    const errMsg = `Transport cannot be initialized since the provided usb device instance is lacking serial number [${otherDevice.serialNumber}]!`;
                    Logger_1.default.warn(errMsg, this.className);
                    return Promise.reject(errMsg);
                }
                let i = 0;
                let usbDevice;
                while ((this.alwaysRetry || i < this.maxSearchRetries) && !usbDevice) {
                    usbDevice = yield this.deviceDiscoveryManager.getDevice(otherDevice.serialNumber);
                    i++;
                }
                if (!usbDevice) {
                    const errMsg = `Unable to find usb.Device instance with serial [${otherDevice.serialNumber}] afer ${i} attempts!`;
                    Logger_1.default.warn(errMsg, this.className);
                    return Promise.reject(errMsg);
                }
                transport = new transport_1.default(usbDevice);
            }
            Logger_1.default.debug('Usb device instance acquired, initializing transport component...', this.className);
            yield transport.init();
            Logger_1.default.debug('Transport component initialized.', this.className);
            return transport;
        });
    }
    isUVCControlsSupported(device) {
        return __awaiter(this, void 0, void 0, function* () {
            return Promise.resolve(false);
        });
    }
    getUVCControlAPIForDevice(device) {
        return __awaiter(this, void 0, void 0, function* () {
            throw new Error('UVCControlInterface API not available for node-usb');
        });
    }
    isHIDSupported(device) {
        return __awaiter(this, void 0, void 0, function* () {
            return Promise.resolve(false);
        });
    }
    getHIDAPIForDevice(device) {
        return __awaiter(this, void 0, void 0, function* () {
            throw new Error('HID Unsupported for device-api usb');
        });
    }
}
exports.default = HuddlyDeviceAPIUSB;
//# sourceMappingURL=index.js.map