@yume-chan/adb 0.0.20 → 0.0.21

package/src/daemon/dispatcher.ts

@@ -28,6 +28,10 @@ export interface AdbPacketDispatcherOptions {
      */
     appendNullToServiceString: boolean;
     maxPayloadSize: number;
+    /**
+     * Whether to preserve the connection open after the `AdbPacketDispatcher` is closed.
+     */
+    preserveConnection?: boolean | undefined;
 }
 
 /**
@@ -51,23 +55,23 @@ export class AdbPacketDispatcher implements Closeable {
 
     #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
-    public readonly options: AdbPacketDispatcherOptions;
+    readonly options: AdbPacketDispatcherOptions;
 
     #closed = false;
     #disconnected = new PromiseResolver<void>();
-    public get disconnected() {
+    get disconnected() {
         return this.#disconnected.promise;
     }
 
     #incomingSocketHandlers = new Map<string, AdbIncomingSocketHandler>();
     #readAbortController = new AbortController();
 
-    public constructor(
+    constructor(
         connection: ReadableWritablePair<
             AdbPacketData,
             Consumable<AdbPacketInit>
         >,
-        options: AdbPacketDispatcherOptions
+        options: AdbPacketDispatcherOptions,
     ) {
         this.options = options;
 
@@ -77,10 +81,10 @@ export class AdbPacketDispatcher implements Closeable {
                     write: async (packet) => {
                         switch (packet.command) {
                             case AdbCommand.OK:
-                                this.handleOk(packet);
+                                this.#handleOk(packet);
                                 break;
                             case AdbCommand.Close:
-                                await this.handleClose(packet);
+                                await this.#handleClose(packet);
                                 break;
                             case AdbCommand.Write:
                                 if (this.#sockets.has(packet.arg1)) {
@@ -90,15 +94,15 @@ export class AdbPacketDispatcher implements Closeable {
                                     await this.sendPacket(
                                         AdbCommand.OK,
                                         packet.arg1,
-                                        packet.arg0
+                                        packet.arg0,
                                     );
                                     break;
                                 }
                                 throw new Error(
-                                    `Unknown local socket id: ${packet.arg1}`
+                                    `Unknown local socket id: ${packet.arg1}`,
                                 );
                             case AdbCommand.Open:
-                                await this.handleOpen(packet);
+                                await this.#handleOpen(packet);
                                 break;
                             default:
                                 // Junk data may only appear in the authentication phase,
@@ -107,38 +111,33 @@ export class AdbPacketDispatcher implements Closeable {
                                 // (although it's possible that Adb added new commands in the future)
                                 throw new Error(
                                     `Unknown command: ${packet.command.toString(
-                                        16
-                                    )}`
+                                        16,
+                                    )}`,
                                 );
                         }
                     },
                 }),
                 {
-                    // There are multiple reasons for the pipe to stop,
-                    // (device disconnection, protocol error, or user abortion)
-                    // if the underlying streams are still open,
-                    // it's still possible to create another ADB connection.
-                    // So don't close `readable` here.
-                    preventCancel: true,
+                    preventCancel: options.preserveConnection ?? false,
                     signal: this.#readAbortController.signal,
-                }
+                },
             )
             .then(
                 () => {
-                    this.dispose();
+                    this.#dispose();
                 },
                 (e) => {
                     if (!this.#closed) {
                         this.#disconnected.reject(e);
                     }
-                    this.dispose();
-                }
+                    this.#dispose();
+                },
             );
 
         this.#writer = connection.writable.getWriter();
     }
 
-    private handleOk(packet: AdbPacketData) {
+    #handleOk(packet: AdbPacketData) {
         if (this.#initializers.resolve(packet.arg1, packet.arg0)) {
             // Device successfully created the socket
             return;
@@ -156,13 +155,13 @@ export class AdbPacketDispatcher implements Closeable {
         void this.sendPacket(AdbCommand.Close, packet.arg1, packet.arg0);
     }
 
-    private async handleClose(packet: AdbPacketData) {
+    async #handleClose(packet: AdbPacketData) {
         // If the socket is still pending
         if (
             packet.arg0 === 0 &&
             this.#initializers.reject(
                 packet.arg1,
-                new Error("Socket open failed")
+                new Error("Socket open failed"),
             )
         ) {
             // Device failed to create the socket
@@ -188,7 +187,7 @@ export class AdbPacketDispatcher implements Closeable {
                 await this.sendPacket(
                     AdbCommand.Close,
                     packet.arg1,
-                    packet.arg0
+                    packet.arg0,
                 );
             }
             await socket.dispose();
@@ -201,22 +200,19 @@ export class AdbPacketDispatcher implements Closeable {
         // the device may also respond with two `CLSE` packets.
     }
 
-    public addReverseTunnel(
-        service: string,
-        handler: AdbIncomingSocketHandler
-    ) {
+    addReverseTunnel(service: string, handler: AdbIncomingSocketHandler) {
         this.#incomingSocketHandlers.set(service, handler);
     }
 
-    public removeReverseTunnel(address: string) {
+    removeReverseTunnel(address: string) {
         this.#incomingSocketHandlers.delete(address);
     }
 
-    public clearReverseTunnels() {
+    clearReverseTunnels() {
         this.#incomingSocketHandlers.clear();
     }
 
-    private async handleOpen(packet: AdbPacketData) {
+    async #handleOpen(packet: AdbPacketData) {
         // `AsyncOperationManager` doesn't support skipping IDs
         // Use `add` + `resolve` to simulate this behavior
         const [localId] = this.#initializers.add<number>();
@@ -251,7 +247,7 @@ export class AdbPacketDispatcher implements Closeable {
         }
     }
 
-    public async createSocket(service: string): Promise<AdbSocket> {
+    async createSocket(service: string): Promise<AdbSocket> {
         if (this.options.appendNullToServiceString) {
             service += "\0";
         }
@@ -273,11 +269,11 @@ export class AdbPacketDispatcher implements Closeable {
         return controller.socket;
     }
 
-    public async sendPacket(
+    async sendPacket(
         command: AdbCommand,
         arg0: number,
         arg1: number,
-        payload: string | Uint8Array = EMPTY_UINT8_ARRAY
+        payload: string | Uint8Array = EMPTY_UINT8_ARRAY,
     ): Promise<void> {
         if (typeof payload === "string") {
             payload = encodeUtf8(payload);
@@ -299,23 +295,28 @@ export class AdbPacketDispatcher implements Closeable {
         });
     }
 
-    public async close() {
+    async close() {
         // Send `CLSE` packets for all sockets
         await Promise.all(
-            Array.from(this.#sockets.values(), (socket) => socket.close())
+            Array.from(this.#sockets.values(), (socket) => socket.close()),
         );
 
         // Stop receiving
         // It's possible that we haven't received all `CLSE` confirm packets,
         // but it doesn't matter, the next connection can cope with them.
         this.#closed = true;
+
         this.#readAbortController.abort();
-        this.#writer.releaseLock();
+        if (this.options.preserveConnection ?? false) {
+            this.#writer.releaseLock();
+        } else {
+            await this.#writer.close();
+        }
 
         // `pipe().then()` will call `dispose`
     }
 
-    private dispose() {
+    #dispose() {
         for (const socket of this.#sockets.values()) {
             socket.dispose().catch(unreachable);
         }

package/src/daemon/packet.ts

@@ -53,7 +53,7 @@ export class AdbPacketSerializeStream extends ConsumableTransformStream<
     AdbPacketInit,
     Uint8Array
 > {
-    public constructor() {
+    constructor() {
         const headerBuffer = new Uint8Array(AdbPacketHeader.size);
         super({
             transform: async (chunk, controller) => {

package/src/daemon/socket.ts

@@ -42,23 +42,23 @@ export class AdbDaemonSocketController
         Closeable,
         Disposable
 {
-    private readonly dispatcher!: AdbPacketDispatcher;
+    readonly #dispatcher!: AdbPacketDispatcher;
 
-    public readonly localId!: number;
-    public readonly remoteId!: number;
-    public readonly localCreated!: boolean;
-    public readonly service!: string;
+    readonly localId!: number;
+    readonly remoteId!: number;
+    readonly localCreated!: boolean;
+    readonly service!: string;
 
     #duplex: DuplexStreamFactory<Uint8Array, Consumable<Uint8Array>>;
 
     #readable: ReadableStream<Uint8Array>;
     #readableController!: PushReadableStreamController<Uint8Array>;
-    public get readable() {
+    get readable() {
         return this.#readable;
     }
 
     #writePromise: PromiseResolver<void> | undefined;
-    public readonly writable: WritableStream<Consumable<Uint8Array>>;
+    readonly writable: WritableStream<Consumable<Uint8Array>>;
 
     #closed = false;
     /**
@@ -66,17 +66,21 @@ export class AdbDaemonSocketController
      *
      * It's only used by dispatcher to avoid sending another `CLSE` packet to remote.
      */
