@yume-chan/adb 3.0.0-beta.0 → 3.0.0-beta.2

package/src/service/sync/compression/native.ts

@@ -0,0 +1,73 @@
+import {
+    CompressionStream,
+    DecompressionStream,
+    TransformStream,
+} from "@yume-chan/stream-extra";
+
+import { NOOP } from "../../../utils/no-op.js";
+
+import { Format } from "./format.js";
+import { Mode } from "./mode.js";
+
+export const FormatMap: Record<Format, string> = {
+    [Format.None]: "",
+    // https://github.com/whatwg/compression/issues/54
+    [Format.Zstd]: "zstd",
+    // placeholder
+    [Format.Lz4]: "lz4",
+    // https://github.com/whatwg/compression/pull/80
+    [Format.Brotli]: "brotli",
+};
+
+const CompressionFormatCache = new Map<Format, boolean>();
+const DecompressionFormatCache = new Map<Format, boolean>();
+
+export function hasNativeSupport(format: Format, mode: Mode) {
+    if (format === Format.None) {
+        return true;
+    }
+
+    const Cache =
+        mode === Mode.Compress
+            ? CompressionFormatCache
+            : DecompressionFormatCache;
+    if (Cache.has(format)) {
+        return Cache.get(format)!;
+    }
+
+    const Stream =
+        mode === Mode.Compress ? CompressionStream : DecompressionStream;
+    if (!Stream) {
+        return false;
+    }
+
+    try {
+        const stream = new Stream(FormatMap[format]);
+        void stream.writable.abort().catch(NOOP);
+        Cache.set(format, true);
+        return true;
+    } catch {
+        Cache.set(format, false);
+        return false;
+    }
+}
+
+export function createNativeCompressionStream(
+    format: Format,
+): CompressionStream {
+    if (format === Format.None) {
+        return new TransformStream();
+    }
+
+    return new CompressionStream(FormatMap[format]);
+}
+
+export function createNativeDecompressionStream(
+    format: Format,
+): DecompressionStream {
+    if (format === Format.None) {
+        return new TransformStream();
+    }
+
+    return new DecompressionStream(FormatMap[format]);
+}

package/src/service/sync/id/request.ts

@@ -10,3 +10,4 @@ export const ListV2 = encodeId("LIS2");
 export const Send = encodeId("SEND");
 export const SendV2 = encodeId("SND2");
 export const Receive = encodeId("RECV");
+export const ReceiveV2 = encodeId("RCV2");

package/src/service/sync/request/flag.ts

@@ -0,0 +1,9 @@
+export const SyncFlag = {
+    None: 0,
+    Brotli: 1,
+    Lz4: 2,
+    Zstd: 4,
+    DryRun: 0x80000000,
+} as const;
+
+export type SyncFlag = (typeof SyncFlag)[keyof typeof SyncFlag];

package/src/service/sync/request/pull.ts

@@ -1,11 +1,15 @@
-import { ReadableStream } from "@yume-chan/stream-extra";
+import type { TransformStream } from "@yume-chan/stream-extra";
+import { InspectStream, ReadableStream } from "@yume-chan/stream-extra";
 import type { StructValue } from "@yume-chan/struct";
 import { buffer, struct, u32 } from "@yume-chan/struct";
 
 import { RequestId, ResponseId } from "../id/index.js";
+import { Compression } from "../index-ns.js";
 import type { SocketPool } from "../socket-pool.js";
 import { Error as AdbSyncError } from "../socket.js";
 
