@yume-chan/adb 0.0.10 → 0.0.13

package/src/commands/sync/list.ts

@@ -1,8 +1,12 @@
 import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response';
-import { AdbSyncLstatResponse } from './stat';
+import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
+
+export interface AdbSyncEntry extends AdbSyncStat {
+    name: string;
+}
 
 export const AdbSyncEntryResponse =
     new Struct({ littleEndian: true })
@@ -13,21 +17,64 @@ export const AdbSyncEntryResponse =
 
 export type AdbSyncEntryResponse = typeof AdbSyncEntryResponse['TDeserializeResult'];
 
-const ResponseTypes = {
+export const AdbSyncEntry2Response =
+    new Struct({ littleEndian: true })
+        .fields(AdbSyncStatResponse)
+        .uint32('nameLength')
+        .string('name', { lengthField: 'nameLength' })
+        .extra({ id: AdbSyncResponseId.Entry2 as const });
+
+export type AdbSyncEntry2Response = typeof AdbSyncEntry2Response['TDeserializeResult'];
+
+const LIST_V1_RESPONSE_TYPES = {
     [AdbSyncResponseId.Entry]: AdbSyncEntryResponse,
     [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntryResponse.size),
 };
 
+const LIST_V2_RESPONSE_TYPES = {
+    [AdbSyncResponseId.Entry2]: AdbSyncEntry2Response,
+    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntry2Response.size),
+};
+
 export async function* adbSyncOpenDir(
     stream: AdbBufferedStream,
-    path: string
-): AsyncGenerator<AdbSyncEntryResponse, void, void> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.List, path);
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+    v2: boolean,
+): AsyncGenerator<AdbSyncEntry, void, void> {
+    let requestId: AdbSyncRequestId.List | AdbSyncRequestId.List2;
+    let responseType: typeof LIST_V1_RESPONSE_TYPES | typeof LIST_V2_RESPONSE_TYPES;
+
+    if (v2) {
+        requestId = AdbSyncRequestId.List2;
+        responseType = LIST_V2_RESPONSE_TYPES;
+    } else {
+        requestId = AdbSyncRequestId.List;
+        responseType = LIST_V1_RESPONSE_TYPES;
+    }
+
+    await adbSyncWriteRequest(writer, requestId, path);
 
     while (true) {
-        const response = await adbSyncReadResponse(stream, ResponseTypes);
+        const response = await adbSyncReadResponse(stream, responseType);
         switch (response.id) {
             case AdbSyncResponseId.Entry:
+                yield {
+                    mode: response.mode,
+                    size: BigInt(response.size),
+                    mtime: BigInt(response.mtime),
+                    get type() { return response.type; },
+                    get permission() { return response.permission; },
+                    name: response.name,
+                };
+                break;
+            case AdbSyncResponseId.Entry2:
+                // `LST2` can return error codes for failed `lstat` calls.
+                // `LIST` just ignores them.
+                // But they only contain `name` so still pretty useless.
+                if (response.error !== 0) {
+                    continue;
+                }
                 yield response;
                 break;
             case AdbSyncResponseId.Done:

package/src/commands/sync/pull.ts

@@ -1,12 +1,12 @@
 import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response';
+import { AdbBufferedStream, ReadableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
 
 export const AdbSyncDataResponse =
     new Struct({ littleEndian: true })
         .uint32('dataLength')
-        .arrayBuffer('data', { lengthField: 'dataLength' })
+        .uint8Array('data', { lengthField: 'dataLength' })
         .extra({ id: AdbSyncResponseId.Data as const });
 
 const ResponseTypes = {
@@ -14,21 +14,30 @@ const ResponseTypes = {
     [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
 };
 
-export async function* adbSyncPull(
+export function adbSyncPull(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
-): AsyncGenerator<ArrayBuffer, void, void> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Receive, path);
-    while (true) {
-        const response = await adbSyncReadResponse(stream, ResponseTypes);
-        switch (response.id) {
-            case AdbSyncResponseId.Data:
-                yield response.data!;
-                break;
-            case AdbSyncResponseId.Done:
-                return;
-            default:
-                throw new Error('Unexpected response id');
+): ReadableStream<Uint8Array> {
+    return new ReadableStream<Uint8Array>({
+        async start() {
+            await adbSyncWriteRequest(writer, AdbSyncRequestId.Receive, path);
+        },
+        async pull(controller) {
+            const response = await adbSyncReadResponse(stream, ResponseTypes);
+            switch (response.id) {
+                case AdbSyncResponseId.Data:
+                    controller.enqueue(response.data!);
+                    break;
+                case AdbSyncResponseId.Done:
+                    controller.close();
+                    break;
+                default:
+                    throw new Error('Unexpected response id');
+            }
         }
-    }
+    }, {
+        highWaterMark: 16 * 1024,
+        size(chunk) { return chunk.byteLength; }
+    });
 }

package/src/commands/sync/push.ts

@@ -1,9 +1,8 @@
 import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { chunkArrayLike, chunkAsyncIterable } from '../../utils';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response';
-import { LinuxFileType } from './stat';
+import { AdbBufferedStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import { LinuxFileType } from './stat.js';
 
 export const AdbSyncOkResponse =
     new Struct({ littleEndian: true })
@@ -13,34 +12,30 @@ const ResponseTypes = {
     [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
 };
 
-export const AdbSyncMaxPacketSize = 64 * 1024;
+export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
 
-export async function adbSyncPush(
+export function adbSyncPush(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     filename: string,
-    content: ArrayLike<number> | ArrayBufferLike | AsyncIterable<ArrayBuffer>,
     mode: number = (LinuxFileType.File << 12) | 0o666,
     mtime: number = (Date.now() / 1000) | 0,
-    packetSize: number = AdbSyncMaxPacketSize,
-    onProgress?: (uploaded: number) => void,
-): Promise<void> {
-    const pathAndMode = `${filename},${mode.toString()}`;
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Send, pathAndMode);
-
-    let chunkReader: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>;
-    if ('length' in content || 'byteLength' in content) {
-        chunkReader = chunkArrayLike(content, packetSize);
-    } else {
-        chunkReader = chunkAsyncIterable(content, packetSize);
-    }
-
-    let uploaded = 0;
-    for await (const buffer of chunkReader) {
-        await adbSyncWriteRequest(stream, AdbSyncRequestId.Data, buffer);
-        uploaded += buffer.byteLength;
-        onProgress?.(uploaded);
-    }
-
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Done, mtime);
-    await adbSyncReadResponse(stream, ResponseTypes);
+    packetSize: number = ADB_SYNC_MAX_PACKET_SIZE,
+): WritableStream<Uint8Array> {
+    return pipeFrom(
+        new WritableStream<Uint8Array>({
+            async start() {
+                const pathAndMode = `${filename},${mode.toString()}`;
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Send, pathAndMode);
+            },
+            async write(chunk) {
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Data, chunk);
+            },
+            async close() {
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Done, mtime);
+                await adbSyncReadResponse(stream, ResponseTypes);
+            },
+        }),
+        new ChunkStream(packetSize)
+    );
 }

package/src/commands/sync/request.ts

@@ -1,9 +1,10 @@
 import Struct from '@yume-chan/struct';
-import type { AdbBufferedStream } from '../../stream';
-import { encodeUtf8 } from "../../utils";
+import type { WritableStreamDefaultWriter } from "../../stream/index.js";
+import { encodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncRequestId {
     List = 'LIST',
+    List2 = 'LIS2',
     Send = 'SEND',
     Lstat = 'STAT',
     Stat = 'STA2',
@@ -21,14 +22,14 @@ export const AdbSyncNumberRequest =
 export const AdbSyncDataRequest =
     new Struct({ littleEndian: true })
         .fields(AdbSyncNumberRequest)
-        .arrayBuffer('data', { lengthField: 'arg' });
+        .uint8Array('data', { lengthField: 'arg' });
 
 export async function adbSyncWriteRequest(
-    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     id: AdbSyncRequestId | string,
-    value: number | string | ArrayBuffer
+    value: number | string | Uint8Array
 ): Promise<void> {
-    let buffer: ArrayBuffer;
+    let buffer: Uint8Array;
     if (typeof value === 'number') {
         buffer = AdbSyncNumberRequest.serialize({
             id,
@@ -45,5 +46,5 @@ export async function adbSyncWriteRequest(
             data: value,
         });
     }
-    await stream.write(buffer);
+    await writer.write(buffer);
 }

package/src/commands/sync/response.ts

@@ -1,9 +1,10 @@
-import Struct, { StructAsyncDeserializeStream, StructLike, StructValueType } from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { decodeUtf8 } from "../../utils";
+import Struct, { type StructAsyncDeserializeStream, type StructLike, type StructValueType } from '@yume-chan/struct';
+import type { AdbBufferedStream } from '../../stream/index.js';
+import { decodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncResponseId {
     Entry = 'DENT',
+    Entry2 = 'DNT2',
     Lstat = 'STAT',
     Stat = 'STA2',
     Lstat2 = 'LST2',
@@ -43,7 +44,12 @@ export const AdbSyncFailResponse =
 export async function adbSyncReadResponse<T extends Record<string, StructLike<any>>>(
     stream: AdbBufferedStream,
     types: T,
-): Promise<StructValueType<T[keyof T]>> {
+    // When `T` is a union type, `T[keyof T]` only includes their common keys.
+    // For example, let `type T = { a: string, b: string } | { a: string, c: string}`,
+    // `keyof T` is `'a'`, not `'a' | 'b' | 'c'`.
+    // However, `T extends unknown ? keyof T : never` will distribute `T`,
+    // so returns all keys.
+): Promise<StructValueType<T extends unknown ? T[keyof T] : never>> {
     const id = decodeUtf8(await stream.read(4));
 
     if (id === AdbSyncResponseId.Fail) {
@@ -51,8 +57,8 @@ export async function adbSyncReadResponse<T extends Record<string, StructLike<an
     }
 
     if (types[id]) {
-        return types[id].deserialize(stream);
+        return types[id]!.deserialize(stream);
     }
 
-    throw new Error('Unexpected response id');
+    throw new Error(`Expected '${Object.keys(types).join(', ')}', but got '${id}'`);
 }

package/src/commands/sync/stat.ts

@@ -1,7 +1,7 @@
 import Struct, { placeholder } from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response';
+import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
 
 // https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
 export enum LinuxFileType {
@@ -10,6 +10,19 @@ export enum LinuxFileType {
     Link = 0o12,
 }
 
+export interface AdbSyncStat {
+    mode: number;
+    size: bigint;
+    mtime: bigint;
+    get type(): LinuxFileType;
+    get permission(): number;
+
+    uid?: number;
+    gid?: number;
+    atime?: bigint;
+    ctime?: bigint;
+}
+
 export const AdbSyncLstatResponse =
     new Struct({ littleEndian: true })
         .int32('mode')
@@ -32,6 +45,7 @@ export const AdbSyncLstatResponse =
 export type AdbSyncLstatResponse = typeof AdbSyncLstatResponse['TDeserializeResult'];
 
 export enum AdbSyncStatErrorCode {
+    SUCCESS = 0,
     EACCES = 13,
     EEXIST = 17,
     EFAULT = 14,
@@ -80,42 +94,57 @@ export const AdbSyncStatResponse =
 
 export type AdbSyncStatResponse = typeof AdbSyncStatResponse['TDeserializeResult'];
 
-const StatResponseType = {
+const STAT_RESPONSE_TYPES = {
     [AdbSyncResponseId.Stat]: AdbSyncStatResponse,
 };
 
-const LstatResponseType = {
+const LSTAT_RESPONSE_TYPES = {
     [AdbSyncResponseId.Lstat]: AdbSyncLstatResponse,
 };
 
-const Lstat2ResponseType = {
+const LSTAT_V2_RESPONSE_TYPES = {
     [AdbSyncResponseId.Lstat2]: AdbSyncStatResponse,
 };
 
 export async function adbSyncLstat(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
     v2: boolean,
-): Promise<AdbSyncLstatResponse | AdbSyncStatResponse> {
+): Promise<AdbSyncStat> {
     let requestId: AdbSyncRequestId.Lstat | AdbSyncRequestId.Lstat2;
-    let responseType: typeof LstatResponseType | typeof Lstat2ResponseType;
+    let responseType: typeof LSTAT_RESPONSE_TYPES | typeof LSTAT_V2_RESPONSE_TYPES;
 
     if (v2) {
         requestId = AdbSyncRequestId.Lstat2;
-        responseType = Lstat2ResponseType;
+        responseType = LSTAT_V2_RESPONSE_TYPES;
     } else {
         requestId = AdbSyncRequestId.Lstat;
-        responseType = LstatResponseType;
+        responseType = LSTAT_RESPONSE_TYPES;
     }
 
-    await adbSyncWriteRequest(stream, requestId, path);
-    return adbSyncReadResponse(stream, responseType);
+    await adbSyncWriteRequest(writer, requestId, path);
+    const response = await adbSyncReadResponse(stream, responseType);
+
+    switch (response.id) {
+        case AdbSyncResponseId.Lstat:
+            return {
+                mode: response.mode,
+                size: BigInt(response.size),
+                mtime: BigInt(response.mtime),
+                get type() { return response.type; },
+                get permission() { return response.permission; },
+            };
+        default:
+            return response;
+    }
 }
 
 export async function adbSyncStat(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
 ): Promise<AdbSyncStatResponse> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Stat, path);
-    return adbSyncReadResponse(stream, StatResponseType);
+    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
+    return await adbSyncReadResponse(stream, STAT_RESPONSE_TYPES);
 }

package/src/commands/sync/sync.ts

@@ -1,37 +1,70 @@
 import { AutoDisposable } from '@yume-chan/event';
-import { Adb } from '../../adb';
-import { AdbFeatures } from '../../features';
-import { AdbSocket } from '../../socket';
-import { AdbBufferedStream } from '../../stream';
-import { AutoResetEvent } from '../../utils';
-import { AdbSyncEntryResponse, adbSyncOpenDir } from './list';
-import { adbSyncPull } from './pull';
-import { adbSyncPush } from './push';
-import { adbSyncLstat, adbSyncStat } from './stat';
+import type { Adb } from '../../adb.js';
+import { AdbFeatures } from '../../features.js';
+import type { AdbSocket } from '../../socket/index.js';
+import { AdbBufferedStream, ReadableStream, WrapReadableStream, WrapWritableStream, WritableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AutoResetEvent } from '../../utils/index.js';
+import { escapeArg } from "../index.js";
+import { adbSyncOpenDir, type AdbSyncEntry } from './list.js';
+import { adbSyncPull } from './pull.js';
+import { adbSyncPush } from './push.js';
+import { adbSyncLstat, adbSyncStat } from './stat.js';
+
+/**
+ * A simplified `dirname` function that only handles absolute unix paths.
+ * @param path an absolute unix path
+ * @returns the directory name of the input path
+ */
+export function dirname(path: string): string {
+    const end = path.lastIndexOf('/');
+    if (end === -1) {
+        throw new Error(`Invalid path`);
+    }
+    if (end === 0) {
+        return '/';
+    }
+    return path.substring(0, end);
+}
 
 export class AdbSync extends AutoDisposable {
     protected adb: Adb;
 
     protected stream: AdbBufferedStream;
 
+    protected writer: WritableStreamDefaultWriter<Uint8Array>;
+
     protected sendLock = this.addDisposable(new AutoResetEvent());
 
     public get supportsStat(): boolean {
         return this.adb.features!.includes(AdbFeatures.StatV2);
     }
 
+    public get supportsList2(): boolean {
+        return this.adb.features!.includes(AdbFeatures.ListV2);
+    }
+
+    public get fixedPushMkdir(): boolean {
+        return this.adb.features!.includes(AdbFeatures.FixedPushMkdir);
+    }
+
+    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;
+    }
+
     public constructor(adb: Adb, socket: AdbSocket) {
         super();
 
         this.adb = adb;
         this.stream = new AdbBufferedStream(socket);
+        this.writer = socket.writable.getWriter();
     }
 
     public async lstat(path: string) {
         await this.sendLock.wait();
 
         try {
-            return adbSyncLstat(this.stream, path, this.supportsStat);
+            return adbSyncLstat(this.stream, this.writer, path, this.supportsStat);
         } finally {
             this.sendLock.notify();
         }
@@ -45,7 +78,7 @@ export class AdbSync extends AutoDisposable {
         await this.sendLock.wait();
 
         try {
-            return adbSyncStat(this.stream, path);
+            return adbSyncStat(this.stream, this.writer, path);
         } finally {
             this.sendLock.notify();
         }
@@ -62,52 +95,87 @@ export class AdbSync extends AutoDisposable {
 
     public async *opendir(
         path: string
-    ): AsyncGenerator<AdbSyncEntryResponse, void, void> {
+    ): AsyncGenerator<AdbSyncEntry, void, void> {
         await this.sendLock.wait();
 
         try {
-            yield* adbSyncOpenDir(this.stream, path);
+            yield* adbSyncOpenDir(this.stream, this.writer, path, this.supportsList2);
         } finally {
             this.sendLock.notify();
         }
     }
 
     public async readdir(path: string) {
-        const results: AdbSyncEntryResponse[] = [];
+        const results: AdbSyncEntry[] = [];
         for await (const entry of this.opendir(path)) {
             results.push(entry);
         }
         return results;
     }
 
-    public async *read(filename: string): AsyncGenerator<ArrayBuffer, void, void> {
-        await this.sendLock.wait();
-
-        try {
-            yield* adbSyncPull(this.stream, filename);
-        } finally {
-            this.sendLock.notify();
-        }
+    /**
+     * Read the content of a file on device.
+     *
+     * @param filename The full path of the file on device to read.
+     * @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: async () => {
+                this.sendLock.notify();
+            },
+        });
     }
 
-    public async write(
+    /**
+     * Write (or overwrite) a file on device.
+     *
+     * @param filename The full path of the file on device 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,
-        content: ArrayLike<number> | ArrayBufferLike | AsyncIterable<ArrayBuffer>,
         mode?: number,
         mtime?: number,
-        onProgress?: (uploaded: number) => void,
-    ): Promise<void> {
-        await this.sendLock.wait();
-
-        try {
-            await adbSyncPush(this.stream, filename, content, mode, mtime, undefined, onProgress);
-        } finally {
-            this.sendLock.notify();
-        }
+    ): 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 this
+                    await this.adb.subprocess.spawnAndWait([
+                        'mkdir',
+                        '-p',
+                        escapeArg(dirname(filename)),
+                    ]);
+                }
+
+                return adbSyncPush(
+                    this.stream,
+                    this.writer,
+                    filename,
+                    mode,
+                    mtime,
+                );
+            },
+            close: async () => {
+                this.sendLock.notify();
+            }
+        });
     }
 
-    public override dispose() {
+    public override async dispose() {
         super.dispose();
         this.stream.close();
+        await this.writer.close();
     }
 }

package/src/commands/tcpip.ts

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