@yume-chan/adb 0.0.18 → 0.0.19

package/src/commands/sync/stat.ts

@@ -1,11 +1,8 @@
-import {
-    type BufferedReadableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
 import Struct, { placeholder } from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
+import type { AdbSyncSocket } from "./socket.js";
 
 // https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
 export enum LinuxFileType {
@@ -47,7 +44,7 @@ export const AdbSyncLstatResponse = new Struct({ littleEndian: true })
     });
 
 export type AdbSyncLstatResponse =
-    typeof AdbSyncLstatResponse["TDeserializeResult"];
+    (typeof AdbSyncLstatResponse)["TDeserializeResult"];
 
 export enum AdbSyncStatErrorCode {
     SUCCESS = 0,
@@ -101,52 +98,60 @@ export const AdbSyncStatResponse = new Struct({ littleEndian: true })
     });
 
 export type AdbSyncStatResponse =
-    typeof AdbSyncStatResponse["TDeserializeResult"];
+    (typeof AdbSyncStatResponse)["TDeserializeResult"];
 
 export async function adbSyncLstat(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string,
     v2: boolean
 ): Promise<AdbSyncStat> {
-    if (v2) {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat2, path);
-        return await adbSyncReadResponse(
-            stream,
-            AdbSyncResponseId.Lstat2,
-            AdbSyncStatResponse
-        );
-    } else {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat, path);
-        const response = await adbSyncReadResponse(
-            stream,
-            AdbSyncResponseId.Lstat,
-            AdbSyncLstatResponse
-        );
-        return {
-            mode: response.mode,
-            // Convert to `BigInt` to make it compatible with `AdbSyncStatResponse`
-            size: BigInt(response.size),
-            mtime: BigInt(response.mtime),
-            get type() {
-                return response.type;
-            },
-            get permission() {
-                return response.permission;
-            },
-        };
+    const locked = await socket.lock();
+    try {
+        if (v2) {
+            await adbSyncWriteRequest(locked, AdbSyncRequestId.LstatV2, path);
+            return await adbSyncReadResponse(
+                locked,
+                AdbSyncResponseId.Lstat2,
+                AdbSyncStatResponse
+            );
+        } else {
+            await adbSyncWriteRequest(locked, AdbSyncRequestId.Lstat, path);
+            const response = await adbSyncReadResponse(
+                locked,
+                AdbSyncResponseId.Lstat,
+                AdbSyncLstatResponse
+            );
+            return {
+                mode: response.mode,
+                // Convert to `BigInt` to make it compatible with `AdbSyncStatResponse`
+                size: BigInt(response.size),
+                mtime: BigInt(response.mtime),
+                get type() {
+                    return response.type;
+                },
+                get permission() {
+                    return response.permission;
+                },
+            };
+        }
+    } finally {
+        locked.release();
     }
 }
 
 export async function adbSyncStat(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string
 ): Promise<AdbSyncStatResponse> {
-    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
-    return await adbSyncReadResponse(
-        stream,
-        AdbSyncResponseId.Stat,
-        AdbSyncStatResponse
-    );
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.Stat, path);
+        return await adbSyncReadResponse(
+            locked,
+            AdbSyncResponseId.Stat,
+            AdbSyncStatResponse
+        );
+    } finally {
+        locked.release();
+    }
 }

package/src/commands/sync/sync.ts

@@ -1,22 +1,16 @@
 import { AutoDisposable } from "@yume-chan/event";