+import { SyncFlag } from "./flag.js";
+
 export const DataResponse = struct(
     { data: buffer(u32) },
     { littleEndian: true },
@@ -13,37 +17,141 @@ export const DataResponse = struct(
 
 export type DataResponse = StructValue<typeof DataResponse>;
 
-export async function* generator(
+export interface ReceiveSession {
+    /**
+     * The readable stream to read the file content from.
+     */
+    readable: ReadableStream<Uint8Array>;
+    /**
+     * Gets the number of bytes read from {@link readable}.
+     */
+    bytesRead: number;
+    /**
+     * When using Pull v2, gets the compression format used (might be `None`).
+     *
+     * When using Pull v1, this will always be `undefined`.
+     */
+    compression?: Compression.Format | undefined;
+    /**
+     * When using Pull v2, gets the size of the compressed data received from the device.
+     * Might be same as {@link bytesRead} if no compression was applied.
+     */
+    bytesCompressed: number;
+}
+
+export function receiveV1(pool: SocketPool, path: string): ReceiveSession {
+    let bytesReceived = 0;
+    return {
+        readable: ReadableStream.from(
+            pool.withSocketGenerator(async function* (socket) {
+                await socket.writeRequest(RequestId.Receive, path);
+
+                for await (const packet of socket.readResponses(
+                    ResponseId.Data,
+                    DataResponse,
+                )) {
+                    bytesReceived += packet.data.length;
+                    yield packet.data;
+                }
+            }),
+        ),
+        get bytesRead() {
+            return bytesReceived;
+        },
+        compression: undefined,
+        get bytesCompressed() {
+            return bytesReceived;
+        },
+    };
+}
+
+export function receiveV2(
     pool: SocketPool,
     path: string,
-): AsyncGenerator<Uint8Array, void, void> {
-    const socket = await pool.acquire();
-    let completed = false;
-    let error: unknown;
-
-    try {
-        await socket.writeRequest(RequestId.Receive, path);
-        for await (const packet of socket.readResponses(
-            ResponseId.Data,
-            DataResponse,
-        )) {
-            yield packet.data;
-        }
-        completed = true;
-    } catch (e) {
-        error = e;
-        throw e;
-    } finally {
-        await pool.release(
-            socket,
-            !(completed || error instanceof AdbSyncError),
-        );
+    compression?: Compression.Format,
+): ReceiveSession {
+    let flags: SyncFlag = SyncFlag.None;
+    let decompressStream: TransformStream<Uint8Array, Uint8Array> | undefined;
+    switch (compression) {
+        case Compression.Format.Brotli:
+            flags |= SyncFlag.Brotli;
+            decompressStream = Compression.createDecompressionStream(
+                Compression.Format.Brotli,
+            );
+            break;
+        case Compression.Format.Lz4:
+            flags |= SyncFlag.Lz4;
+            decompressStream = Compression.createDecompressionStream(
+                Compression.Format.Lz4,
+            );
+            break;
+        case Compression.Format.Zstd:
+            flags |= SyncFlag.Zstd;
+            decompressStream = Compression.createDecompressionStream(
+                Compression.Format.Zstd,
+            );
+            break;
     }
+
+    let bytesReceived = 0;
+    const raw = ReadableStream.from(
+        pool.withSocketGenerator(async function* (socket) {
+            await socket.writeRequest(RequestId.ReceiveV2, path);
+            await socket.writeRequest(RequestId.ReceiveV2, flags);
+
+            for await (const packet of socket.readResponses(
+                ResponseId.Data,
+                DataResponse,
+            )) {
+                bytesReceived += packet.data.length;
+                yield packet.data;
+            }
+        }),
+    );
+
+    if (decompressStream) {
+        let bytesRead = 0;
+        return {
+            readable: raw.pipeThrough(decompressStream).pipeThrough(
+                new InspectStream((chunk) => {
+                    bytesRead += chunk.length;
+                }),
+            ),
+            get bytesRead() {
+                return bytesRead;
+            },
+            compression,
+            get bytesCompressed() {
+                return bytesReceived;
+            },
+        };
+    }
+
+    return {
+        readable: raw,
+        get bytesRead() {
+            return bytesReceived;
+        },
+        compression: Compression.Format.None,
+        get bytesCompressed() {
+            return bytesReceived;
+        },
+    };
 }
 
-export function stream(
+export function receive(
+    version: 1 | 2,
     pool: SocketPool,
     path: string,
-): ReadableStream<Uint8Array> {
-    return ReadableStream.from(generator(pool, path));
+    compression?: Compression.Format,
+) {
+    if (version === 2) {
+        return receiveV2(pool, path, compression);
+    }
+
+    if (compression !== undefined && compression !== Compression.Format.None) {
+        throw new AdbSyncError("compression is not supported in v1");
+    }
+
+    return receiveV1(pool, path);
 }

package/src/service/sync/request/push.ts

@@ -1,12 +1,13 @@
-import type { ReadableStream } from "@yume-chan/stream-extra";
-import {
-    AbortController,
-    DistributionStream,
-    MaybeConsumable,
+import { PromiseResolver } from "@yume-chan/async";
+import type {
+    TransformStream,
+    WritableStream,
+    WritableStreamDefaultController,
 } from "@yume-chan/stream-extra";
+import { DistributionStream, MaybeConsumable } from "@yume-chan/stream-extra";
 import { struct, u32 } from "@yume-chan/struct";
 
-import { NOOP } from "../../../utils/index.js";
+import { NOOP } from "../../../utils/no-op.js";
 import { LinuxFileType } from "../android.js";
 import { Compression } from "../compression/index.js";
 import { RequestId, ResponseId } from "../id/index.js";
@@ -14,93 +15,166 @@ import type { SocketPool } from "../socket-pool.js";
 import type { Socket } from "../socket.js";
 import { Error as AdbSyncError } from "../socket.js";
 
+import { SyncFlag } from "./flag.js";
+
 export const MaxPacketSize = 64 * 1024;
 
 export const OkResponse = struct({ unused: u32 }, { littleEndian: true });
 
-// eslint-disable-next-line @typescript-eslint/max-params
-async function pipeFileData(
-    socket: Socket,
-    file: ReadableStream<MaybeConsumable<Uint8Array>>,
-    packetSize: number,
-    mtime: number,
-    compression: Compression.Format,
-): Promise<void> {
-    if (compression !== Compression.Format.None) {
-        const stream = Compression.createCompressionStream(compression);
-        void file
-            .pipeTo(new MaybeConsumable.WrapWritableStream(stream.writable))
-            .catch(NOOP);
-        file = stream.readable;
+export interface SendSession {
+    /**
+     * The writable stream to write the file content into.
+     */
+    writable: WritableStream<MaybeConsumable<Uint8Array>>;
+    /**
+     * Gets the number of bytes written into {@link writable}.
+     */
+    bytesWritten: number;
+    /**
+     * When using Send v2, gets the compression format used (might be `None`).
+     *
+     * When using Send v1, this will always be `undefined`.
+     */
+    compression?: Compression.Format | undefined;
+    /**
+     * When using Send v2, gets the size of the compressed data sent to the device.
+     * Might be same as {@link bytesWritten} if no compression was applied.
+     */
+    bytesCompressed: number;
+}
+
+class SendWritableStream extends MaybeConsumable.WritableStream<Uint8Array> {
+    #pool: SocketPool;
+    #socket: Socket;
+
+    #resolver = new PromiseResolver<void>();
+    #controller: WritableStreamDefaultController;
+
+    #bytesWritten = 0;
+    get bytesWritten() {
+        return this.#bytesWritten;
     }
 
-    // Read and write in parallel,
-    // allow error response to abort the write.
-    const abortController = new AbortController();
-    file.pipeThrough(new DistributionStream(packetSize, true))
-        .pipeTo(
-            new MaybeConsumable.WritableStream({
-                write(chunk) {
-                    return socket.writeRequest(RequestId.Data, chunk);
-                },
-            }),
-            { signal: abortController.signal },
-        )
-        .then(async () => {
-            await socket.writeRequest(RequestId.Done, mtime);
-            await socket.flush();
-        }, NOOP);
+    constructor(pool: SocketPool, socket: Socket, mtime: number) {
+        let controller!: WritableStreamDefaultController;
 
-    try {
-        await socket.readResponse(ResponseId.Ok, OkResponse);
-    } catch (e) {
-        abortController.abort(e);
-        throw e;
+        super({
+            start: (controller_) => {
+                controller = controller_;
+
+                // Start reading response immediately,
+                // the server can send error response before the whole file is sent.
+                socket.readResponse(ResponseId.Ok, OkResponse).then(
+                    () => this.#finish(),
+                    (e) => this.#finish(e),
+                );
+            },
+            write: async (chunk) => {
+                try {
+                    this.#bytesWritten += chunk.length;
+                    await socket.writeRequest(RequestId.Data, chunk);
+                } catch (e) {
+                    await this.#finish(e);
+                }
+            },
+            close: async () => {
+                try {
+                    await socket.writeRequest(RequestId.Done, mtime);
+                    await socket.flush();
+                } catch (e) {
+                    await this.#finish(e);
+                    return;
+                }
+                await this.#resolver.promise;
+            },
+            abort: async (reason) => {
+                // Write anything other than `Data` or `Done`
+                // will cause the server to delete the file.
+                await socket.writeRequest(ResponseId.Fail, 0);
+
+                // Socket not reusable after aborting, so discard it.
+                await this.#finish(reason);
+            },
+        });
+
+        this.#pool = pool;
+        this.#socket = socket;
+
+        this.#controller = controller;
+        // Suppress unhandled rejection warning when the promise is not awaited.
+        this.#resolver.promise.catch(NOOP);
+    }
+
+    #trySetError(reason: unknown) {
+        try {
+            this.#controller.error(reason);
+        } catch {
+            // Ignore if controller is already closed or errored
+        }
+    }
+
+    async #finish(error?: unknown) {
+        try {
+            await this.#pool.release(
+                this.#socket,
+                !(error instanceof AdbSyncError),
+            );
+            if (error) {
+                this.#trySetError(error);
+                this.#resolver.reject(error);
+            } else {
+                this.#resolver.resolve();
+            }
+        } catch (e) {
+            // TOOD: use `SuppressedError` when universally supported
+            this.#trySetError(e);
+            this.#resolver.reject(e);
+        }
     }
 }
 
 export interface SendV1Options {
     pool: SocketPool;
-    filename: string;
-    file: ReadableStream<MaybeConsumable<Uint8Array>>;
+    path: string;
     type?: LinuxFileType | undefined;
     permission?: number | undefined;
     mtime?: number | undefined;
     packetSize?: number | undefined;
 }
 
-export function sendV1({
+export async function sendV1({
     pool,
-    filename,
-    file,
+    path,
     type = LinuxFileType.File,
     permission = 0o666,
     mtime = (Date.now() / 1000) | 0,
     packetSize = MaxPacketSize,
-}: SendV1Options) {
-    return pool.withSocket(async (socket) => {
-        const mode = (type << 12) | permission;
-        const pathAndMode = `${filename},${mode.toString()}`;
-        await socket.writeRequest(RequestId.Send, pathAndMode);
-        await pipeFileData(
-            socket,
-            file,
-            packetSize,
-            mtime,
-            Compression.Format.None,
-        );
-    });
-}
+}: SendV1Options): Promise<SendSession> {
+    const mode = (type << 12) | permission;
+    const request = path + "," + mode;
+
+    const socket = await pool.acquire();
+    try {
+        await socket.writeRequest(RequestId.Send, request);
+    } catch (e) {
+        await pool.release(socket, !(e instanceof AdbSyncError));
+        throw e;
+    }
 
-export const SendV2Flags = {
-    None: 0,
-    Brotli: 1,
-    Lz4: 2,
-    Zstd: 4,
-    DryRun: 0x80000000,
-} as const;
+    const distributeStream = new DistributionStream(packetSize, true);
+    const sendStream = new SendWritableStream(pool, socket, mtime);
+    void distributeStream.readable.pipeTo(sendStream).catch(NOOP);
 
-export type SendV2Flags = (typeof SendV2Flags)[keyof typeof SendV2Flags];
+    return {
+        writable: distributeStream.writable,
+        get bytesWritten() {
+            return sendStream.bytesWritten;
+        },
+        get bytesCompressed() {
+            return sendStream.bytesWritten;
+        },
+    };
+}
 
 export const SendV2Request = struct(
     { id: u32, mode: u32, flags: u32 },
@@ -108,6 +182,16 @@ export const SendV2Request = struct(
 );
 
 export interface SendV2Options extends SendV1Options {
+    /**
+     * The format to compress the file stream for sending.
+     *
+     * If the device or current runtime doesn't support the specified format,
+     * an Error will be thrown.
+     *
+     * If `undefined` is specified, no compression will be used.
+     * (this behavior is different from `AdbSync.Service.prototype.write`,
+     * which will automatically choose the best format)
+     */
     compression?: Compression.Format | undefined;
 
     /**
@@ -119,35 +203,47 @@ export interface SendV2Options extends SendV1Options {
     dryRun?: boolean | undefined;
 }
 
-export function sendV2({
+export async function sendV2({
     pool,
-    filename,
-    file,
+    path,
     type = LinuxFileType.File,
     permission = 0o666,
     mtime = (Date.now() / 1000) | 0,
     packetSize = MaxPacketSize,
     compression = Compression.Format.None,
     dryRun = false,
-}: SendV2Options) {
-    return pool.withSocket(async (socket) => {
-        let flags: SendV2Flags = SendV2Flags.None;
-        switch (compression) {
-            case Compression.Format.Brotli:
-                flags |= SendV2Flags.Brotli;
-                break;
-            case Compression.Format.Lz4:
-                flags |= SendV2Flags.Lz4;
-                break;
-            case Compression.Format.Zstd:
-                flags |= SendV2Flags.Zstd;
-                break;
-        }
-        if (dryRun) {
-            flags |= SendV2Flags.DryRun;
-        }
+}: SendV2Options): Promise<SendSession> {
+    let flags: SyncFlag = SyncFlag.None;
+    let compressStream: TransformStream<Uint8Array, Uint8Array> | undefined;
+
+    // Validate `compression` before acquiring the socket
+    switch (compression) {
+        case Compression.Format.Brotli:
+            flags |= SyncFlag.Brotli;
+            compressStream = Compression.createCompressionStream(
+                Compression.Format.Brotli,
+            );
+            break;
+        case Compression.Format.Lz4:
+            flags |= SyncFlag.Lz4;
+            compressStream = Compression.createCompressionStream(
+                Compression.Format.Lz4,
+            );
+            break;
+        case Compression.Format.Zstd:
+            flags |= SyncFlag.Zstd;
+            compressStream = Compression.createCompressionStream(
+                Compression.Format.Zstd,
+            );
+            break;
+    }
+    if (dryRun) {
+        flags |= SyncFlag.DryRun;
+    }
 
-        await socket.writeRequest(RequestId.SendV2, filename);
+    const socket = await pool.acquire();
+    try {
+        await socket.writeRequest(RequestId.SendV2, path);
         await socket.write(
             SendV2Request.serialize({
                 id: RequestId.SendV2,
@@ -155,9 +251,63 @@ export function sendV2({
                 flags,
             }),
         );
+    } catch (e) {
+        await pool.release(socket, !(e instanceof AdbSyncError));
+        throw e;
+    }
+
+    const distributeStream = new DistributionStream(packetSize, true);
+    const sendStream = new SendWritableStream(pool, socket, mtime);
+
+    if (!compressStream) {
+        const pipe = distributeStream.readable.pipeTo(sendStream);
+
+        const writer = distributeStream.writable.getWriter();
+        return {
+            writable: new MaybeConsumable.WritableStream({
+                write(chunk) {
+                    return writer.write(chunk);
+                },
+                async close() {
+                    await writer.close();
+                    await pipe;
+                },
+            }),
+            get bytesWritten() {
+                return sendStream.bytesWritten;
+            },
+            compression: Compression.Format.None,
+            get bytesCompressed() {
+                return sendStream.bytesWritten;
+            },
+        };
+    }
+
+    const pipe = compressStream.readable
+        .pipeThrough(distributeStream)
+        .pipeTo(sendStream);
 
-        await pipeFileData(socket, file, packetSize, mtime, compression);
-    });
+    const writer = compressStream.writable.getWriter();
+    let bytesWritten = 0;
+    return {
+        writable: new MaybeConsumable.WritableStream({
+            write(chunk) {
+                bytesWritten += chunk.length;
+                return writer.write(chunk);
+            },
+            async close() {
+                await writer.close();
+                await pipe;
+            },
+        }),
+        get bytesWritten() {
+            return bytesWritten;
+        },
+        compression,
+        get bytesCompressed() {
+            return sendStream.bytesWritten;
+        },
+    };
 }
 
 export interface SendOptions extends SendV2Options {