usb 2.5.2-alpha.1 → 2.6.0

package/tsc/usb/endpoint.ts

@@ -1,229 +0,0 @@
-import { EventEmitter } from 'events';
-import { LibUSBException, LIBUSB_TRANSFER_CANCELLED, Transfer, Device } from './bindings';
-import { EndpointDescriptor } from './descriptors';
-
-const isBuffer = (obj: ArrayBuffer | Buffer): obj is Uint8Array => obj && obj instanceof Uint8Array;
-
-/** Common base for InEndpoint and OutEndpoint. */
-export abstract class Endpoint extends EventEmitter {
-    public address: number;
-
-    /** Endpoint direction: `"in"` or `"out"`. */
-    public abstract direction: 'in' | 'out';
-
-    /** Endpoint type: `usb.LIBUSB_TRANSFER_TYPE_BULK`, `usb.LIBUSB_TRANSFER_TYPE_INTERRUPT`, or `usb.LIBUSB_TRANSFER_TYPE_ISOCHRONOUS`. */
-    public transferType: number;
-
-    /** Sets the timeout in milliseconds for transfers on this endpoint. The default, `0`, is infinite timeout. */
-    public timeout = 0;
-
-    /** Object with fields from the endpoint descriptor -- see libusb documentation or USB spec. */
-    public descriptor: EndpointDescriptor;
-
-    constructor(protected device: Device, descriptor: EndpointDescriptor) {
-        super();
-        this.descriptor = descriptor;
-        this.address = descriptor.bEndpointAddress;
-        this.transferType = descriptor.bmAttributes & 0x03;
-    }
-
-    /** Clear the halt/stall condition for this endpoint. */
-    public clearHalt(callback: (error: LibUSBException | undefined) => void): void {
-        return this.device.__clearHalt(this.address, callback);
-    }
-
-    /**
-     * Create a new `Transfer` object for this endpoint.
-     *
-     * The passed callback will be called when the transfer is submitted and finishes. Its arguments are the error (if any), the submitted buffer, and the amount of data actually written (for
-     * OUT transfers) or read (for IN transfers).
-     *
-     * @param timeout Timeout for the transfer (0 means unlimited).
-     * @param callback Transfer completion callback.
-     */
-    public makeTransfer(timeout: number, callback: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer {
-        return new Transfer(this.device, this.address, this.transferType, timeout, callback);
-    }
-}
-
-/** Endpoints in the IN direction (device->PC) have this type. */
-export class InEndpoint extends Endpoint {
-
-    /** Endpoint direction. */
-    public direction: 'in' | 'out' = 'in';
-
-    protected pollTransfers: Transfer[] = [];
-    protected pollTransferSize = 0;
-    protected pollPending = 0;
-    public pollActive = false;
-
-    constructor(device: Device, descriptor: EndpointDescriptor) {
-        super(device, descriptor);
-    }
-
-    /**
-     * Perform a transfer to read data from the endpoint.
-     *
-     * If length is greater than maxPacketSize, libusb will automatically split the transfer in multiple packets, and you will receive one callback with all data once all packets are complete.
-     *
-     * `this` in the callback is the InEndpoint object.
-     *
-     * The device must be open to use this method.
-     * @param length
-     * @param callback
-     */
-    public transfer(length: number, callback: (error: LibUSBException | undefined, data?: Buffer) => void): InEndpoint {
-        const buffer = Buffer.alloc(length);
-
-        const cb = (error: LibUSBException | undefined, _buffer?: Buffer, actualLength?: number) => {
-            callback.call(this, error, buffer.slice(0, actualLength));
-        };
-
-        try {
-            this.makeTransfer(this.timeout, cb).submit(buffer);
-        } catch (e) {
-            process.nextTick(() => callback.call(this, e));
-        }
-        return this;
-    }
-
-    /**
-     * Start polling the endpoint.
-     *
-     * The library will keep `nTransfers` transfers of size `transferSize` pending in the kernel at all times to ensure continuous data flow.
-     * This is handled by the libusb event thread, so it continues even if the Node v8 thread is busy. The `data` and `error` events are emitted as transfers complete.
-     *
-     * The device must be open to use this method.
-     * @param nTransfers
-     * @param transferSize
-     */
-    public startPoll(nTransfers?: number, transferSize?: number, _callback?: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer[] {
-        const transferDone = (error: LibUSBException | undefined, transfer: Transfer, buffer: Buffer, actualLength: number) => {
-            if (!error) {
-                this.emit('data', buffer.slice(0, actualLength));
-            } else if (error.errno != LIBUSB_TRANSFER_CANCELLED) {
-                this.emit('error', error);
-                this.stopPoll();
-            }
-
-            if (this.pollActive) {
-                startTransfer(transfer);
-            } else {
-                this.pollPending--;
-
-                if (this.pollPending === 0) {
-                    this.pollTransfers = [];
-                    this.pollActive = false;
-                    this.emit('end');
-                }
-            }
-        };
-
-        const startTransfer = (transfer: Transfer) => {
-            try {
-                transfer.submit(Buffer.alloc(this.pollTransferSize), (error, buffer, actualLength) => {
-                    transferDone(error, transfer, buffer, actualLength);
-                });
-            } catch (e) {
-                this.emit('error', e);
-                this.stopPoll();
-            }
-        };
-
-        this.pollTransfers = this.startPollTransfers(nTransfers, transferSize, function (this: Transfer, error, buffer, actualLength) {
-            transferDone(error, this, buffer, actualLength);
-        });
-        this.pollTransfers.forEach(startTransfer);
-        this.pollPending = this.pollTransfers.length;
-        return this.pollTransfers;
-    }
-
-    protected startPollTransfers(nTransfers = 3, transferSize = this.descriptor.wMaxPacketSize, callback: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer[] {
-        if (this.pollActive) {
-            throw new Error('Polling already active');
-        }
-
-        this.pollTransferSize = transferSize;
-        this.pollActive = true;
-        this.pollPending = 0;
-
-        const transfers: Transfer[] = [];
-        for (let i = 0; i < nTransfers; i++) {
-            const transfer = this.makeTransfer(0, callback);
-            transfers[i] = transfer;
-        }
-        return transfers;
-    }
-
-    /**
-     * Stop polling.
-     *
-     * Further data may still be received. The `end` event is emitted and the callback is called once all transfers have completed or canceled.
-     *
-     * The device must be open to use this method.
-     * @param callback
-     */
-    public stopPoll(callback?: () => void): void {
-        if (!this.pollActive) {
-            throw new Error('Polling is not active.');
-        }
-        for (let i = 0; i < this.pollTransfers.length; i++) {
-            try {
-                this.pollTransfers[i].cancel();
-            } catch (error) {
-                this.emit('error', error);
-            }
-        }
-        this.pollActive = false;
-        if (callback) this.once('end', callback);
-    }
-}
-
-/** Endpoints in the OUT direction (PC->device) have this type. */
-export class OutEndpoint extends Endpoint {
-
-    /** Endpoint direction. */
-    public direction: 'in' | 'out' = 'out';
-
-    /**
-     * Perform a transfer to write `data` to the endpoint.
-     *
-     * If length is greater than maxPacketSize, libusb will automatically split the transfer in multiple packets, and you will receive one callback once all packets are complete.
-     *
-     * `this` in the callback is the OutEndpoint object.
-     *
-     * The device must be open to use this method.
-     * @param buffer
-     * @param callback
-     */
-    public transfer(buffer: Buffer, callback?: (error: LibUSBException | undefined, actual: number) => void): OutEndpoint {
-        if (!buffer) {
-            buffer = Buffer.alloc(0);
-        } else if (!isBuffer(buffer)) {
-            buffer = Buffer.from(buffer);
-        }
-
-        const cb = (error: LibUSBException | undefined, _buffer?: Buffer, actual?: number) => {
-            if (callback) {
-                callback.call(this, error, actual || 0);
-            }
-        };
-
-        try {
-            this.makeTransfer(this.timeout, cb).submit(buffer);
-        } catch (e) {
-            process.nextTick(() => cb(e));
-        }
-
-        return this;
-    }
-
-    public transferWithZLP(buffer: Buffer, callback: (error: LibUSBException | undefined) => void): void {
-        if (buffer.length % this.descriptor.wMaxPacketSize === 0) {
-            this.transfer(buffer);
-            this.transfer(Buffer.alloc(0), callback);
-        } else {
-            this.transfer(buffer, callback);
-        }
-    }
-}

package/tsc/usb/index.ts

@@ -1,149 +0,0 @@
-import { EventEmitter } from 'events';
-import { ExtendedDevice } from './device';
-import * as usb from './bindings';
-
-if (usb.INIT_ERROR) {
-    /* eslint-disable no-console */
-    console.warn('Failed to initialize libusb.');
-}
-
-Object.setPrototypeOf(usb, EventEmitter.prototype);
-
-Object.getOwnPropertyNames(ExtendedDevice.prototype).forEach(name => {
-    Object.defineProperty(usb.Device.prototype, name, Object.getOwnPropertyDescriptor(ExtendedDevice.prototype, name) || Object.create(null));
-});
-
-interface EventListeners<T> {
-    newListener: keyof T;
-    removeListener: keyof T;
-}
-
-interface DeviceIds {
-    idVendor: number;
-    idProduct: number;
-}
-
-declare module './bindings' {
-
-    /* eslint-disable @typescript-eslint/no-empty-interface */
-    interface Device extends ExtendedDevice { }
-
-    interface DeviceEvents extends EventListeners<DeviceEvents> {
-        attach: Device;
-        detach: Device;
-        attachIds: DeviceIds;
-        detachIds: DeviceIds;
-    }
-
-    function addListener<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function removeListener<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function on<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function off<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function once<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
-    function listeners<K extends keyof DeviceEvents>(event: K): ((arg: DeviceEvents[K]) => void)[];
-    function rawListeners<K extends keyof DeviceEvents>(event: K): ((arg: DeviceEvents[K]) => void)[];
-    function removeAllListeners<K extends keyof DeviceEvents>(event?: K): void;
-    function emit<K extends keyof DeviceEvents>(event: K, arg: DeviceEvents[K]): boolean;
-    function listenerCount<K extends keyof DeviceEvents>(event: K): number;
-}
-
-// Hotplug support
-const hotplugSupported = usb._supportedHotplugEvents();
-
-// Devices delta support for non-libusb hotplug events
-// This methd needs to be used for attach/detach IDs (hotplugSupportType === 2) rather than a lookup because vid/pid are not unique
-let hotPlugDevices = new Set<usb.Device>();
-const emitHotplugEvents = () => {
-    // Collect current devices
-    const devices = new Set(usb.getDeviceList());
-
-    // Find attached devices
-    for (const device of devices) {
-        if (!hotPlugDevices.has(device)) {
-            usb.emit('attach', device);
-        }
-    }
-
-    // Find detached devices
-    for (const device of hotPlugDevices) {
-        if (!devices.has(device)) {
-            usb.emit('detach', device);
-        }
-    }
-
-    hotPlugDevices = devices;
-};
-
-// Polling mechanism for checking device changes where hotplug detection is not available
-let pollingHotplug = false;
-const pollHotplug = (start = false) => {
-    if (start) {
-        pollingHotplug = true;
-    } else if (!pollingHotplug) {
-        return;
-    } else {
-        emitHotplugEvents();
-    }
-
-    setTimeout(() => pollHotplug(), 500);
-};
-
-// Hotplug control
-const startHotplug = () => {
-    if (hotplugSupported !== 1) {
-        // Collect initial devices when not using libusb
-        hotPlugDevices = new Set(usb.getDeviceList());
-    }
-
-    if (hotplugSupported) {
-        // Use hotplug event emitters
-        usb._enableHotplugEvents();
-
-        if (hotplugSupported === 2) {
-            // Use hotplug ID events to trigger a change check
-            usb.on('attachIds', emitHotplugEvents);
-            usb.on('detachIds', emitHotplugEvents);
-        }
-    } else {
-        // Fallback to using polling to check for changes
-        pollHotplug(true);
-    }
-};
-
-const stopHotplug = () => {
-    if (hotplugSupported) {
-        // Disable hotplug events
-        usb._disableHotplugEvents();
-
-        if (hotplugSupported === 2) {
-            // Remove hotplug ID event listeners
-            usb.off('attachIds', emitHotplugEvents);
-            usb.off('detachIds', emitHotplugEvents);
-        }
-    } else {
-        // Stop polling
-        pollingHotplug = false;
-    }
-};
-
-usb.on('newListener', event => {
-    if (event !== 'attach' && event !== 'detach') {
-        return;
-    }
-    const listenerCount = usb.listenerCount('attach') + usb.listenerCount('detach');
-    if (listenerCount === 0) {
-        startHotplug();
-    }
-});
-
-usb.on('removeListener', event => {
-    if (event !== 'attach' && event !== 'detach') {
-        return;
-    }
-    const listenerCount = usb.listenerCount('attach') + usb.listenerCount('detach');
-    if (listenerCount === 0) {
-        stopHotplug();
-    }
-});
-
-export = usb;

package/tsc/usb/interface.ts

@@ -1,167 +0,0 @@
-import { LibUSBException, LIBUSB_ENDPOINT_IN, Device } from './bindings';
-import { InterfaceDescriptor } from './descriptors';
-import { Endpoint, InEndpoint, OutEndpoint } from './endpoint';
-
-export class Interface {
-    /** Integer interface number. */
-    public interfaceNumber!: number;
-
-    /** Integer alternate setting number. */
-    public altSetting = 0;
-
-    /** Object with fields from the interface descriptor -- see libusb documentation or USB spec. */
-    public descriptor!: InterfaceDescriptor;
-
-    /** List of endpoints on this interface: InEndpoint and OutEndpoint objects. */
-    public endpoints!: Endpoint[];
-
-    constructor(protected device: Device, protected id: number) {
-        this.refresh();
-    }
-
-    protected refresh(): void {
-        if (!this.device.configDescriptor) {
-            return;
-        }
-
-        this.descriptor = this.device.configDescriptor.interfaces[this.id][this.altSetting];
-        this.interfaceNumber = this.descriptor.bInterfaceNumber;
-        this.endpoints = [];
-        const len = this.descriptor.endpoints.length;
-        for (let i = 0; i < len; i++) {
-            const desc = this.descriptor.endpoints[i];
-            const c = (desc.bEndpointAddress & LIBUSB_ENDPOINT_IN) ? InEndpoint : OutEndpoint;
-            this.endpoints[i] = new c(this.device, desc);
-        }
-    }
-
-    /**
-     * Claims the interface. This method must be called before using any endpoints of this interface.
-     *
-     * The device must be open to use this method.
-     */
-    public claim(): void {
-        this.device.__claimInterface(this.id);
-    }
-
-    /**
-     * Releases the interface and resets the alternate setting. Calls callback when complete.
-     *
-     * It is an error to release an interface with pending transfers.
-     *
-     * The device must be open to use this method.
-     * @param callback
-     */
-    public release(callback?: (error?: LibUSBException) => void): void;
-
-    /**
-     * Releases the interface and resets the alternate setting. Calls callback when complete.
-     *
-     * It is an error to release an interface with pending transfers. If the optional closeEndpoints
-     * parameter is true, any active endpoint streams are stopped (see `Endpoint.stopStream`),
-     * and the interface is released after the stream transfers are cancelled. Transfers submitted
-     * individually with `Endpoint.transfer` are not affected by this parameter.
-     *
-     * The device must be open to use this method.
-     * @param closeEndpoints
-     * @param callback
-     */
-    public release(closeEndpoints?: boolean, callback?: (error?: LibUSBException) => void): void;
-    public release(closeEndpointsOrCallback?: boolean | ((error?: LibUSBException) => void), callback?: (error: LibUSBException | undefined) => void): void {
-
-        let closeEndpoints = false;
-        if (typeof closeEndpointsOrCallback === 'boolean') {
-            closeEndpoints = closeEndpointsOrCallback;
-        } else {
-            callback = closeEndpointsOrCallback;
-        }
-
-        const next = () => {
-            this.device.__releaseInterface(this.id, error => {
-                if (!error) {
-                    this.altSetting = 0;
-                    this.refresh();
-                }
-                if (callback) {
-                    callback.call(this, error);
-                }
-            });
-        };
-
-        if (!closeEndpoints || this.endpoints.length === 0) {
-            next();
-        } else {
-            let n = this.endpoints.length;
-            this.endpoints.forEach(ep => {
-                if (ep.direction === 'in' && (ep as InEndpoint).pollActive) {
-                    ep.once('end', () => {
-                        if (--n === 0) {
-                            next();
-                        }
-                    });
-                    (ep as InEndpoint).stopPoll();
-                } else {
-                    if (--n === 0) {
-                        next();
-                    }
-                }
-            });
-        }
-    }
-
-    /**
-     * Returns `false` if a kernel driver is not active; `true` if active.
-     *
-     * The device must be open to use this method.
-     */
-    public isKernelDriverActive(): boolean {
-        return this.device.__isKernelDriverActive(this.id);
-    }
-
-    /**
-     * Detaches the kernel driver from the interface.
-     *
-     * The device must be open to use this method.
-     */
-    public detachKernelDriver(): void {
-        return this.device.__detachKernelDriver(this.id);
-    }
-
-    /**
-     * Re-attaches the kernel driver for the interface.
-     *
-     * The device must be open to use this method.
-     */
-    public attachKernelDriver(): void {
-        return this.device.__attachKernelDriver(this.id);
-    }
-
-    /**
-     * Sets the alternate setting. It updates the `interface.endpoints` array to reflect the endpoints found in the alternate setting.
-     *
-     * The device must be open to use this method.
-     * @param altSetting
-     * @param callback
-     */
-    public setAltSetting(altSetting: number, callback?: (error: LibUSBException | undefined) => void): void {
-        this.device.__setInterface(this.id, altSetting, error => {
-            if (!error) {
-                this.altSetting = altSetting;
-                this.refresh();
-            }
-            if (callback) {
-                callback.call(this, error);
-            }
-        });
-    }
-
-    /**
-     * Return the InEndpoint or OutEndpoint with the specified address.
-     *
-     * The device must be open to use this method.
-     * @param addr
-     */
-    public endpoint(addr: number): Endpoint | undefined {
-        return this.endpoints.find(item => item.address === addr);
-    }
-}