-    public get closed() {
+    get closed() {
         return this.#closed;
     }
 
-    private _socket: AdbDaemonSocket;
-    public get socket() {
-        return this._socket;
+    #socket: AdbDaemonSocket;
+    get socket() {
+        return this.#socket;
     }
 
-    public constructor(options: AdbDaemonSocketConstructionOptions) {
-        Object.assign(this, options);
+    constructor(options: AdbDaemonSocketConstructionOptions) {
+        this.#dispatcher = options.dispatcher;
+        this.localId = options.localId;
+        this.remoteId = options.remoteId;
+        this.localCreated = options.localCreated;
+        this.service = options.service;
 
         // Check this image to help you understand the stream graph
         // cspell: disable-next-line
@@ -89,7 +93,7 @@ export class AdbDaemonSocketController
             close: async () => {
                 this.#closed = true;
 
-                await this.dispatcher.sendPacket(
+                await this.#dispatcher.sendPacket(
                     AdbCommand.Close,
                     this.localId,
                     this.remoteId
@@ -124,7 +128,7 @@ export class AdbDaemonSocketController
                     write: async (chunk) => {
                         // Wait for an ack packet
                         this.#writePromise = new PromiseResolver();
-                        await this.dispatcher.sendPacket(
+                        await this.#dispatcher.sendPacket(
                             AdbCommand.Write,
                             this.localId,
                             this.remoteId,
@@ -134,13 +138,13 @@ export class AdbDaemonSocketController
                     },
                 })
             ),
-            new DistributionStream(this.dispatcher.options.maxPayloadSize)
+            new DistributionStream(this.#dispatcher.options.maxPayloadSize)
         );
 
-        this._socket = new AdbDaemonSocket(this);
+        this.#socket = new AdbDaemonSocket(this);
     }
 
-    public async enqueue(data: Uint8Array) {
+    async enqueue(data: Uint8Array) {
         // Consumer may abort the `ReadableStream` to close the socket,
         // it's OK to throw away further packets in this case.
         if (this.#readableController.abortSignal.aborted) {
@@ -150,15 +154,15 @@ export class AdbDaemonSocketController
         await this.#readableController.enqueue(data);
     }
 
-    public ack() {
+    ack() {
         this.#writePromise?.resolve();
     }
 
-    public async close(): Promise<void> {
+    async close(): Promise<void> {
         await this.#duplex.close();
     }
 
-    public dispose() {
+    dispose() {
         return this.#duplex.dispose();
     }
 }
@@ -178,35 +182,35 @@ export class AdbDaemonSocket
 {
     #controller: AdbDaemonSocketController;
 
-    public get localId(): number {
+    get localId(): number {
         return this.#controller.localId;
     }
-    public get remoteId(): number {
+    get remoteId(): number {
         return this.#controller.remoteId;
     }
-    public get localCreated(): boolean {
+    get localCreated(): boolean {
         return this.#controller.localCreated;
     }
-    public get service(): string {
+    get service(): string {
         return this.#controller.service;
     }
 
-    public get readable(): ReadableStream<Uint8Array> {
+    get readable(): ReadableStream<Uint8Array> {
         return this.#controller.readable;
     }
-    public get writable(): WritableStream<Consumable<Uint8Array>> {
+    get writable(): WritableStream<Consumable<Uint8Array>> {
         return this.#controller.writable;
     }
 
-    public get closed(): boolean {
+    get closed(): boolean {
         return this.#controller.closed;
     }
 
-    public constructor(controller: AdbDaemonSocketController) {
+    constructor(controller: AdbDaemonSocketController) {
         this.#controller = controller;
     }
 
-    public close() {
+    close() {
         return this.#controller.close();
     }
 }

package/src/daemon/transport.ts

@@ -32,6 +32,10 @@ interface AdbDaemonAuthenticationOptions {
     connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>;
     credentialStore: AdbCredentialStore;
     authenticators?: AdbAuthenticator[];
+    /**
+     * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
+     */
+    preserveConnection?: boolean | undefined;
 }
 
 interface AdbDaemonSocketConnectorConstructionOptions {
@@ -40,6 +44,10 @@ interface AdbDaemonSocketConnectorConstructionOptions {
     version: number;
     maxPayloadSize: number;
     banner: string;
+    /**
+     * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
+     */
+    preserveConnection?: boolean | undefined;
 }
 
 export class AdbDaemonTransport implements AdbTransport {
@@ -51,11 +59,12 @@ export class AdbDaemonTransport implements AdbTransport {
      * on the same connection. Because every time the device receives a `CNXN` packet,
      * it resets all internal state, and starts a new authentication process.
      */
-    public static async authenticate({
+    static async authenticate({
         serial,
         connection,
         credentialStore,
         authenticators = ADB_DEFAULT_AUTHENTICATORS,
+        preserveConnection,
     }: AdbDaemonAuthenticationOptions): Promise<AdbDaemonTransport> {
         // Initially, set to highest-supported version and payload size.
         let version = 0x01000001;
@@ -65,7 +74,7 @@ export class AdbDaemonTransport implements AdbTransport {
         const resolver = new PromiseResolver<string>();
         const authProcessor = new AdbAuthenticationProcessor(
             authenticators,
-            credentialStore
+            credentialStore,
         );
 
         // Here is similar to `AdbPacketDispatcher`,
@@ -80,13 +89,13 @@ export class AdbDaemonTransport implements AdbTransport {
                                 version = Math.min(version, packet.arg0);
                                 maxPayloadSize = Math.min(
                                     maxPayloadSize,
-                                    packet.arg1
+                                    packet.arg1,
                                 );
                                 resolver.resolve(decodeUtf8(packet.payload));
                                 break;
                             case AdbCommand.Auth: {
                                 const response = await authProcessor.process(
-                                    packet
+                                    packet,
                                 );
                                 await sendPacket(response);
                                 break;
@@ -105,19 +114,19 @@ export class AdbDaemonTransport implements AdbTransport {
                     // Don't cancel the source ReadableStream on AbortSignal abort.
                     preventCancel: true,
                     signal: abortController.signal,
-                }
+                },
             )
             .then(
                 () => {
                     if (resolver.state === "running") {
                         resolver.reject(
-                            new Error("Connection closed unexpectedly")
+                            new Error("Connection closed unexpectedly"),
                         );
                     }
                 },
                 (e) => {
                     resolver.reject(e);
-                }
+                },
             );
 
         const writer = connection.writable.getWriter();
@@ -147,7 +156,7 @@ export class AdbDaemonTransport implements AdbTransport {
                 AdbFeature.AbbExec,
                 "remount_shell",
                 "track_app",
-                "sendrecv_v2",
+                AdbFeature.SendReceiveV2,
                 "sendrecv_v2_brotli",
                 "sendrecv_v2_lz4",
                 "sendrecv_v2_zstd",
@@ -180,41 +189,43 @@ export class AdbDaemonTransport implements AdbTransport {
             version,
             maxPayloadSize,
             banner,
+            preserveConnection,
         });
     }
 
     readonly #dispatcher: AdbPacketDispatcher;
 
     #serial: string;
-    public get serial() {
+    get serial() {
         return this.#serial;
     }
 
     #protocolVersion: number;
-    public get protocolVersion() {
+    get protocolVersion() {
         return this.#protocolVersion;
     }
 
     #maxPayloadSize: number;
-    public get maxPayloadSize() {
+    get maxPayloadSize() {
         return this.#maxPayloadSize;
     }
 
     #banner: AdbBanner;
-    public get banner() {
+    get banner() {
         return this.#banner;
     }
 
-    public get disconnected() {
+    get disconnected() {
         return this.#dispatcher.disconnected;
     }
 
-    public constructor({
+    constructor({
         serial,
         connection,
         version,
         maxPayloadSize,
         banner,
+        preserveConnection,
     }: AdbDaemonSocketConnectorConstructionOptions) {
         this.#serial = serial;
         this.#banner = AdbBanner.parse(banner);
@@ -233,19 +244,20 @@ export class AdbDaemonTransport implements AdbTransport {
             calculateChecksum,
             appendNullToServiceString,
             maxPayloadSize,
+            preserveConnection,
         });
 
         this.#protocolVersion = version;
         this.#maxPayloadSize = maxPayloadSize;
     }
 
-    public connect(service: string): ValueOrPromise<AdbSocket> {
+    connect(service: string): ValueOrPromise<AdbSocket> {
         return this.#dispatcher.createSocket(service);
     }
 
-    public addReverseTunnel(
+    addReverseTunnel(
         handler: AdbIncomingSocketHandler,
-        address?: string
+        address?: string,
     ): string {
         if (!address) {
             const id = Math.random().toString().substring(2);
@@ -255,15 +267,15 @@ export class AdbDaemonTransport implements AdbTransport {
         return address;
     }
 
-    public removeReverseTunnel(address: string): void {
+    removeReverseTunnel(address: string): void {
         this.#dispatcher.removeReverseTunnel(address);
     }
 
-    public clearReverseTunnels(): void {
+    clearReverseTunnels(): void {
         this.#dispatcher.clearReverseTunnels();
     }
 
-    public close(): ValueOrPromise<void> {
+    close(): ValueOrPromise<void> {
         return this.#dispatcher.close();
     }
 }