@yume-chan/adb 0.0.10 → 0.0.11

package/CHANGELOG.json

@@ -1,6 +1,32 @@
 {
   "name": "@yume-chan/adb",
   "entries": [
+    {
+      "version": "0.0.11",
+      "tag": "@yume-chan/adb_v0.0.11",
+      "date": "Sun, 03 Apr 2022 10:54:15 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Add power related API"
+          },
+          {
+            "comment": "Update compatibility matrix"
+          },
+          {
+            "comment": "Update license year"
+          }
+        ],
+        "patch": [
+          {
+            "comment": "Update to use Web Streams API"
+          },
+          {
+            "comment": "Improve compatibility with Node.js 12 ESM format"
+          }
+        ]
+      }
+    },
     {
       "version": "0.0.10",
       "tag": "@yume-chan/adb_v0.0.10",

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Change Log - @yume-chan/adb
 
-This log was last generated on Sun, 09 Jan 2022 15:52:20 GMT and should not be manually modified.
+This log was last generated on Sun, 03 Apr 2022 10:54:15 GMT and should not be manually modified.
+
+## 0.0.11
+Sun, 03 Apr 2022 10:54:15 GMT
+
+### Patches
+
+- Update to use Web Streams API
+- Improve compatibility with Node.js 12 ESM format
+
+### Updates
+
+- Add power related API
+- Update compatibility matrix
+- Update license year
 
 ## 0.0.10
 Sun, 09 Jan 2022 15:52:20 GMT

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Simon Chan
+Copyright (c) 2020-2022 Simon Chan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -5,17 +5,18 @@ TypeScript implementation of Android Debug Bridge (ADB) protocol.
 **WARNING:** The public API is UNSTABLE. If you have any questions, please open an issue.
 
 - [Compatibility](#compatibility)
+  - [Basic usage](#basic-usage)
+  - [Use without bundlers](#use-without-bundlers)
 - [Connection](#connection)
   - [Backend](#backend)
     - [`connect`](#connect)
-    - [`read`](#read)
-    - [`write`](#write)
 - [Authentication](#authentication)
     - [AdbCredentialStore](#adbcredentialstore)
       - [`generateKey`](#generatekey)
       - [`iterateKeys`](#iteratekeys)
       - [Implementations](#implementations)
     - [AdbAuthenticator](#adbauthenticator)
+    - [`authenticate`](#authenticate)
 - [Stream multiplex](#stream-multiplex)
   - [Backend](#backend-1)
 - [Commands](#commands)
@@ -36,50 +37,49 @@ TypeScript implementation of Android Debug Bridge (ADB) protocol.
 
 ## Compatibility
 
-The main limiting factor of compatibility is [@yume-chan/struct](https://www.npmjs.com/package/@yume-chan/struct).
+Here is a list of features, their used APIs, and their compatibilities. If an optional feature is not actually used, its requirements can be ignored.
 
-This library doesn't use any DOM or Node.js API.
+Some features can be polyfilled to support older runtimes, but this library doesn't ship with any polyfills.
 
-|                 | Chrome | Edge | Firefox | Internet Explorer | Safari         | Node.js |
-| --------------- | ------ | ---- | ------- | ----------------- | -------------- | ------- |
-| **Basic usage** | 68     | 79   | 68      | No                | 14<sup>1</sup> | 10.4    |
+Each backend may have different requirements.
 
-<sup>1</sup> Requires a polyfill for [`DataView#getBigUint64`][MDN_DataView_getBigUint64] and [`DataView#setBigUint64`][MDN_DataView_setBigUint64]
+### Basic usage
 
-[MDN_DataView_getBigUint64]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getBigUint64
-[MDN_DataView_setBigUint64]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setBigUint64
+|                                 | Chrome | Edge | Firefox | Internet Explorer | Safari | Node.js             |
+| ------------------------------- | ------ | ---- | ------- | ----------------- | ------ | ------------------- |
+| `@yume-chan/struct`<sup>1</sup> | 67     | 79   | 68      | No                | 14     | 8.3<sup>2</sup>, 11 |
+| [Streams][MDN_Streams]          | 67     | 79   | No      | No                | 14.1   | 16.5                |
+| *Overall*                       | 67     | 79   | No      | No                | 14.1   | 16.5                |
 
-## Connection
-
-This library doesn't tie to a specific transportation method.
+<sup>1</sup> `uint64` and `string` used.
 
-Instead, a `Backend` is responsible for transferring data in its own way (USB, WebSocket, etc).
+<sup>2</sup> `TextEncoder` and `TextDecoder` are only available in `util` module. Need to be assigned to `globalThis`.
 
-### Backend
-
-#### `connect`
+### Use without bundlers
 
-Establishes a connection with the device.
+|                 | Chrome | Edge | Firefox | Internet Explorer | Safari | Node.js |
+| --------------- | ------ | ---- | ------- | ----------------- | ------ | ------- |
+| Top-level await | 89     | 89   | 89      | No                | 15     | 14.8    |
 
-If a backend doesn't have extra steps to establish the connection, it can omit the `connect` method implementation.
+[MDN_Streams]: https://developer.mozilla.org/en-US/docs/Web/API/Streams_API
 
-#### `read`
+## Connection
 
-```ts
-read(length: number): ArrayBuffer | Promise<ArrayBuffer>
-```
+This library doesn't tie to a specific transportation method.
 
-Reads the specified amount of data from the underlying connection.
+Instead, a `Backend` is responsible for transferring data in its own way (USB, WebSocket, TCP, etc).
 
-The returned `ArrayBuffer` may have more or less data than the `length` parameter specified, if there is some residual data in the connection buffer. The client will automatically call `read` again with the same `length`.
+### Backend
 
-#### `write`
+#### `connect`
 
 ```ts
-write(buffer: ArrayBuffer): void | Promise<void>
+connect(): ValueOrPromise<ReadableWritablePair<AdbPacketCore, AdbPacketInit>>
 ```
 
-Writes data to the underlying connection.
+Connect to a device and create a pair of `AdbPacket` streams.
+
+The backend is responsible for serializing and deserializing the packets, because it's extreme slow for WebUSB backend (`@yume-chan/adb-backend-webusb`) to read packets with unknown size.
 
 ## Authentication
 
@@ -87,22 +87,19 @@ For how does ADB authentication work, see https://chensi.moe/blog/2020/09/30/web
 
 In this library, authentication comes in two parts:
 
-* `AdbCredentialStore`: because JavaScript has no unified method to generate, store and iterate crypto keys, an implementation of `AdbCredentialStore` is required for the two built-in authenticators.
-* `AdbAuthenticator`: can be used to implement custom authentication modes.
-
-Custom `AdbCredentialStore`s and `AdbAuthenticator`s can be specified in the `Adb#connect` method.
-
 #### AdbCredentialStore
 
+An interface to generate, store and iterate ADB private keys on each runtime. (Because Node.js and Browsers have different APIs to do this)
+
 ##### `generateKey`
 
 ```ts
-generateKey(): ArrayBuffer | Promise<ArrayBuffer>
+generateKey(): ValueOrPromise<Uint8Array>
 ```
 
 Generate and store a RSA private key with modulus length `2048` and public exponent `65537`.
 
-The returned `ArrayBuffer` is the private key in PKCS #8 format.
+The returned `Uint8Array` is the private key in PKCS #8 format.
 
 ##### `iterateKeys`
 
@@ -116,7 +113,7 @@ Each call to `iterateKeys` must return a different iterator that iterate through
 
 ##### Implementations
 
-The `@yume-chan/adb-backend-webusb` package contains a `AdbWebCredentialStore` implementation using Web Crypto API to generating keys and Web Storage API to storing keys.
+The `@yume-chan/adb-credential-web` package contains a `AdbWebCredentialStore` implementation using Web Crypto API for generating keys and Web Storage API for storing keys.
 
 #### AdbAuthenticator
 
@@ -124,6 +121,20 @@ An `AdbAuthenticator` generates `AUTH` responses for each `AUTH` request from se
 
 This package contains `AdbSignatureAuthenticator` and `AdbPublicKeyAuthenticator`, the two basic modes.
 
+#### `authenticate`
+
+```ts
+static async authenticate(
+    connection: ReadableWritablePair<AdbPacketCore, AdbPacketCore>,
+    credentialStore: AdbCredentialStore,
+    authenticators = AdbDefaultAuthenticators,
+): Promise<Adb>
+```
+
+Call this method to authenticate the connection and create an `Adb` instance.
+
+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.
+
 ## Stream multiplex
 
 ADB commands are all based on streams. Multiple streams can send and receive at the same time in one connection.
@@ -143,16 +154,18 @@ The `Backend` is responsible for reading and writing data from underlying source
 
 Spawns child process on server. ADB has two shell modes:
 
-|                             | Legacy mode      | Shell Protocol     |
-| --------------------------- | ---------------- | ------------------ |
-| Feature flag                | -                | `shell_v2`         |
-| Implementation              | `AdbLegacyShell` | `AdbShellProtocol` |
-| Splitting stdout and stderr | No               | Yes                |
-| Returning exit code         | No               | Yes                |
-| Resizing window             | No               | Yes                |
+|                             | Legacy mode                 | Shell Protocol               |
+| --------------------------- | --------------------------- | ---------------------------- |
+| Feature flag                | -                           | `shell_v2`                   |
+| Implementation              | `AdbNoneSubprocessProtocol` | `AdbShellSubprocessProtocol` |
+| Splitting stdout and stderr | No                          | Yes                          |
+| Returning exit code         | No                          | Yes                          |
+| Resizing window             | No                          | Yes                          |
 
 The `Adb#childProcess#shell` and `Adb#childProcess#spawn` methods accepts a list of implementations, and will use the first supported one.
 
+For simple command invocation, usually the `AdbNoneSubprocessProtocol` is enough.
+
 ### usb
 
 Disable ADB over WiFi.

package/esm/adb.d.ts

@@ -0,0 +1,48 @@
+import { type AdbCredentialStore } from './auth.js';
+import { AdbPower, AdbReverseCommand, AdbSubprocess, AdbSync, AdbTcpIpCommand, type AdbFrameBuffer } from './commands/index.js';
+import { AdbFeatures } from './features.js';
+import { type AdbPacketCore, type AdbPacketInit } from './packet.js';
+import { AdbSocket } from './socket/index.js';
+import { WritableStream, type ReadableWritablePair } from "./stream/index.js";
+export declare enum AdbPropKey {
+    Product = "ro.product.name",
+    Model = "ro.product.model",
+    Device = "ro.product.device",
+    Features = "features"
+}
+export declare const VERSION_OMIT_CHECKSUM = 16777217;
+export declare class Adb {
+    /**
+     * 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.
+     */
+    static authenticate(connection: ReadableWritablePair<AdbPacketCore, AdbPacketCore>, credentialStore: AdbCredentialStore, authenticators?: import("./auth.js").AdbAuthenticator[]): Promise<Adb>;
+    private readonly packetDispatcher;
+    get disconnected(): Promise<void>;
+    private _protocolVersion;
+    get protocolVersion(): number | undefined;
+    private _product;
+    get product(): string | undefined;
+    private _model;
+    get model(): string | undefined;
+    private _device;
+    get device(): string | undefined;
+    private _features;
+    get features(): AdbFeatures[] | undefined;
+    readonly subprocess: AdbSubprocess;
+    readonly power: AdbPower;
+    readonly reverse: AdbReverseCommand;
+    readonly tcpip: AdbTcpIpCommand;
+    constructor(connection: ReadableWritablePair<AdbPacketCore, AdbPacketInit>, version: number, maxPayloadSize: number, banner: string);
+    private parseBanner;
+    getProp(key: string): Promise<string>;
+    rm(...filenames: string[]): Promise<string>;
+    install(): WritableStream<Uint8Array>;
+    sync(): Promise<AdbSync>;
+    framebuffer(): Promise<AdbFrameBuffer>;
+    createSocket(service: string): Promise<AdbSocket>;
+    createSocketAndWait(service: string): Promise<string>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=adb.d.ts.map

package/esm/adb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adb.d.ts","sourceRoot":"","sources":["../src/adb.ts"],"names":[],"mappings":"AACA,OAAO,EAAsD,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACxG,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,EAAmC,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACjK,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAA4C,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/G,OAAO,EAAuB,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAyD,cAAc,EAAE,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGrI,oBAAY,UAAU;IAClB,OAAO,oBAAoB;IAC3B,KAAK,qBAAqB;IAC1B,MAAM,sBAAsB;IAC5B,QAAQ,aAAa;CACxB;AAED,eAAO,MAAM,qBAAqB,WAAa,CAAC;AAEhD,qBAAa,GAAG;IACZ;;;;OAIG;WACiB,YAAY,CAC5B,UAAU,EAAE,oBAAoB,CAAC,aAAa,EAAE,aAAa,CAAC,EAC9D,eAAe,EAAE,kBAAkB,EACnC,cAAc,yCAA2B,GAC1C,OAAO,CAAC,GAAG,CAAC;IA4Ff,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IAEvD,IAAW,YAAY,kBAAiD;IAExE,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,IAAW,eAAe,uBAAoC;IAE9D,OAAO,CAAC,QAAQ,CAAqB;IACrC,IAAW,OAAO,uBAA4B;IAE9C,OAAO,CAAC,MAAM,CAAqB;IACnC,IAAW,KAAK,uBAA0B;IAE1C,OAAO,CAAC,OAAO,CAAqB;IACpC,IAAW,MAAM,uBAA2B;IAE5C,OAAO,CAAC,SAAS,CAA4B;IAC7C,IAAW,QAAQ,8BAA6B;IAEhD,SAAgB,UAAU,EAAE,aAAa,CAAC;IAC1C,SAAgB,KAAK,EAAE,QAAQ,CAAC;IAChC,SAAgB,OAAO,EAAE,iBAAiB,CAAC;IAC3C,SAAgB,KAAK,EAAE,eAAe,CAAC;gBAGnC,UAAU,EAAE,oBAAoB,CAAC,aAAa,EAAE,aAAa,CAAC,EAC9D,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM;IAoBlB,OAAO,CAAC,WAAW;IAmCN,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOrC,EAAE,CAAC,GAAG,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAOjD,OAAO;IAID,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAKxB,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC;IAItC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAIjD,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASrD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAGxC"}

package/esm/adb.js

@@ -1,121 +1,134 @@
-import { __awaiter } from "tslib";
 import { PromiseResolver } from '@yume-chan/async';
-import { DisposableList } from '@yume-chan/event';
-import { AdbAuthenticationHandler, AdbDefaultAuthenticators } from './auth';
-import { AdbChildProcess, AdbDemoMode, AdbReverseCommand, AdbSync, AdbTcpIpCommand, escapeArg, framebuffer, install } from './commands';
-import { AdbFeatures } from './features';
-import { AdbCommand } from './packet';
-import { AdbPacketDispatcher } from './socket';
-import { decodeUtf8 } from "./utils";
+import { AdbAuthenticationHandler, AdbDefaultAuthenticators } from './auth.js';
+import { AdbPower, AdbReverseCommand, AdbSubprocess, AdbSync, AdbTcpIpCommand, escapeArg, framebuffer, install } from './commands/index.js';
+import { AdbFeatures } from './features.js';
+import { AdbCommand, calculateChecksum } from './packet.js';
+import { AdbPacketDispatcher } from './socket/index.js';
+import { AbortController, DecodeUtf8Stream, GatherStringStream, WritableStream } from "./stream/index.js";
+import { decodeUtf8, encodeUtf8 } from "./utils/index.js";
 export var AdbPropKey;
 (function (AdbPropKey) {
     AdbPropKey["Product"] = "ro.product.name";
     AdbPropKey["Model"] = "ro.product.model";
     AdbPropKey["Device"] = "ro.product.device";
     AdbPropKey["Features"] = "features";
-})(AdbPropKey || (AdbPropKey = {}));
+})(AdbPropKey = AdbPropKey || (AdbPropKey = {}));
+export const VERSION_OMIT_CHECKSUM = 0x01000001;
 export class Adb {
-    constructor(backend, logger) {
-        this._connected = false;
-        this._backend = backend;
-        this.packetDispatcher = new AdbPacketDispatcher(backend, logger);
-        this.tcpip = new AdbTcpIpCommand(this);
-        this.reverse = new AdbReverseCommand(this.packetDispatcher);
-        this.demoMode = new AdbDemoMode(this);
-        this.childProcess = new AdbChildProcess(this);
-        backend.onDisconnected(this.dispose, this);
+    /**
+     * 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.
+     */
+    static async authenticate(connection, credentialStore, authenticators = AdbDefaultAuthenticators) {
+        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();
+        const authHandler = new AdbAuthenticationHandler(authenticators, credentialStore);
+        const abortController = new AbortController();
+        const pipe = connection.readable
+            .pipeTo(new WritableStream({
+            async write(packet) {
+                switch (packet.command) {
+                    case AdbCommand.Connect:
+                        version = Math.min(version, packet.arg0);
+                        maxPayloadSize = Math.min(maxPayloadSize, packet.arg1);
+                        resolver.resolve(decodeUtf8(packet.payload));
+                        break;
+                    case AdbCommand.Auth:
+                        const response = await authHandler.handle(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');
+                }
+            }
+        }), {
+            preventCancel: true,
+            signal: abortController.signal,
+        })
+            .catch((e) => { resolver.reject(e); });
+        const writer = connection.writable.getWriter();
+        async function sendPacket(init) {
+            // Always send checksum in auth steps
+            // Because we don't know if the device will ignore it yet.
+            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 {
+            const banner = await resolver.promise;
+            // Stop piping before creating Adb object
+            // Because AdbPacketDispatcher will try to lock the streams when initializing
+            abortController.abort();
+            await pipe;
+            writer.releaseLock();
+            return new Adb(connection, version, maxPayloadSize, banner);
+        }
+        finally {
+            abortController.abort();
+            writer.releaseLock();
+        }
     }
-    get backend() { return this._backend; }
-    get onDisconnected() { return this.backend.onDisconnected; }
-    get connected() { return this._connected; }
-    get name() { return this.backend.name; }
+    packetDispatcher;
+    get disconnected() { return this.packetDispatcher.disconnected; }
+    _protocolVersion;
     get protocolVersion() { return this._protocolVersion; }
+    _product;
     get product() { return this._product; }
+    _model;
     get model() { return this._model; }
+    _device;
     get device() { return this._device; }
+    _features;
     get features() { return this._features; }
-    connect(credentialStore, authenticators = AdbDefaultAuthenticators) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            yield ((_b = (_a = this.backend).connect) === null || _b === void 0 ? void 0 : _b.call(_a));
-            this.packetDispatcher.maxPayloadSize = 0x1000;
-            this.packetDispatcher.calculateChecksum = true;
-            this.packetDispatcher.appendNullToServiceString = true;
-            this.packetDispatcher.start();
-            const version = 0x01000001;
-            const versionNoChecksum = 0x01000001;
-            const 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();
-            const authHandler = new AdbAuthenticationHandler(authenticators, credentialStore);
-            const disposableList = new DisposableList();
-            disposableList.add(this.packetDispatcher.onPacket((e) => __awaiter(this, void 0, void 0, function* () {
-                e.handled = true;
-                const { packet } = e;
-                try {
-                    switch (packet.command) {
-                        case AdbCommand.Connect:
-                            this.packetDispatcher.maxPayloadSize = Math.min(maxPayloadSize, packet.arg1);
-                            const finalVersion = Math.min(version, packet.arg0);
-                            this._protocolVersion = finalVersion;
-                            if (finalVersion >= versionNoChecksum) {
-                                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;
-                            }
-                            this.parseBanner(decodeUtf8(packet.payload));
-                            resolver.resolve();
-                            break;
-                        case AdbCommand.Auth:
-                            const authPacket = yield authHandler.handle(e.packet);
-                            yield this.packetDispatcher.sendPacket(authPacket);
-                            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');
-                    }
-                }
-                catch (e) {
-                    resolver.reject(e);
-                }
-            })));
-            disposableList.add(this.packetDispatcher.onError(e => {
-                resolver.reject(e);
-            }));
-            // Android prior 9.0.0 requires the null character
-            // Newer versions can also handle the null character
-            // The terminating `;` is required in formal definition
-            // But ADB daemon can also work without it
-            yield this.packetDispatcher.sendPacket(AdbCommand.Connect, version, maxPayloadSize, `host::features=${features};\0`);
-            try {
-                yield resolver.promise;
-                this._connected = true;
-            }
-            finally {
-                disposableList.dispose();
-            }
-        });
+    subprocess;
+    power;
+    reverse;
+    tcpip;
+    constructor(connection, version, maxPayloadSize, banner) {
+        this.parseBanner(banner);
+        this.packetDispatcher = new AdbPacketDispatcher(connection);
+        this._protocolVersion = version;
+        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;
+        }
+        this.packetDispatcher.maxPayloadSize = maxPayloadSize;
+        this.subprocess = new AdbSubprocess(this);
+        this.power = new AdbPower(this);
+        this.reverse = new AdbReverseCommand(this.packetDispatcher);
+        this.tcpip = new AdbTcpIpCommand(this);
     }
     parseBanner(banner) {
         this._features = [];
@@ -148,55 +161,37 @@ export class Adb {
             }
         }
     }
-    getProp(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const output = yield this.childProcess.exec('getprop', key);
-            return output.trim();
-        });
+    async getProp(key) {
+        const stdout = await this.subprocess.spawnAndWaitLegacy(['getprop', key]);
+        return stdout.trim();
     }
-    rm(...filenames) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.childProcess.exec('rm', '-rf', ...filenames.map(arg => escapeArg(arg)));
-        });
+    async rm(...filenames) {
+        const stdout = await this.subprocess.spawnAndWaitLegacy(['rm', '-rf', ...filenames.map(arg => escapeArg(arg))]);
+        return stdout;
     }
-    install(apk, onProgress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield install(this, apk, onProgress);
-        });
+    install() {
+        return install(this);
     }
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const socket = yield this.createSocket('sync:');
-            return new AdbSync(this, socket);
-        });
+    async sync() {
+        const socket = await this.createSocket('sync:');
+        return new AdbSync(this, socket);
     }
-    framebuffer() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return framebuffer(this);
-        });
+    async framebuffer() {
+        return framebuffer(this);
     }
-    createSocket(service) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.packetDispatcher.createSocket(service);
-        });
+    async createSocket(service) {
+        return this.packetDispatcher.createSocket(service);
     }
-    createSocketAndReadAll(service) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const socket = yield this.createSocket(service);
-            const resolver = new PromiseResolver();
-            let result = '';
-            socket.onData(buffer => {
-                result += decodeUtf8(buffer);
-            });
-            socket.onClose(() => resolver.resolve(result));
-            return resolver.promise;
-        });
+    async createSocketAndWait(service) {
+        const socket = await this.createSocket(service);
+        const gatherStream = new GatherStringStream();
+        await socket.readable
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeTo(gatherStream.writable);
+        return gatherStream.result;
     }
-    dispose() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.packetDispatcher.dispose();
-            yield this.backend.dispose();
-        });
+    async dispose() {
+        this.packetDispatcher.dispose();
     }
 }
 //# sourceMappingURL=adb.js.map