@yume-chan/adb 0.0.8 → 0.0.11

package/src/socket/controller.ts

@@ -1,105 +0,0 @@
-import { AutoDisposable } from '@yume-chan/event';
-import { AdbBackend } from '../backend';
-import { AdbCommand } from '../packet';
-import { AutoResetEvent, chunkArrayLike } from '../utils';
-import { CloseEventEmitter } from './close-event-emitter';
-import { DataEventEmitter } from './data-event-emitter';
-import { AdbPacketDispatcher } from './dispatcher';
-
-export interface AdbSocketInfo {
-    backend: AdbBackend;
-
-    localId: number;
-
-    remoteId: number;
-
-    localCreated: boolean;
-
-    serviceString: string;
-}
-
-export interface AdbSocketConstructionOptions {
-    dispatcher: AdbPacketDispatcher;
-
-    localId: number;
-
-    remoteId: number;
-
-    localCreated: boolean;
-
-    serviceString: string;
-}
-
-export class AdbSocketController extends AutoDisposable implements AdbSocketInfo {
-    private readonly writeChunkLock = this.addDisposable(new AutoResetEvent());
-    private readonly writeLock = this.addDisposable(new AutoResetEvent());
-
-    private readonly dispatcher!: AdbPacketDispatcher;
-    public get backend() { return this.dispatcher.backend; }
-
-    public readonly localId!: number;
-    public readonly remoteId!: number;
-    public readonly localCreated!: boolean;
-    public readonly serviceString!: string;
-
-    public readonly dataEvent = this.addDisposable(new DataEventEmitter<ArrayBuffer>());
-
-    private _closed = false;
-    public get closed() { return this._closed; }
-
-    private readonly closeEvent = this.addDisposable(new CloseEventEmitter());
-    public get onClose() { return this.closeEvent.event; }
-
-    public constructor(options: AdbSocketConstructionOptions) {
-        super();
-        Object.assign(this, options);
-    }
-
-    private async writeChunk(data: ArrayBuffer): Promise<void> {
-        try {
-            // Wait for an ack packet
-            await this.writeChunkLock.wait();
-        } catch {
-            // Lock has been disposed, which means the socket has been closed
-            throw new Error('Can not write after closed');
-        }
-
-        await this.dispatcher.sendPacket(AdbCommand.Write, this.localId, this.remoteId, data);
-    }
-
-    public async write(data: ArrayBuffer): Promise<void> {
-        try {
-            // Keep write operations in order
-            await this.writeLock.wait();
-        } catch {
-            // Lock has been disposed, which means the socket has been closed
-            throw new Error('Can not write after closed');
-        }
-
-        for await (const chunk of chunkArrayLike(data, this.dispatcher.maxPayloadSize)) {
-            await this.writeChunk(chunk);
-        }
-        this.writeLock.notify();
-    }
-
-    public ack() {
-        this.writeChunkLock.notify();
-    }
-
-    public async close(): Promise<void> {
-        if (!this._closed) {
-            // Immediately cancel all pending writes
-            this.writeLock.dispose();
-            this.writeChunkLock.dispose();
-
-            await this.dispatcher.sendPacket(AdbCommand.Close, this.localId, this.remoteId);
-            this._closed = true;
-        }
-    }
-
-    public dispose() {
-        this._closed = true;
-        this.closeEvent.fire();
-        super.dispose();
-    }
-}

package/src/socket/data-event-emitter.ts

@@ -1,27 +0,0 @@
-import { PromiseResolver } from '@yume-chan/async';
-import { Event, EventEmitter, EventListenerInfo } from '@yume-chan/event';
-import { ValueOrPromise } from '@yume-chan/struct';
-
-export type AsyncEventResult = ValueOrPromise<void>;
-
-export type AsyncEvent<TEvent> = Event<TEvent, AsyncEventResult>;
-
-export class DataEventEmitter<TEvent> extends EventEmitter<TEvent, AsyncEventResult> {
-    private dispatchLock = new PromiseResolver<void>();
-
-    protected addEventListener(info: EventListenerInfo<TEvent, AsyncEventResult>) {
-        const remove = super.addEventListener(info);
-        if (this.listeners.length === 1) {
-            this.dispatchLock.resolve();
-        }
-        return remove;
-    }
-
-    public async fire(e: TEvent) {
-        await this.dispatchLock.promise;
-
-        for (const info of this.listeners) {
-            await info.listener.apply(info.thisArg, [e, ...info.args]);
-        }
-    }
-}

