@yume-chan/adb 0.0.11 → 0.0.14

package/src/adb.ts

@@ -1,9 +1,11 @@
+// cspell: ignore libusb
+
 import { PromiseResolver } from '@yume-chan/async';
-import { AdbAuthenticationHandler, AdbDefaultAuthenticators, type AdbCredentialStore } from './auth.js';
+import { AdbAuthenticationProcessor, ADB_DEFAULT_AUTHENTICATORS, type AdbCredentialStore } from './auth.js';
 import { AdbPower, AdbReverseCommand, AdbSubprocess, AdbSync, AdbTcpIpCommand, escapeArg, framebuffer, install, type AdbFrameBuffer } from './commands/index.js';
 import { AdbFeatures } from './features.js';
-import { AdbCommand, AdbPacket, calculateChecksum, type AdbPacketCore, type AdbPacketInit } from './packet.js';
-import { AdbPacketDispatcher, AdbSocket } from './socket/index.js';
+import { AdbCommand, calculateChecksum, type AdbPacketData, type AdbPacketInit } from './packet.js';
+import { AdbIncomingSocketHandler, AdbPacketDispatcher, type AdbSocket, type Closeable } from './socket/index.js';
 import { AbortController, DecodeUtf8Stream, GatherStringStream, WritableStream, type ReadableWritablePair } from "./stream/index.js";
 import { decodeUtf8, encodeUtf8 } from "./utils/index.js";
 
