@yume-chan/adb 0.0.9 → 0.0.10

package/src/packet.ts

@@ -1,89 +1,84 @@
-import Struct from '@yume-chan/struct';
-import { AdbBackend } from './backend';
-import { BufferedStream } from './stream';
-
-export enum AdbCommand {
-    Auth = 0x48545541,    // 'AUTH'
-    Close = 0x45534c43,   // 'CLSE'
-    Connect = 0x4e584e43, // 'CNXN'
-    OK = 0x59414b4f,      // 'OKAY'
-    Open = 0x4e45504f,    // 'OPEN'
-    Write = 0x45545257,   // 'WRTE'
-}
-
-const AdbPacketHeader =
-    new Struct({ littleEndian: true })
-        .uint32('command')
-        .uint32('arg0')
-        .uint32('arg1')
-        .uint32('payloadLength')
-        .uint32('checksum')
-        .int32('magic');
-
-const AdbPacketStruct =
-    new Struct({ littleEndian: true })
-        .fields(AdbPacketHeader)
-        .arrayBuffer('payload', { lengthField: 'payloadLength' });
-
-export type AdbPacket = typeof AdbPacketStruct['TDeserializeResult'];
-
-export type AdbPacketInit = Omit<typeof AdbPacketStruct['TInit'], 'checksum' | 'magic'>;
-
-export namespace AdbPacket {
-    export async function read(backend: AdbBackend): Promise<AdbPacket> {
-        let buffer = await backend.read(24);
-
-        // Detect boundary
-        // Note that it relies on the backend to only return data from one write operation
-        while (buffer.byteLength !== 24) {
-            // Maybe it's a payload from last connection.
-            // Ignore and try again
-            buffer = await backend.read(24);
-        }
-
-        let bufferUsed = false;
-        const stream = new BufferedStream({
-            read(length: number) {
-                if (!bufferUsed) {
-                    bufferUsed = true;
-                    return buffer;
-                }
-                return backend.read(length);
-            }
-        });
-
-        return AdbPacketStruct.deserialize({
-            read: stream.read.bind(stream),
-            decodeUtf8: backend.decodeUtf8.bind(backend),
-            encodeUtf8: backend.encodeUtf8.bind(backend),
-        });
-    }
-
-    export async function write(
-        init: AdbPacketInit,
-        calculateChecksum: boolean,
-        backend: AdbBackend
-    ): Promise<void> {
-        let checksum: number;
-        if (calculateChecksum && init.payload) {
-            const array = new Uint8Array(init.payload);
-            checksum = array.reduce((result, item) => result + item, 0);
-        } else {
-            checksum = 0;
-        }
-
-        const packet = {
-            ...init,
-            checksum,
-            magic: init.command ^ 0xFFFFFFFF,
-            payloadLength: init.payload.byteLength,
-        };
-
-        // Write payload separately to avoid an extra copy
-        const header = AdbPacketHeader.serialize(packet, backend);
-        await backend.write(header);
-        if (packet.payload.byteLength) {
-            await backend.write(packet.payload);
-        }
-    }
-}
+import Struct from '@yume-chan/struct';
+import { AdbBackend } from './backend';
+import { BufferedStream } from './stream';
+
+export enum AdbCommand {
+    Auth = 0x48545541,    // 'AUTH'
+    Close = 0x45534c43,   // 'CLSE'
+    Connect = 0x4e584e43, // 'CNXN'
+    OK = 0x59414b4f,      // 'OKAY'
+    Open = 0x4e45504f,    // 'OPEN'
+    Write = 0x45545257,   // 'WRTE'
+}
+
+const AdbPacketHeader =
+    new Struct({ littleEndian: true })
+        .uint32('command')
+        .uint32('arg0')
+        .uint32('arg1')
+        .uint32('payloadLength')
+        .uint32('checksum')
+        .int32('magic');
+
+const AdbPacketStruct =
+    new Struct({ littleEndian: true })
+        .fields(AdbPacketHeader)
+        .arrayBuffer('payload', { lengthField: 'payloadLength' });
+
+export type AdbPacket = typeof AdbPacketStruct['TDeserializeResult'];
+
+export type AdbPacketInit = Omit<typeof AdbPacketStruct['TInit'], 'checksum' | 'magic'>;
+
+export namespace AdbPacket {
+    export async function read(backend: AdbBackend): Promise<AdbPacket> {
+        // Detect boundary
+        // Note that it relies on the backend to only return data from one write operation
+        let buffer: ArrayBuffer;
+        do {
+            // Maybe it's a payload from last connection.
+            // Ignore and try again
+            buffer = await backend.read(24);
+        } while (buffer.byteLength !== 24);
+
+        let bufferUsed = false;
+        const stream = new BufferedStream({
+            async read(length: number) {
+                if (!bufferUsed) {
+                    bufferUsed = true;
+                    return buffer;
+                }
+                return backend.read(length);
+            }
+        });
+
+        return AdbPacketStruct.deserialize(stream);
+    }
+
+    export async function write(
+        init: AdbPacketInit,
+        calculateChecksum: boolean,
+        backend: AdbBackend
+    ): Promise<void> {
+        let checksum: number;
+        if (calculateChecksum && init.payload) {
+            const array = new Uint8Array(init.payload);
+            checksum = array.reduce((result, item) => result + item, 0);
+        } else {
+            checksum = 0;
+        }
+
+        const packet = {
+            ...init,
+            checksum,
+            magic: init.command ^ 0xFFFFFFFF,
+            payloadLength: init.payload.byteLength,
+        };
+
+        // Write payload separately to avoid an extra copy
+        const header = AdbPacketHeader.serialize(packet);
+        await backend.write(header);
+        if (packet.payload.byteLength) {
+            await backend.write(packet.payload);
+        }
+    }
+}

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