package/src/socket/logger.ts

@@ -1,12 +0,0 @@
-import { AdbPacket, AdbPacketInit } from '../packet';
-import { AdbSocket } from './socket';
-
-export interface AdbLogger {
-    onIncomingPacket?(packet: AdbPacket): void;
-
-    onOutgoingPacket?(packet: AdbPacketInit): void;
-
-    onSocketOpened?(socket: AdbSocket): void;
-
-    onSocketClosed?(socket: AdbSocket): void;
-}

package/src/stream/buffered-stream.ts

@@ -1,100 +0,0 @@
-import { StructDeserializationContext } from '@yume-chan/struct';
-import { AdbSocket, AdbSocketInfo } from '../socket';
-import { AdbSocketStream } from './stream';
-
-export interface Stream {
-    /**
-     * @param length A hint of how much data should be read.
-     * @returns Data, which can be either more or less than `length`
-     */
-    read(length: number): ArrayBuffer | Promise<ArrayBuffer>;
-
-    close?(): void;
-}
-
-export class BufferedStream<T extends Stream> {
-    private buffer: Uint8Array | undefined;
-
-    protected readonly stream: T;
-
-    public constructor(stream: T) {
-        this.stream = stream;
-    }
-
-    public async read(length: number): Promise<ArrayBuffer> {
-        let array: Uint8Array;
-        let index: number;
-        if (this.buffer) {
-            const buffer = this.buffer;
-            if (buffer.byteLength > length) {
-                this.buffer = buffer.subarray(length);
-                return buffer.slice(0, length).buffer;
-            }
-
-            array = new Uint8Array(length);
-            array.set(buffer);
-            index = buffer.byteLength;
-            this.buffer = undefined;
-        } else {
-            const buffer = await this.stream.read(length);
-            if (buffer.byteLength === length) {
-                return buffer;
-            }
-
-            if (buffer.byteLength > length) {
-                this.buffer = new Uint8Array(buffer, length);
-                return buffer.slice(0, length);
-            }
-
-            array = new Uint8Array(length);
-            array.set(new Uint8Array(buffer), 0);
-            index = buffer.byteLength;
-        }
-
-        while (index < length) {
-            const left = length - index;
-
-            const buffer = await this.stream.read(left);
-            if (buffer.byteLength > left) {
-                array.set(new Uint8Array(buffer, 0, left), index);
-                this.buffer = new Uint8Array(buffer, left);
-                return array.buffer;
-            }
-
-            array.set(new Uint8Array(buffer), index);
-            index += buffer.byteLength;
-        }
-
-        return array.buffer;
-    }
-
-    public close() {
-        this.stream.close?.();
-    }
-}
-
-export class AdbBufferedStream
-    extends BufferedStream<AdbSocketStream>
-    implements AdbSocketInfo, StructDeserializationContext {
-    public get backend() { return this.stream.backend; }
-    public get localId() { return this.stream.localId; }
-    public get remoteId() { return this.stream.remoteId; }
-    public get localCreated() { return this.stream.localCreated; }
-    public get serviceString() { return this.stream.serviceString; }
-
-    public constructor(socket: AdbSocket) {
-        super(new AdbSocketStream(socket));
-    }
-
-    public write(data: ArrayBuffer): Promise<void> {
-        return this.stream.write(data);
-    }
-
-    public decodeUtf8(buffer: ArrayBuffer): string {
-        return this.backend.decodeUtf8(buffer);
-    }
-
-    public encodeUtf8(input: string): ArrayBuffer {
-        return this.backend.encodeUtf8(input);
-    }
-}

package/src/stream/stream.ts