-import {
-    BufferedReadableStream,
-    WrapReadableStream,
-    WrapWritableStream,
-    type ReadableStream,
-    type WritableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
-
-import { type Adb } from "../../adb.js";
-import { AdbFeatures } from "../../features.js";
-import { type AdbSocket } from "../../socket/index.js";
-import { AutoResetEvent } from "../../utils/index.js";
+import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
+
+import type { Adb } from "../../adb.js";
+import { AdbFeature } from "../../features.js";
+import type { AdbSocket } from "../../socket/index.js";
 import { escapeArg } from "../subprocess/index.js";
 
-import { adbSyncOpenDir, type AdbSyncEntry } from "./list.js";
+import type { AdbSyncEntry } from "./list.js";
+import { adbSyncOpenDir } from "./list.js";
 import { adbSyncPull } from "./pull.js";
 import { adbSyncPush } from "./push.js";
+import { AdbSyncSocket } from "./socket.js";
 import { adbSyncLstat, adbSyncStat } from "./stat.js";
 
 /**
@@ -35,57 +29,64 @@ export function dirname(path: string): string {
     return path.substring(0, end);
 }
 
+export interface AdbSyncWriteOptions {
+    filename: string;
+    file: ReadableStream<Consumable<Uint8Array>>;
+    mode?: number;
+    mtime?: number;
+    dryRun?: boolean;
+}
+
 export class AdbSync extends AutoDisposable {
-    protected adb: Adb;
+    protected _adb: Adb;
+    protected _socket: AdbSyncSocket;
 
-    protected stream: BufferedReadableStream;
-    // Getting another writer on a locked WritableStream will throw.
-    // We don't want this behavior on higher-level APIs.
-    // So we acquire the writer early and use a blocking lock to guard it.
-    protected writer: WritableStreamDefaultWriter<Uint8Array>;
-    protected sendLock = this.addDisposable(new AutoResetEvent());
+    private _supportsStat: boolean;
+    private _supportsListV2: boolean;
+    private _fixedPushMkdir: boolean;
+    private _supportsSendReceiveV2: boolean;
+    private _needPushMkdirWorkaround: boolean;
 
     public get supportsStat(): boolean {
-        return this.adb.features.includes(AdbFeatures.StatV2);
+        return this._supportsStat;
     }
 
-    public get supportsList2(): boolean {
-        return this.adb.features.includes(AdbFeatures.ListV2);
+    public get supportsListV2(): boolean {
+        return this._supportsListV2;
     }
 
     public get fixedPushMkdir(): boolean {
-        return this.adb.features.includes(AdbFeatures.FixedPushMkdir);
+        return this._fixedPushMkdir;
+    }
+
+    public get supportsSendReceiveV2(): boolean {
+        return this._supportsSendReceiveV2;
     }
 
     public get needPushMkdirWorkaround(): boolean {
-        // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
-        return (
-            this.adb.features.includes(AdbFeatures.ShellV2) &&
-            !this.fixedPushMkdir
-        );
+        return this._needPushMkdirWorkaround;
     }
 
     public constructor(adb: Adb, socket: AdbSocket) {
         super();
 
-        this.adb = adb;
-        this.stream = new BufferedReadableStream(socket.readable);
-        this.writer = socket.writable.getWriter();
+        this._adb = adb;
+        this._socket = new AdbSyncSocket(socket, adb.maxPayloadSize);
+
+        this._supportsStat = adb.supportsFeature(AdbFeature.StatV2);
+        this._supportsListV2 = adb.supportsFeature(AdbFeature.ListV2);
+        this._fixedPushMkdir = adb.supportsFeature(AdbFeature.FixedPushMkdir);
+        this._supportsSendReceiveV2 = adb.supportsFeature(
+            AdbFeature.SendReceiveV2
+        );
+        // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
+        this._needPushMkdirWorkaround =
+            this._adb.supportsFeature(AdbFeature.ShellV2) &&
+            !this.fixedPushMkdir;
     }
 
     public async lstat(path: string) {
-        await this.sendLock.wait();
-
-        try {
-            return adbSyncLstat(
-                this.stream,
-                this.writer,
-                path,
-                this.supportsStat
-            );
-        } finally {
-            this.sendLock.notify();
-        }
+        return await adbSyncLstat(this._socket, path, this.supportsStat);
     }
 
     public async stat(path: string) {
@@ -93,13 +94,7 @@ export class AdbSync extends AutoDisposable {
             throw new Error("Not supported");
         }
 
-        await this.sendLock.wait();
-
-        try {
-            return adbSyncStat(this.stream, this.writer, path);
-        } finally {
-            this.sendLock.notify();
-        }
+        return await adbSyncStat(this._socket, path);
     }
 
     public async isDirectory(path: string): Promise<boolean> {
@@ -111,21 +106,8 @@ export class AdbSync extends AutoDisposable {
         }
     }
 
-    public async *opendir(
-        path: string
-    ): AsyncGenerator<AdbSyncEntry, void, void> {
-        await this.sendLock.wait();
-
-        try {
-            yield* adbSyncOpenDir(
-                this.stream,
-                this.writer,
-                path,
-                this.supportsList2
-            );
-        } finally {
-            this.sendLock.notify();
-        }
+    public opendir(path: string): AsyncGenerator<AdbSyncEntry, void, void> {
+        return adbSyncOpenDir(this._socket, path, this.supportsListV2);
     }
 
     public async readdir(path: string) {
@@ -143,61 +125,39 @@ export class AdbSync extends AutoDisposable {
      * @returns A `ReadableStream` that reads from the file.
      */
     public read(filename: string): ReadableStream<Uint8Array> {
-        return new WrapReadableStream({
-            start: async () => {
-                await this.sendLock.wait();
-                return adbSyncPull(this.stream, this.writer, filename);
-            },
-            close: () => {
-                this.sendLock.notify();
-            },
-        });
+        return adbSyncPull(this._socket, filename);
     }
 
     /**
      * Write (or overwrite) a file on device.
      *
      * @param filename The full path of the file on device to write.
+     * @param file The content to write.
      * @param mode The unix permissions of the file.
      * @param mtime The modified time of the file.
      * @returns A `WritableStream` that writes to the file.
      */
-    public write(
-        filename: string,
-        mode?: number,
-        mtime?: number
-    ): WritableStream<Uint8Array> {
-        return new WrapWritableStream({
-            start: async () => {
-                await this.sendLock.wait();
-
-                if (this.needPushMkdirWorkaround) {
-                    // It may fail if the path is already existed.
-                    // Ignore the result.
-                    // TODO: sync: test push mkdir workaround (need an Android 8 device)
-                    await this.adb.subprocess.spawnAndWait([
-                        "mkdir",
-                        "-p",
-                        escapeArg(dirname(filename)),
-                    ]);
-                }
-
-                return adbSyncPush(
-                    this.stream,
-                    this.writer,
-                    filename,
-                    mode,
-                    mtime
-                );
-            },
-            close: () => {
-                this.sendLock.notify();
-            },
+    public async write(options: AdbSyncWriteOptions) {
+        if (this.needPushMkdirWorkaround) {
+            // It may fail if the path is already existed.
+            // Ignore the result.
+            // TODO: sync: test push mkdir workaround (need an Android 8 device)
+            await this._adb.subprocess.spawnAndWait([
+                "mkdir",
+                "-p",
+                escapeArg(dirname(options.filename)),
+            ]);
+        }
+
+        await adbSyncPush({
+            v2: this.supportsSendReceiveV2,
+            socket: this._socket,
+            ...options,
         });
     }
 
     public override async dispose() {
         super.dispose();
-        await this.writer.close();
+        await this._socket.close();
     }
 }

package/src/commands/tcpip.ts

@@ -1,4 +1,4 @@
-import { AdbCommandBase } from './base.js';
+import { AdbCommandBase } from "./base.js";
 
 export class AdbTcpIpCommand extends AdbCommandBase {
     public async setPort(port: number): Promise<void> {
@@ -8,14 +8,14 @@ export class AdbTcpIpCommand extends AdbCommandBase {
 
         const output = await this.adb.createSocketAndWait(`tcpip:${port}`);
         if (output !== `restarting in TCP mode port: ${port}\n`) {
-            throw new Error('Invalid response');
+            throw new Error("Invalid response");
         }
     }
 
     public async disable(): Promise<void> {
-        const output = await this.adb.createSocketAndWait('usb:');
-        if (output !== 'restarting in USB mode\n') {
-            throw new Error('Invalid response');
+        const output = await this.adb.createSocketAndWait("usb:");
+        if (output !== "restarting in USB mode\n") {
+            throw new Error("Invalid response");
         }
     }
 }

package/src/features.ts

@@ -1,9 +1,12 @@
 // The order follows
 // https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
-export enum AdbFeatures {
-    ShellV2 = 'shell_v2',
-    Cmd = 'cmd',
-    StatV2 = 'stat_v2',
-    ListV2 = 'ls_v2',
-    FixedPushMkdir = 'fixed_push_mkdir',
+export enum AdbFeature {
+    ShellV2 = "shell_v2",
+    Cmd = "cmd",
+    StatV2 = "stat_v2",
+    ListV2 = "ls_v2",
+    FixedPushMkdir = "fixed_push_mkdir",
+    Abb = "abb",
+    AbbExec = "abb_exec",
+    SendReceiveV2 = "sendrecv_v2",
 }

package/src/packet.ts

@@ -1,4 +1,4 @@
-import { TransformStream } from "@yume-chan/stream-extra";
+import { ConsumableTransformStream } from "@yume-chan/stream-extra";
 import Struct from "@yume-chan/struct";
 
 export enum AdbCommand {
@@ -18,15 +18,15 @@ export const AdbPacketHeader = new Struct({ littleEndian: true })
     .uint32("checksum")
     .int32("magic");
 
-export type AdbPacketHeader = typeof AdbPacketHeader["TDeserializeResult"];
+export type AdbPacketHeader = (typeof AdbPacketHeader)["TDeserializeResult"];
 
-type AdbPacketHeaderInit = typeof AdbPacketHeader["TInit"];
+type AdbPacketHeaderInit = (typeof AdbPacketHeader)["TInit"];
 
 export const AdbPacket = new Struct({ littleEndian: true })
     .fields(AdbPacketHeader)
     .uint8Array("payload", { lengthField: "payloadLength" });
 
-export type AdbPacket = typeof AdbPacket["TDeserializeResult"];
+export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
 
 /**
  * `AdbPacketData` contains all the useful fields of `AdbPacket`.
@@ -39,50 +39,35 @@ export type AdbPacket = typeof AdbPacket["TDeserializeResult"];
  * so `AdbSocket#writable#write` only needs `AdbPacketData`.
  */
 export type AdbPacketData = Omit<
-    typeof AdbPacket["TInit"],
+    (typeof AdbPacket)["TInit"],
     "checksum" | "magic"
 >;
 
-// All fields except `magic`, which can be calculated in `AdbPacketSerializeStream`
-export type AdbPacketInit = Omit<typeof AdbPacket["TInit"], "magic">;
+export type AdbPacketInit = (typeof AdbPacket)["TInit"];
 
-export function calculateChecksum(payload: Uint8Array): number;
-export function calculateChecksum(init: AdbPacketData): AdbPacketInit;
-export function calculateChecksum(
-    payload: Uint8Array | AdbPacketData
-): number | AdbPacketInit {
-    if (payload instanceof Uint8Array) {
-        return payload.reduce((result, item) => result + item, 0);
-    } else {
-        (payload as AdbPacketInit).checksum = calculateChecksum(
-            payload.payload
-        );
-        return payload as AdbPacketInit;
-    }
+export function calculateChecksum(payload: Uint8Array): number {
+    return payload.reduce((result, item) => result + item, 0);
 }
 
-export class AdbPacketSerializeStream extends TransformStream<
+export class AdbPacketSerializeStream extends ConsumableTransformStream<
     AdbPacketInit,
     Uint8Array
 > {
     public constructor() {
+        const headerBuffer = new Uint8Array(AdbPacketHeader.size);
         super({
-            transform: (init, controller) => {
-                // This syntax is ugly, but I don't want to create a new object.
-                (init as unknown as AdbPacketHeaderInit).magic =
-                    init.command ^ 0xffffffff;
-                (init as unknown as AdbPacketHeaderInit).payloadLength =
-                    init.payload.byteLength;
+            transform: async (chunk, controller) => {
+                const init = chunk as AdbPacketInit & AdbPacketHeaderInit;
+                init.payloadLength = init.payload.byteLength;
 
-                controller.enqueue(
-                    AdbPacketHeader.serialize(
-                        init as unknown as AdbPacketHeaderInit
-                    )
-                );
+                AdbPacketHeader.serialize(init, headerBuffer);
+                await controller.enqueue(headerBuffer);
 
                 if (init.payload.byteLength) {
-                    // Enqueue payload separately to avoid copying
-                    controller.enqueue(init.payload);
+                    // USB protocol preserves packet boundaries,
+                    // so we must write payload separately as native ADB does,
+                    // otherwise the read operation on device will fail.
+                    await controller.enqueue(init.payload);
                 }
             },
         });

package/src/socket/dispatcher.ts

@@ -1,22 +1,24 @@
 import { AsyncOperationManager, PromiseResolver } from "@yume-chan/async";
-import { type RemoveEventListener } from "@yume-chan/event";
+import type { RemoveEventListener } from "@yume-chan/event";
+import type {
+    Consumable,
+    ReadableWritablePair,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
 import {
     AbortController,
+    ConsumableWritableStream,
     WritableStream,
-    type ReadableWritablePair,
-    type WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
-import { EMPTY_UINT8_ARRAY, type ValueOrPromise } from "@yume-chan/struct";
+import type { ValueOrPromise } from "@yume-chan/struct";
+import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
 
-import {
-    AdbCommand,
-    calculateChecksum,
-    type AdbPacketData,
-    type AdbPacketInit,
-} from "../packet.js";
+import type { AdbPacketData, AdbPacketInit } from "../packet.js";
+import { AdbCommand, calculateChecksum } from "../packet.js";
 import { decodeUtf8, encodeUtf8 } from "../utils/index.js";
 
-import { AdbSocketController, type AdbSocket } from "./socket.js";
+import type { AdbSocket } from "./socket.js";
+import { AdbSocketController } from "./socket.js";
 
 export interface AdbPacketDispatcherOptions {
     calculateChecksum: boolean;
@@ -57,7 +59,7 @@ export class AdbPacketDispatcher implements Closeable {
      */
     private readonly sockets = new Map<number, AdbSocketController>();
 
-    private _writer!: WritableStreamDefaultWriter<AdbPacketInit>;
+    private _writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
     public readonly options: AdbPacketDispatcherOptions;
 
@@ -72,7 +74,10 @@ export class AdbPacketDispatcher implements Closeable {
     private _abortController = new AbortController();
 
     public constructor(
-        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
+        connection: ReadableWritablePair<
+            AdbPacketData,
+            Consumable<AdbPacketInit>
+        >,
         options: AdbPacketDispatcherOptions
     ) {
         this.options = options;
@@ -273,50 +278,30 @@ export class AdbPacketDispatcher implements Closeable {
         return controller.socket;
     }
 
-    public sendPacket(packet: AdbPacketInit): Promise<void>;
-    public sendPacket(
+    public async sendPacket(
         command: AdbCommand,
         arg0: number,
         arg1: number,
-        payload?: string | Uint8Array
-    ): Promise<void>;
-    public async sendPacket(
-        packetOrCommand: AdbPacketInit | AdbCommand,
-        arg0?: number,
-        arg1?: number,
         payload: string | Uint8Array = EMPTY_UINT8_ARRAY
     ): Promise<void> {
-        let init: AdbPacketData;
-        if (arg0 === undefined) {
-            init = packetOrCommand as AdbPacketInit;
-        } else {
-            if (typeof payload === "string") {
-                payload = encodeUtf8(payload);
-            }
-
-            init = {
-                command: packetOrCommand as AdbCommand,
-                arg0: arg0,
-                arg1: arg1 as number,
-                payload,
-            };
+        if (typeof payload === "string") {
+            payload = encodeUtf8(payload);
         }
 
-        if (
-            init.payload &&
-            init.payload.byteLength > this.options.maxPayloadSize
-        ) {
+        if (payload.byteLength > this.options.maxPayloadSize) {
             throw new Error("payload too large");
         }
 
-        if (this.options.calculateChecksum) {
-            calculateChecksum(init);
-        } else {
-            (init as AdbPacketInit).checksum = 0;
-        }
-
-        await this._writer.ready;
-        await this._writer.write(init as AdbPacketInit);
+        await ConsumableWritableStream.write(this._writer, {
+            command,
+            arg0,
+            arg1,
+            payload,
+            checksum: this.options.calculateChecksum
+                ? calculateChecksum(payload)
+                : 0,
+            magic: command ^ 0xffffffff,
+        });
     }
 
     public async close() {

package/src/socket/index.ts

@@ -1,2 +1,2 @@
-export * from './dispatcher.js';
-export * from './socket.js';
+export * from "./dispatcher.js";
+export * from "./socket.js";