@@ -16,46 +18,30 @@ export enum AdbPropKey {
 
 export const VERSION_OMIT_CHECKSUM = 0x01000001;
 
-export class Adb {
+export class Adb implements Closeable {
     /**
      * It's possible to call `authenticate` multiple times on a single connection,
      * every time the device receives a `CNXN` packet, it resets its internal state,
      * and starts a new authentication process.
      */
     public static async authenticate(
-        connection: ReadableWritablePair<AdbPacketCore, AdbPacketCore>,
+        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
         credentialStore: AdbCredentialStore,
-        authenticators = AdbDefaultAuthenticators,
+        authenticators = ADB_DEFAULT_AUTHENTICATORS,
     ): Promise<Adb> {
+        // Initially, set to highest-supported version and payload size.
         let version = 0x01000001;
         let maxPayloadSize = 0x100000;
 
-        const features = [
-            'shell_v2',
-            'cmd',
-            AdbFeatures.StatV2,
-            'ls_v2',
-            'fixed_push_mkdir',
-            'apex',
-            'abb',
-            'fixed_push_symlink_timestamp',
-            'abb_exec',
-            'remount_shell',
-            'track_app',
-            'sendrecv_v2',
-            'sendrecv_v2_brotli',
-            'sendrecv_v2_lz4',
-            'sendrecv_v2_zstd',
-            'sendrecv_v2_dry_run_send',
-        ].join(',');
-
         const resolver = new PromiseResolver<string>();
-        const authHandler = new AdbAuthenticationHandler(authenticators, credentialStore);
+        const authProcessor = new AdbAuthenticationProcessor(authenticators, credentialStore);
 
+        // Here is similar to `AdbPacketDispatcher`,
+        // But the received packet types and send packet processing are different.
         const abortController = new AbortController();
         const pipe = connection.readable
             .pipeTo(new WritableStream({
-                async write(packet: AdbPacket) {
+                async write(packet) {
                     switch (packet.command) {
                         case AdbCommand.Connect:
                             version = Math.min(version, packet.arg0);
@@ -63,64 +49,92 @@ export class Adb {
                             resolver.resolve(decodeUtf8(packet.payload));
                             break;
                         case AdbCommand.Auth:
-                            const response = await authHandler.handle(packet);
+                            const response = await authProcessor.process(packet);
                             await sendPacket(response);
                             break;
-                        case AdbCommand.Close:
-                            // Last connection was interrupted
-                            // Ignore this packet, device will recover
-                            break;
                         default:
-                            throw new Error('Device not in correct state. Reconnect your device and try again');
+                            // Maybe the previous ADB client exited without reading all packets,
+                            // so they are still waiting in OS internal buffer.
+                            // Just ignore them.
+                            // Because a `Connect` packet will reset the device,
+                            // Eventually there will be `Connect` and `Auth` response packets.
+                            break;
                     }
                 }
             }), {
                 preventCancel: true,
                 signal: abortController.signal,
             })
-            .catch((e) => { resolver.reject(e); });
+            .catch((e) => {
+                resolver.reject(e);
+            });
 
         const writer = connection.writable.getWriter();
-        async function sendPacket(init: AdbPacketCore) {
+        async function sendPacket(init: AdbPacketData) {
             // Always send checksum in auth steps
-            // Because we don't know if the device will ignore it yet.
+            // Because we don't know if the device needs it or not.
             await writer.write(calculateChecksum(init));
         }
 
-        await sendPacket({
-            command: AdbCommand.Connect,
-            arg0: version,
-            arg1: maxPayloadSize,
-            // The terminating `;` is required in formal definition
-            // But ADB daemon (all versions) can still work without it
-            payload: encodeUtf8(`host::features=${features};`),
-        });
-
         try {
+            // https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
+            // There are some other feature constants, but some of them are only used by ADB server, not devices (daemons).
+            const features = [
+                AdbFeatures.ShellV2,
+                AdbFeatures.Cmd,
+                AdbFeatures.StatV2,
+                AdbFeatures.ListV2,
+                AdbFeatures.FixedPushMkdir,
+                'apex',
+                'abb',
+                // only tells the client the symlink timestamp issue in `adb push --sync` has been fixed.
+                // No special handling required.
+                'fixed_push_symlink_timestamp',
+                'abb_exec',
+                'remount_shell',
+                'track_app',
+                'sendrecv_v2',
+                'sendrecv_v2_brotli',
+                'sendrecv_v2_lz4',
+                'sendrecv_v2_zstd',
+                'sendrecv_v2_dry_run_send',
+            ].join(',');
+
+            await sendPacket({
+                command: AdbCommand.Connect,
+                arg0: version,
+                arg1: maxPayloadSize,
+                // The terminating `;` is required in formal definition
+                // But ADB daemon (all versions) can still work without it
+                payload: encodeUtf8(`host::features=${features};`),
+            });
+
             const banner = await resolver.promise;
 
-            // Stop piping before creating Adb object
-            // Because AdbPacketDispatcher will try to lock the streams when initializing
+            // Stop piping before creating `Adb` object
+            // Because `AdbPacketDispatcher` will lock the streams when initializing
             abortController.abort();
-            await pipe;
-
             writer.releaseLock();
 
+            // Wait until pipe stops (`ReadableStream` lock released)
+            await pipe;
+
             return new Adb(
                 connection,
                 version,
                 maxPayloadSize,
                 banner,
             );
-        } finally {
+        } catch (e) {
             abortController.abort();
             writer.releaseLock();
+            throw e;
         }
     }
 
-    private readonly packetDispatcher: AdbPacketDispatcher;
+    private readonly dispatcher: AdbPacketDispatcher;
 
-    public get disconnected() { return this.packetDispatcher.disconnected; }
+    public get disconnected() { return this.dispatcher.disconnected; }
 
     private _protocolVersion: number | undefined;
     public get protocolVersion() { return this._protocolVersion; }
@@ -143,26 +157,37 @@ export class Adb {
     public readonly tcpip: AdbTcpIpCommand;
 
     public constructor(
-        connection: ReadableWritablePair<AdbPacketCore, AdbPacketInit>,
+        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
         version: number,
         maxPayloadSize: number,
         banner: string,
     ) {
         this.parseBanner(banner);
-        this.packetDispatcher = new AdbPacketDispatcher(connection);
 
-        this._protocolVersion = version;
+        let calculateChecksum: boolean;
+        let appendNullToServiceString: boolean;
         if (version >= VERSION_OMIT_CHECKSUM) {
-            this.packetDispatcher.calculateChecksum = false;
-            // Android prior to 9.0.0 uses char* to parse service string
-            // thus requires an extra null character
-            this.packetDispatcher.appendNullToServiceString = false;
+            calculateChecksum = false;
+            appendNullToServiceString = false;
+        } else {
+            calculateChecksum = true;
+            appendNullToServiceString = true;
         }
-        this.packetDispatcher.maxPayloadSize = maxPayloadSize;
+
+        this.dispatcher = new AdbPacketDispatcher(
+            connection,
+            {
+                calculateChecksum,
+                appendNullToServiceString,
+                maxPayloadSize,
+            }
+        );
+
+        this._protocolVersion = version;
 
         this.subprocess = new AdbSubprocess(this);
         this.power = new AdbPower(this);
-        this.reverse = new AdbReverseCommand(this.packetDispatcher);
+        this.reverse = new AdbReverseCommand(this);
         this.tcpip = new AdbTcpIpCommand(this);
     }
 
@@ -201,6 +226,23 @@ export class Adb {
         }
     }
 
+    public addIncomingSocketHandler(handler: AdbIncomingSocketHandler) {
+        return this.dispatcher.addIncomingSocketHandler(handler);
+    }
+
+    public async createSocket(service: string): Promise<AdbSocket> {
+        return this.dispatcher.createSocket(service);
+    }
+
+    public async createSocketAndWait(service: string): Promise<string> {
+        const socket = await this.createSocket(service);
+        const gatherStream = new GatherStringStream();
+        await socket.readable
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeTo(gatherStream);
+        return gatherStream.result;
+    }
+
     public async getProp(key: string): Promise<string> {
         const stdout = await this.subprocess.spawnAndWaitLegacy(
             ['getprop', key]
@@ -228,20 +270,7 @@ export class Adb {
         return framebuffer(this);
     }
 
-    public async createSocket(service: string): Promise<AdbSocket> {
-        return this.packetDispatcher.createSocket(service);
-    }
-
-    public async createSocketAndWait(service: string): Promise<string> {
-        const socket = await this.createSocket(service);
-        const gatherStream = new GatherStringStream();
-        await socket.readable
-            .pipeThrough(new DecodeUtf8Stream())
-            .pipeTo(gatherStream.writable);
-        return gatherStream.result;
-    }
-
-    public async dispose(): Promise<void> {
-        this.packetDispatcher.dispose();
+    public async close(): Promise<void> {
+        await this.dispatcher.close();
     }
 }

package/src/auth.ts

@@ -2,7 +2,7 @@ import { PromiseResolver } from '@yume-chan/async';
 import type { Disposable } from '@yume-chan/event';
 import type { ValueOrPromise } from '@yume-chan/struct';
 import { calculatePublicKey, calculatePublicKeyLength, sign } from './crypto.js';
-import { AdbCommand, AdbPacket, type AdbPacketCore } from './packet.js';
+import { AdbCommand, type AdbPacketData } from './packet.js';
 import { calculateBase64EncodedLength, encodeBase64 } from './utils/index.js';
 
 export type AdbKeyIterable = Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
@@ -43,14 +43,14 @@ export interface AdbAuthenticator {
      */
     (
         credentialStore: AdbCredentialStore,
-        getNextRequest: () => Promise<AdbPacket>
-    ): AsyncIterable<AdbPacketCore>;
+        getNextRequest: () => Promise<AdbPacketData>
+    ): AsyncIterable<AdbPacketData>;
 }
 
 export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacket>,
-): AsyncIterable<AdbPacketCore> {
+    getNextRequest: () => Promise<AdbPacketData>,
+): AsyncIterable<AdbPacketData> {
     for await (const key of credentialStore.iterateKeys()) {
         const packet = await getNextRequest();
 
@@ -70,8 +70,8 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
 
 export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacket>,
-): AsyncIterable<AdbPacketCore> {
+    getNextRequest: () => Promise<AdbPacketData>,
+): AsyncIterable<AdbPacketData> {
     const packet = await getNextRequest();
 
     if (packet.arg0 !== AdbAuthType.Token) {
@@ -110,19 +110,19 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     };
 };
 
-export const AdbDefaultAuthenticators: AdbAuthenticator[] = [
+export const ADB_DEFAULT_AUTHENTICATORS: AdbAuthenticator[] = [
     AdbSignatureAuthenticator,
     AdbPublicKeyAuthenticator,
 ];
 
-export class AdbAuthenticationHandler implements Disposable {
+export class AdbAuthenticationProcessor implements Disposable {
     public readonly authenticators: readonly AdbAuthenticator[];
 
     private readonly credentialStore: AdbCredentialStore;
 
-    private pendingRequest = new PromiseResolver<AdbPacket>();
+    private pendingRequest = new PromiseResolver<AdbPacketData>();
 
-    private iterator: AsyncIterator<AdbPacketCore> | undefined;
+    private iterator: AsyncIterator<AdbPacketData, void, void> | undefined;
 
     public constructor(
         authenticators: readonly AdbAuthenticator[],
@@ -132,16 +132,16 @@ export class AdbAuthenticationHandler implements Disposable {
         this.credentialStore = credentialStore;
     }
 
-    private getNextRequest = (): Promise<AdbPacket> => {
+    private getNextRequest = (): Promise<AdbPacketData> => {
         return this.pendingRequest.promise;
     };
 
-    private async* runAuthenticator(): AsyncGenerator<AdbPacketCore> {
+    private async* invokeAuthenticator(): AsyncGenerator<AdbPacketData, void, void> {
         for (const authenticator of this.authenticators) {
             for await (const packet of authenticator(this.credentialStore, this.getNextRequest)) {
                 // If the authenticator yielded a response
                 // Prepare `nextRequest` for next authentication request
-                this.pendingRequest = new PromiseResolver<AdbPacket>();
+                this.pendingRequest = new PromiseResolver();
 
                 // Yield the response to outer layer
                 yield packet;
@@ -150,17 +150,20 @@ export class AdbAuthenticationHandler implements Disposable {
             // If the authenticator returned,
             // Next authenticator will be given the same `pendingRequest`
         }
-
-        throw new Error('Cannot authenticate with device');
     }
 
-    public async handle(packet: AdbPacket): Promise<AdbPacketCore> {
+    public async process(packet: AdbPacketData): Promise<AdbPacketData> {
         if (!this.iterator) {
-            this.iterator = this.runAuthenticator();
+            this.iterator = this.invokeAuthenticator();
         }
 
         this.pendingRequest.resolve(packet);
+
         const result = await this.iterator.next();
+        if (result.done) {
+            throw new Error('No authenticator can handle the request');
+        }
+
         return result.value;
     }
 

package/src/backend.ts

@@ -1,5 +1,5 @@
 import type { ValueOrPromise } from '@yume-chan/struct';
-import type { AdbPacketCore, AdbPacketInit } from "./packet.js";
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
 import type { ReadableWritablePair } from "./stream/index.js";
 
 export interface AdbBackend {
@@ -7,5 +7,5 @@ export interface AdbBackend {
 
     readonly name: string | undefined;
 
-    connect(): ValueOrPromise<ReadableWritablePair<AdbPacketCore, AdbPacketInit>>;
+    connect(): ValueOrPromise<ReadableWritablePair<AdbPacketData, AdbPacketInit>>;
 }

package/src/commands/install.ts

@@ -8,18 +8,16 @@ export function install(
 ): WritableStream<Uint8Array> {
     const filename = `/data/local/tmp/${Math.random().toString().substring(2)}.apk`;
 
-    return new WrapWritableStream<Uint8Array, WritableStream<Uint8Array>, AdbSync>({
+    let sync!: AdbSync;
+    return new WrapWritableStream<Uint8Array>({
         async start() {
-            // Upload apk file to tmp folder
-            const sync = await adb.sync();
-            const writable = sync.write(filename, undefined, undefined);
+            // TODO: install: support other install apk methods (streaming, etc.)
 
-            return {
-                writable,
-                state: sync,
-            };
+            // Upload apk file to tmp folder
+            sync = await adb.sync();
+            return sync.write(filename, undefined, undefined);
         },
-        async close(sync) {
+        async close() {
             sync.dispose();
 
             // Invoke `pm install` to install it

package/src/commands/reverse.ts

@@ -2,15 +2,11 @@
 
 import { AutoDisposable } from '@yume-chan/event';
 import Struct from '@yume-chan/struct';
-import type { AdbPacketCore } from '../packet.js';
-import type { AdbIncomingSocketEventArgs, AdbPacketDispatcher, AdbSocket } from '../socket/index.js';
+import type { Adb } from "../adb.js";
+import type { AdbIncomingSocketHandler, AdbSocket } from '../socket/index.js';
 import { AdbBufferedStream } from '../stream/index.js';
 import { decodeUtf8 } from "../utils/index.js";
 
-export interface AdbReverseHandler {
-    onSocket(packet: AdbPacketCore, socket: AdbSocket): void;
-}
-
 export interface AdbForwardListener {
     deviceSerial: string;
 
@@ -32,37 +28,30 @@ const AdbReverseErrorResponse =
         });
 
 export class AdbReverseCommand extends AutoDisposable {
-    protected localPortToHandler = new Map<number, AdbReverseHandler>();
+    protected localPortToHandler = new Map<number, AdbIncomingSocketHandler>();
 
     protected deviceAddressToLocalPort = new Map<string, number>();
 
-    protected dispatcher: AdbPacketDispatcher;
+    protected adb: Adb;
 
     protected listening = false;
 
-    public constructor(dispatcher: AdbPacketDispatcher) {
+    public constructor(adb: Adb) {
         super();
 
-        this.dispatcher = dispatcher;
-        this.addDisposable(this.dispatcher.onIncomingSocket(this.handleIncomingSocket, this));
+        this.adb = adb;
+        this.addDisposable(this.adb.addIncomingSocketHandler(this.handleIncomingSocket));
     }
 
-    protected handleIncomingSocket(e: AdbIncomingSocketEventArgs): void {
-        if (e.handled) {
-            return;
-        }
-
-        const address = decodeUtf8(e.packet.payload);
+    protected handleIncomingSocket = async (socket: AdbSocket) => {
+        const address = socket.serviceString;
         // Address format: `tcp:12345\0`
         const port = Number.parseInt(address.substring(4));
-        if (this.localPortToHandler.has(port)) {
-            this.localPortToHandler.get(port)!.onSocket(e.packet, e.socket);
-            e.handled = true;
-        }
-    }
+        return !!(await this.localPortToHandler.get(port)?.(socket));
+    };
 
     private async createBufferedStream(service: string) {
-        const socket = await this.dispatcher.createSocket(service);
+        const socket = await this.adb.createSocket(service);
         return new AdbBufferedStream(socket);
     }
 
@@ -96,7 +85,7 @@ export class AdbReverseCommand extends AutoDisposable {
     public async add(
         deviceAddress: string,
         localPort: number,
-        handler: AdbReverseHandler,
+        handler: AdbIncomingSocketHandler,
     ): Promise<string> {
         const stream = await this.sendRequest(`reverse:forward:${deviceAddress};tcp:${localPort}`);
 

package/src/commands/subprocess/index.ts

@@ -1,34 +1,30 @@
 import type { Adb } from '../../adb.js';
 import { DecodeUtf8Stream, GatherStringStream } from "../../stream/index.js";
-import { AdbNoneSubprocessProtocol } from './legacy.js';
-import { AdbShellSubprocessProtocol } from './protocol.js';
-import type { AdbSubprocessProtocol, AdbSubprocessProtocolConstructor } from './types.js';
+import { AdbSubprocessNoneProtocol, AdbSubprocessShellProtocol, type AdbSubprocessProtocol, type AdbSubprocessProtocolConstructor } from './protocols/index.js';
 
-export * from './legacy.js';
-export * from './protocol.js';
-export * from './types.js';
+export * from './protocols/index.js';
 export * from './utils.js';
 
 export interface AdbSubprocessOptions {
     /**
-     * A list of `AdbShellConstructor`s to be used.
+     * A list of `AdbSubprocessProtocolConstructor`s to be used.
      *
-     * Different `AdbShell` has different capabilities, thus requires specific adaptations.
-     * Check each `AdbShell`'s documentation for details.
+     * Different `AdbSubprocessProtocol` has different capabilities, thus requires specific adaptations.
+     * Check their documentations for details.
      *
-     * The first one whose `isSupported` returns `true` will be used.
-     * If no `AdbShell` is supported, an error will be thrown.
+     * The first protocol whose `isSupported` returns `true` will be used.
+     * If no `AdbSubprocessProtocol` is supported, an error will be thrown.
      *
-     * The default value is `[AdbShellProtocol, AdbLegacyShell]`.
+     * @default [AdbSubprocessShellProtocol, AdbSubprocessNoneProtocol]
      */
     protocols: AdbSubprocessProtocolConstructor[];
 }
 
-const DefaultOptions: AdbSubprocessOptions = {
-    protocols: [AdbShellSubprocessProtocol, AdbNoneSubprocessProtocol],
+const DEFAULT_OPTIONS: AdbSubprocessOptions = {
+    protocols: [AdbSubprocessShellProtocol, AdbSubprocessNoneProtocol],
 };
 
-export interface SubprocessResult {
+export interface AdbSubprocessWaitResult {
     stdout: string;
     stderr: string;
     exitCode: number;
@@ -41,11 +37,16 @@ export class AdbSubprocess {
         this.adb = adb;
     }
 
-    private async createProtocol(command: string, options?: Partial<AdbSubprocessOptions>): Promise<AdbSubprocessProtocol> {
-        let { protocols } = { ...DefaultOptions, ...options };
+    private async createProtocol(
+        mode: 'pty' | 'raw',
+        command?: string | string[],
+        options?: Partial<AdbSubprocessOptions>
+    ): Promise<AdbSubprocessProtocol> {
+        const { protocols } = { ...DEFAULT_OPTIONS, ...options };
 
         let Constructor: AdbSubprocessProtocolConstructor | undefined;
         for (const item of protocols) {
+            // It's async so can't use `Array#find`
             if (await item.isSupported(this.adb)) {
                 Constructor = item;
                 break;
@@ -56,54 +57,65 @@ export class AdbSubprocess {
             throw new Error('No specified protocol is supported by the device');
         }
 
-        return await Constructor.spawn(this.adb, command);
+        if (Array.isArray(command)) {
+            command = command.join(' ');
+        } else if (command === undefined) {
+            // spawn the default shell
+            command = '';
+        }
+        return await Constructor[mode](this.adb, command);
     }
 
     /**
-     * Spawns the default shell in interactive mode.
-     * @param options The options for creating the `AdbShell`
-     * @returns A new `AdbShell` instance connecting to the spawned shell process.
+     * Spawns an executable in PTY (interactive) mode.
+     * @param command The command to run. If omitted, the default shell will be spawned.
+     * @param options The options for creating the `AdbSubprocessProtocol`
+     * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.
      */
-    public shell(options?: Partial<AdbSubprocessOptions>): Promise<AdbSubprocessProtocol> {
-        return this.createProtocol('', options);
+    public shell(
+        command?: string | string[],
+        options?: Partial<AdbSubprocessOptions>
+    ): Promise<AdbSubprocessProtocol> {
+        return this.createProtocol('pty', command, options);
     }
 
     /**
-     * Spawns a new process using the given `command`.
+     * Spawns an executable and pipe the output.
      * @param command The command to run, or an array of strings containing both command and args.
-     * @param options The options for creating the `AdbShell`
-     * @returns A new `AdbShell` instance connecting to the spawned process.
+     * @param options The options for creating the `AdbSubprocessProtocol`
+     * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.
      */
-    public spawn(command: string | string[], options?: Partial<AdbSubprocessOptions>): Promise<AdbSubprocessProtocol> {
-        if (Array.isArray(command)) {
-            command = command.join(' ');
-        }
-        return this.createProtocol(command, options);
+    public spawn(
+        command: string | string[],
+        options?: Partial<AdbSubprocessOptions>
+    ): Promise<AdbSubprocessProtocol> {
+        return this.createProtocol('raw', command, options);
     }
 
     /**
      * Spawns a new process, waits until it exits, and returns the entire output.
      * @param command The command to run
-     * @param options The options for creating the `AdbShell`
+     * @param options The options for creating the `AdbSubprocessProtocol`
      * @returns The entire output of the command
      */
     public async spawnAndWait(
         command: string | string[],
         options?: Partial<AdbSubprocessOptions>
-    ): Promise<SubprocessResult> {
+    ): Promise<AdbSubprocessWaitResult> {
         const shell = await this.spawn(command, options);
 
         const stdout = new GatherStringStream();
-        shell.stdout
-            .pipeThrough(new DecodeUtf8Stream())
-            .pipeThrough(stdout);
-
         const stderr = new GatherStringStream();
-        shell.stderr
-            .pipeThrough(new DecodeUtf8Stream())
-            .pipeThrough(stderr);
 
-        const exitCode = await shell.exit;
+        const [, , exitCode] = await Promise.all([
+            shell.stdout
+                .pipeThrough(new DecodeUtf8Stream())
+                .pipeTo(stdout),
+            shell.stderr
+                .pipeThrough(new DecodeUtf8Stream())
+                .pipeTo(stderr),
+            shell.exit
+        ]);
 
         return {
             stdout: stdout.result,
@@ -118,7 +130,10 @@ export class AdbSubprocess {
      * @returns The entire output of the command
      */
     public async spawnAndWaitLegacy(command: string | string[]): Promise<string> {
-        const { stdout } = await this.spawnAndWait(command, { protocols: [AdbNoneSubprocessProtocol] });
+        const { stdout } = await this.spawnAndWait(
+            command,
+            { protocols: [AdbSubprocessNoneProtocol] }
+        );
         return stdout;
     }
 }