@@ -1,50 +0,0 @@
-import { once } from '@yume-chan/event';
-import { ValueOrPromise } from '@yume-chan/struct';
-import { AdbSocket, AdbSocketInfo } from '../socket';
-import { EventQueue } from '../utils';
-
-export class AdbSocketStream implements AdbSocketInfo {
-    private socket: AdbSocket;
-
-    private queue: EventQueue<ArrayBuffer>;
-
-    public get backend() { return this.socket.backend; }
-    public get localId() { return this.socket.localId; }
-    public get remoteId() { return this.socket.remoteId; }
-    public get localCreated() { return this.socket.localCreated; }
-    public get serviceString() { return this.socket.serviceString; }
-
-    public constructor(socket: AdbSocket) {
-        this.socket = socket;
-
-        this.queue = new EventQueue<ArrayBuffer>({
-            highWaterMark: 16 * 1024,
-        });
-
-        this.socket.onData((buffer): ValueOrPromise<void> => {
-            if (!this.queue.enqueue(buffer, buffer.byteLength)) {
-                return once(this.queue.onDrain);
-            }
-        });
-
-        this.socket.onClose(() => {
-            this.queue.end();
-        });
-    }
-
-    public async read(): Promise<ArrayBuffer> {
-        try {
-            return await this.queue.dequeue();
-        } catch {
-            throw new Error('Can not read after AdbSocketStream has been closed');
-        }
-    }
-
-    public write(data: ArrayBuffer): Promise<void> {
-        return this.socket.write(data);
-    }
-
-    close(): void {
-        this.socket.close();
-    }
-}

package/src/utils/chunk.ts

@@ -1,70 +0,0 @@
-export function* chunkArrayLike(
-    value: ArrayLike<number> | ArrayBufferLike,
-    size: number
-): Generator<ArrayBuffer, void, void> {
-    if ('length' in value) {
-        value = new Uint8Array(value).buffer;
-    }
-
-    if (value.byteLength <= size) {
-        return yield value;
-    }
-
-    for (let i = 0; i < value.byteLength; i += size) {
-        yield value.slice(i, i + size);
-    }
-}
-
-export async function* chunkAsyncIterable(
-    value: AsyncIterable<ArrayBuffer>,
-    size: number
-): AsyncGenerator<ArrayBuffer, void, void> {
-    let result = new Uint8Array(size);
-    let index = 0;
-    for await (let buffer of value) {
-        // `result` has some data, `result + buffer` is enough
-        if (index !== 0 && index + buffer.byteLength >= size) {
-            const remainder = size - index;
-            result.set(new Uint8Array(buffer, 0, remainder), index);
-            yield result.buffer;
-
-            result = new Uint8Array(size);
-            index = 0;
-
-            if (buffer.byteLength > remainder) {
-                // `buffer` still has some data
-                buffer = buffer.slice(remainder);
-            } else {
-                continue;
-            }
-        }
-
-        // `result` is empty, `buffer` alone is enough
-        if (buffer.byteLength >= size) {
-            let remainder = false;
-            for (const chunk of chunkArrayLike(buffer, size)) {
-                if (chunk.byteLength === size) {
-                    yield chunk;
-                    continue;
-                }
-
-                // `buffer` still has some data
-                remainder = true;
-                buffer = chunk;
-            }
-
-            if (!remainder) {
-                continue;
-            }
-        }
-
-        // `result` has some data but `result + buffer` is still not enough
-        // or after previous steps `buffer` still has some data
-        result.set(new Uint8Array(buffer), index);
-        index += buffer.byteLength;
-    }
-
-    if (index !== 0) {
-        yield result.buffer.slice(0, index);
-    }
-}

package/src/utils/event-queue.ts