@@ -1,28 +1,28 @@
-import { EventEmitter, EventListenerInfo, RemoveEventListener } from '@yume-chan/event';
-
-const NoopRemoveEventListener: RemoveEventListener = () => { };
-NoopRemoveEventListener.dispose = NoopRemoveEventListener;
-
-export class CloseEventEmitter extends EventEmitter<void, void>{
-    private closed = false;
-
-    protected addEventListener(info: EventListenerInfo<void, void>) {
-        if (this.closed) {
-            info.listener.apply(info.thisArg, [undefined, ...info.args]);
-            return NoopRemoveEventListener;
-        } else {
-            return super.addEventListener(info);
-        }
-    }
-
-    public fire() {
-        super.fire();
-        this.closed = true;
-        this.listeners.length = 0;
-    }
-
-    public dispose() {
-        this.fire();
-        super.dispose();
-    }
-}
+import { EventEmitter, EventListenerInfo, RemoveEventListener } from '@yume-chan/event';
+
+const NoopRemoveEventListener: RemoveEventListener = () => { };
+NoopRemoveEventListener.dispose = NoopRemoveEventListener;
+
+export class CloseEventEmitter extends EventEmitter<void, void>{
+    private closed = false;
+
+    protected override addEventListener(info: EventListenerInfo<void, void>) {
+        if (this.closed) {
+            info.listener.apply(info.thisArg, [undefined, ...info.args]);
+            return NoopRemoveEventListener;
+        } else {
+            return super.addEventListener(info);
+        }
+    }
+
+    public override fire() {
+        super.fire();
+        this.closed = true;
+        this.listeners.length = 0;
+    }
+
+    public override dispose() {
+        this.fire();
+        super.dispose();
+    }
+}

package/src/socket/controller.ts

@@ -1,105 +1,105 @@
-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();
-    }
-}
+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 override dispose() {
+        this._closed = true;
+        this.closeEvent.fire();
+        super.dispose();
+    }
+}

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

@@ -1,27 +1,27 @@
-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]);
-        }
-    }
-}
+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 override addEventListener(info: EventListenerInfo<TEvent, AsyncEventResult>) {
+        const remove = super.addEventListener(info);
+        if (this.listeners.length === 1) {
+            this.dispatchLock.resolve();
+        }
+        return remove;
+    }
+
+    public override async fire(e: TEvent) {
+        await this.dispatchLock.promise;
+
+        for (const info of this.listeners) {
+            await info.listener.apply(info.thisArg, [e, ...info.args]);
+        }
+    }
+}