@yume-chan/adb 0.0.10 → 0.0.11

package/src/commands/shell/protocol.ts

@@ -1,121 +0,0 @@
-import { EventEmitter } from "@yume-chan/event";
-import Struct, { placeholder } from "@yume-chan/struct";
-import type { Adb } from "../../adb";
-import { AdbFeatures } from "../../features";
-import type { AdbSocket } from "../../socket";
-import { AdbBufferedStream } from "../../stream";
-import { encodeUtf8 } from "../../utils";
-import type { AdbShell } from "./types";
-
-export enum AdbShellProtocolId {
-    Stdin,
-    Stdout,
-    Stderr,
-    Exit,
-    CloseStdin,
-    WindowSizeChange,
-}
-
-// This packet format is used in both direction.
-const AdbShellProtocolPacket = new Struct({ littleEndian: true })
-    .uint8('id', placeholder<AdbShellProtocolId>())
-    .uint32('length')
-    .arrayBuffer('data', { lengthField: 'length' });
-
-function assertUnreachable(x: never): never {
-    throw new Error("Unreachable");
-}
-
-/**
- * Shell v2 a.k.a Shell Protocol
- *
- * Features:
- * * `onStderr`: Yes
- * * `onExit` exit code: Yes
- * * `resize`: Yes
- */
-export class AdbShellProtocol implements AdbShell {
-    public static isSupported(adb: Adb) {
-        return adb.features!.includes(AdbFeatures.ShellV2);
-    }
-
-    public static async spawn(adb: Adb, command: string) {
-        // TODO: the service string may support more parameters
-        return new AdbShellProtocol(await adb.createSocket(`shell,v2,pty:${command}`));
-    }
-
-    private readonly stream: AdbBufferedStream;
-
-    private readonly stdoutEvent = new EventEmitter<ArrayBuffer>();
-    public get onStdout() { return this.stdoutEvent.event; }
-
-    private readonly stderrEvent = new EventEmitter<ArrayBuffer>();
-    public get onStderr() { return this.stderrEvent.event; }
-
-    private readonly exitEvent = new EventEmitter<number>();
-    public get onExit() { return this.exitEvent.event; }
-
-    public constructor(socket: AdbSocket) {
-        this.stream = new AdbBufferedStream(socket);
-        this.readData();
-    }
-
-    private async readData() {
-        while (true) {
-            try {
-                const packet = await AdbShellProtocolPacket.deserialize(this.stream);
-                switch (packet.id) {
-                    case AdbShellProtocolId.Stdout:
-                        this.stdoutEvent.fire(packet.data);
-                        break;
-                    case AdbShellProtocolId.Stderr:
-                        this.stderrEvent.fire(packet.data);
-                        break;
-                    case AdbShellProtocolId.Exit:
-                        this.exitEvent.fire(new Uint8Array(packet.data)[0]);
-                        break;
-                    case AdbShellProtocolId.CloseStdin:
-                    case AdbShellProtocolId.Stdin:
-                    case AdbShellProtocolId.WindowSizeChange:
-                        // These ids are client-to-server
-                        throw new Error('unreachable');
-                    default:
-                        assertUnreachable(packet.id);
-                }
-            } catch {
-                return;
-            }
-        }
-    }
-
-    public async write(data: ArrayBuffer) {
-        this.stream.write(
-            AdbShellProtocolPacket.serialize(
-                {
-                    id: AdbShellProtocolId.Stdin,
-                    data,
-                }
-            )
-        );
-    }
-
-    public async resize(rows: number, cols: number) {
-        await this.stream.write(
-            AdbShellProtocolPacket.serialize(
-                {
-                    id: AdbShellProtocolId.WindowSizeChange,
-                    data: encodeUtf8(
-                        // The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`
-                        // However, according to https://linux.die.net/man/4/tty_ioctl
-                        // `x_pixels` and `y_pixels` are not used, so always pass `0` is fine.
-                        `${rows}x${cols},0x0\0`
-                    ),
-                }
-            )
-        );
-    }
-
-    public kill() {
-        return this.stream.close();
-    }
-}

package/src/commands/shell/types.ts

@@ -1,55 +0,0 @@
-import type { Event } from "@yume-chan/event";
-import type { ValueOrPromise } from "@yume-chan/struct";
-import type { Adb } from "../../adb";
-import type { AdbSocket } from "../../socket";
-
-export interface AdbShell {
-    /**
-     * Notifies that new data has been written into the `stdout` stream.
-     */
-    readonly onStdout: Event<ArrayBuffer>;
-
-    /**
-     * Notifies that new data has been written into the `stderr` stream.
-     *
-     * Some `AdbShell`s may not support separate output streams
-     * and will always fire the `onStdout` event instead.
-     */
-    readonly onStderr: Event<ArrayBuffer>;
-
-    /**
-     * Notifies that the current process has exited.
-     *
-     * The event arg is the exit code.
-     * Some `AdbShell`s may not support returning exit code and will always return `0` instead.
-     */
-    readonly onExit: Event<number>;
-
-    /**
-     * Writes raw PTY data into the `stdin` stream.
-     */
-    write(data: ArrayBuffer): Promise<void>;
-
-    /**
-     * Resizes the current shell.
-     *
-     * Some `AdbShell`s may not support resizing and will always ignore calls to this method.
-     */
-    resize(rows: number, cols: number): ValueOrPromise<void>;
-
-    /**
-     * Kills the current process.
-     */
-    kill(): ValueOrPromise<void>;
-}
-
-export interface AdbShellConstructor {
-    /** Returns `true` if the `adb` instance supports this shell */
-    isSupported(adb: Adb): ValueOrPromise<boolean>;
-
-    /** Creates a new `AdbShell` using the specified `Adb` and `command` */
-    spawn(adb: Adb, command: string): ValueOrPromise<AdbShell>;
-
-    /** Creates a new `AdbShell` by attaching to an exist `AdbSocket` */
-    new(socket: AdbSocket): AdbShell;
-}

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

@@ -1,28 +0,0 @@
-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 +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 override 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 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]);
-        }
-    }
-}

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,92 +0,0 @@
-import { StructAsyncDeserializeStream } 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, StructAsyncDeserializeStream {
-    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);
-    }
-}

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);
-    }
-}