@@ -1,145 +0,0 @@
-import { PromiseResolver } from '@yume-chan/async';
-import { EventEmitter } from '@yume-chan/event';
-
-export interface EventQueueOptions {
-    maxWaitCount: number;
-
-    highWaterMark: number;
-
-    lowWaterMark: number;
-}
-
-export const EventQueueDefaultOptions: EventQueueOptions = {
-    maxWaitCount: Infinity,
-    highWaterMark: 10,
-    lowWaterMark: 0,
-};
-
-interface LinkedListItem<T> {
-    value: T;
-
-    next?: LinkedListItem<T>;
-}
-
-class LinkedList<T>{
-    private head?: LinkedListItem<T>;
-
-    private tail?: LinkedListItem<T>;
-
-    private _length = 0;
-    public get length() { return this._length; }
-
-    public push(value: T): void {
-        const item: LinkedListItem<T> = { value };
-
-        if (this._length === 0) {
-            this.head = item;
-        } else {
-            this.tail!.next = item;
-        }
-
-        this._length += 1;
-        this.tail = item;
-    }
-
-    public shift(): T | undefined {
-        if (this._length === 0) {
-            return;
-        }
-
-        const { next, value } = this.head!;
-        if (!next) {
-            this.tail = undefined;
-        }
-
-        this.head = next;
-        this._length -= 1;
-        return value;
-    }
-}
-
-/**
- * Basically an object-mode ReadableStream with Promise-based API
- *
- * It's called `EventQueue` because it usually converts events ("push system") to "pull system"
- *
- * https://github.com/nodejs/node/blob/master/lib/internal/streams/readable.js
- */
-export class EventQueue<T> {
-    // Use linked lists for faster shift operation.
-
-    /** Already buffered data ready to be served to consumers */
-    private buffers = new LinkedList<[value: T, size: number]>();
-
-    /** Waiting consumers because lack of data */
-    private awaiters = new LinkedList<PromiseResolver<T>>();
-
-    private options: EventQueueOptions;
-
-    private ended = false;
-
-    private _length = 0;
-    public get length() { return this._length; }
-
-    private _needDrain = false;
-    public get needDrain() { return this._needDrain; }
-
-    private readonly drainEvent = new EventEmitter<void>();
-    public readonly onDrain = this.drainEvent.event;
-
-    public constructor(options?: Partial<EventQueueOptions>) {
-        this.options = { ...EventQueueDefaultOptions, ...options };
-    }
-
-    public enqueue(value: T, length = 1): boolean {
-        if (this.ended) {
-            return true;
-        }
-
-        if (this.awaiters.length) {
-            this.awaiters.shift()!.resolve(value);
-            return true;
-        }
-
-        this.buffers.push([value, length]);
-        this._length += length;
-        if (this._length < this.options.highWaterMark) {
-            return true;
-        }
-
-        this._needDrain = true;
-        return false;
-    }
-
-    public dequeue(): Promise<T> {
-        if (this.buffers.length) {
-            const [value, size] = this.buffers.shift()!;
-            this._length -= size;
-            if (this._needDrain &&
-                this._length <= this.options.lowWaterMark) {
-                this.drainEvent.fire();
-            }
-            return Promise.resolve(value);
-        }
-
-        if (this.ended) {
-            return Promise.reject(new Error('The EventQueue has already ended'));
-        }
-
-        if (this.awaiters.length === this.options.maxWaitCount - 1) {
-            throw new Error('Max wait count exceeded');
-        }
-
-        const resolver = new PromiseResolver<T>();
-        this.awaiters.push(resolver);
-        return resolver.promise;
-    }
-
-    public end(): void {
-        this.ended = true;
-        let item: PromiseResolver<T> | undefined;
-        while (item = this.awaiters.shift()) {
-            item.reject(new Error('The EventQueue has already ended'));
-        }
-    }
-}

package/tsconfig.cjs.json

@@ -1,11 +0,0 @@
-{
-    "extends": "./tsconfig.esm.json",
-    "compilerOptions": {
-        "composite": false,
-        "module": "CommonJS",
-        "outDir": "cjs",
-        "declaration": false,
-        "declarationDir": null,
-        "declarationMap": false
-    }
-}

package/tsconfig.esm.json

@@ -1,28 +0,0 @@
-{
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "rootDir": "src",
-        "outDir": "esm",
-        "target": "ES2016",
-        "declarationDir": "dts",
-        "types": [
-            "@yume-chan/async",
-            "@yume-chan/event",
-            "@yume-chan/struct",
-        ],
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "src/**/*.spec.ts"
-    ],
-    "references": [
-        {
-            "path": "../event/tsconfig.esm.json"
-        },
-        {
-            "path": "../struct/tsconfig.esm.json"
-        }
-    ]
-}