refactor: use ES private fields to replace TypeScript private accessors (d286a40c) · Commits · e / tools / webadb

libraries/adb/src/banner.ts

+12 −12

Original line number	Diff line number	Diff line
		@@ -48,24 +48,24 @@ export class AdbBanner {
		return new AdbBanner(product, model, device, features);
		}

		private _product: string \| undefined;
		#product: string \| undefined;
		public get product() {
		return this._product;
		return this.#product;
		}

		private _model: string \| undefined;
		#model: string \| undefined;
		public get model() {
		return this._model;
		return this.#model;
		}

		private _device: string \| undefined;
		#device: string \| undefined;
		public get device() {
		return this._device;
		return this.#device;
		}

		private _features: AdbFeature[] = [];
		#features: AdbFeature[] = [];
		public get features() {
		return this._features;
		return this.#features;
		}

		public constructor(
		@@ -74,9 +74,9 @@ export class AdbBanner {
		device: string \| undefined,
		features: AdbFeature[]
		) {
		this._product = product;
		this._model = model;
		this._device = device;
		this._features = features;
		this.#product = product;
		this.#model = model;
		this.#device = device;
		this.#features = features;
		}
		}

libraries/adb/src/commands/reverse.ts

+15 −16

Original line number	Diff line number	Diff line
		@@ -5,7 +5,7 @@ import { BufferedReadableStream } from "@yume-chan/stream-extra";
		import Struct, { ExactReadableEndedError } from "@yume-chan/struct";

		import type { Adb, AdbIncomingSocketHandler } from "../adb.js";
		import { decodeUtf8 } from "../utils/index.js";
		import { decodeUtf8, hexToNumber } from "../utils/index.js";

		export interface AdbForwardListener {
		deviceSerial: string;
		@@ -47,10 +47,15 @@ const AdbReverseErrorResponse = new Struct()
		}
		});

		async function readString(stream: BufferedReadableStream, length: number) {
		const buffer = await stream.readExactly(length);
		return decodeUtf8(buffer);
		}

		export class AdbReverseCommand extends AutoDisposable {
		protected adb: Adb;

		private readonly _deviceAddressToLocalAddress = new Map<string, string>();
		readonly #deviceAddressToLocalAddress = new Map<string, string>();

		public constructor(adb: Adb) {
		super();
		@@ -58,19 +63,14 @@ export class AdbReverseCommand extends AutoDisposable {
		this.adb = adb;
		}

		private async createBufferedStream(service: string) {
		protected async createBufferedStream(service: string) {
		const socket = await this.adb.createSocket(service);
		return new BufferedReadableStream(socket.readable);
		}

		private async readString(stream: BufferedReadableStream, length: number) {
		const buffer = await stream.readExactly(length);
		return decodeUtf8(buffer);
		}

		private async sendRequest(service: string) {
		protected async sendRequest(service: string) {
		const stream = await this.createBufferedStream(service);
		const success = (await this.readString(stream, 4)) === "OKAY";
		const success = (await readString(stream, 4)) === "OKAY";
		if (!success) {
		await AdbReverseErrorResponse.deserialize(stream);
		}
		@@ -109,9 +109,8 @@ export class AdbReverseCommand extends AutoDisposable {
		if (deviceAddress.startsWith("tcp:")) {
		const position = stream.position;
		try {
		const lengthString = await this.readString(stream, 4);
		const length = Number.parseInt(lengthString, 16);
		const port = await this.readString(stream, length);
		const length = hexToNumber(await stream.readExactly(4));
		const port = await readString(stream, length);
		deviceAddress = `tcp:${Number.parseInt(port, 10)}`;
		} catch (e) {
		if (
		@@ -150,7 +149,7 @@ export class AdbReverseCommand extends AutoDisposable {

		try {
		deviceAddress = await this.addExternal(deviceAddress, localAddress);
		this._deviceAddressToLocalAddress.set(deviceAddress, localAddress);
		this.#deviceAddressToLocalAddress.set(deviceAddress, localAddress);
		return deviceAddress;
		} catch (e) {
		await this.adb.transport.removeReverseTunnel(localAddress);
		@@ -160,7 +159,7 @@ export class AdbReverseCommand extends AutoDisposable {

		public async remove(deviceAddress: string): Promise<void> {
		const localAddress =
		this._deviceAddressToLocalAddress.get(deviceAddress);
		this.#deviceAddressToLocalAddress.get(deviceAddress);
		if (localAddress) {
		await this.adb.transport.removeReverseTunnel(localAddress);
		}
		@@ -172,7 +171,7 @@ export class AdbReverseCommand extends AutoDisposable {

		public async removeAll(): Promise<void> {
		await this.adb.transport.clearReverseTunnels();
		this._deviceAddressToLocalAddress.clear();
		this.#deviceAddressToLocalAddress.clear();

		await this.sendRequest(`reverse:killforward-all`);

libraries/adb/src/commands/subprocess/protocols/none.ts

+16 −16

Original line number	Diff line number	Diff line
		@@ -31,50 +31,50 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
		);
		}

		private readonly _socket: AdbSocket;
		readonly #socket: AdbSocket;

		private readonly _duplex: DuplexStreamFactory<Uint8Array, Uint8Array>;
		readonly #duplex: DuplexStreamFactory<Uint8Array, Uint8Array>;

		// Legacy shell forwards all data to stdin.
		public get stdin() {
		return this._socket.writable;
		return this.#socket.writable;
		}

		private _stdout: ReadableStream<Uint8Array>;
		#stdout: ReadableStream<Uint8Array>;
		/**
		* Legacy shell mixes stdout and stderr.
		*/
		public get stdout() {
		return this._stdout;
		return this.#stdout;
		}

		private _stderr: ReadableStream<Uint8Array>;
		#stderr: ReadableStream<Uint8Array>;
		/**
		* `stderr` will always be empty.
		*/
		public get stderr() {
		return this._stderr;
		return this.#stderr;
		}

		private _exit: Promise<number>;
		#exit: Promise<number>;
		public get exit() {
		return this._exit;
		return this.#exit;
		}

		public constructor(socket: AdbSocket) {
		this._socket = socket;
		this.#socket = socket;

		// Link `stdout`, `stderr` and `stdin` together,
		// so closing any of them will close the others.
		this._duplex = new DuplexStreamFactory<Uint8Array, Uint8Array>({
		this.#duplex = new DuplexStreamFactory<Uint8Array, Uint8Array>({
		close: async () => {
		await this._socket.close();
		await this.#socket.close();
		},
		});

		this._stdout = this._duplex.wrapReadable(this._socket.readable);
		this._stderr = this._duplex.wrapReadable(new ReadableStream());
		this._exit = this._duplex.closed.then(() => 0);
		this.#stdout = this.#duplex.wrapReadable(this.#socket.readable);
		this.#stderr = this.#duplex.wrapReadable(new ReadableStream());
		this.#exit = this.#duplex.closed.then(() => 0);
		}

		public resize() {
		@@ -82,6 +82,6 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
		}

		public kill() {
		return this._duplex.close();
		return this.#duplex.close();
		}
		}

libraries/adb/src/commands/subprocess/protocols/shell.ts

+20 −20

Original line number	Diff line number	Diff line
		@@ -125,33 +125,33 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
		);
		}

		private readonly _socket: AdbSocket;
		private _socketWriter: WritableStreamDefaultWriter<
		readonly #socket: AdbSocket;
		#socketWriter: WritableStreamDefaultWriter<
		Consumable<AdbShellProtocolPacketInit>
		>;

		private _stdin: WritableStream<Consumable<Uint8Array>>;
		#stdin: WritableStream<Consumable<Uint8Array>>;
		public get stdin() {
		return this._stdin;
		return this.#stdin;
		}

		private _stdout: ReadableStream<Uint8Array>;
		#stdout: ReadableStream<Uint8Array>;
		public get stdout() {
		return this._stdout;
		return this.#stdout;
		}

		private _stderr: ReadableStream<Uint8Array>;
		#stderr: ReadableStream<Uint8Array>;
		public get stderr() {
		return this._stderr;
		return this.#stderr;
		}

		private readonly _exit = new PromiseResolver<number>();
		readonly #exit = new PromiseResolver<number>();
		public get exit() {
		return this._exit.promise;
		return this.#exit.promise;
		}

		public constructor(socket: AdbSocket) {
		this._socket = socket;
		this.#socket = socket;

		// Check this image to help you understand the stream graph
		// cspell: disable-next-line
		@@ -159,10 +159,10 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {

		let stdoutController!: PushReadableStreamController<Uint8Array>;
		let stderrController!: PushReadableStreamController<Uint8Array>;
		this._stdout = new PushReadableStream<Uint8Array>((controller) => {
		this.#stdout = new PushReadableStream<Uint8Array>((controller) => {
		stdoutController = controller;
		});
		this._stderr = new PushReadableStream<Uint8Array>((controller) => {
		this.#stderr = new PushReadableStream<Uint8Array>((controller) => {
		stderrController = controller;
		});

		@@ -173,7 +173,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
		write: async (chunk) => {
		switch (chunk.id) {
		case AdbShellProtocolId.Exit:
		this._exit.resolve(chunk.data[0]!);
		this.#exit.resolve(chunk.data[0]!);
		break;
		case AdbShellProtocolId.Stdout:
		await stdoutController.enqueue(chunk.data);
		@@ -189,8 +189,8 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
		() => {
		stdoutController.close();
		stderrController.close();
		if (this._exit.state !== "resolved") {
		this._exit.reject(
		if (this.#exit.state !== "resolved") {
		this.#exit.reject(
		new Error("Socket ended without exit message")
		);
		}
		@@ -216,16 +216,16 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
		)
		.pipeTo(socket.writable);

		this._stdin = pipeFrom(
		this.#stdin = pipeFrom(
		multiplexer.createWriteable(),
		new StdinSerializeStream()
		);

		this._socketWriter = multiplexer.createWriteable().getWriter();
		this.#socketWriter = multiplexer.createWriteable().getWriter();
		}

		public async resize(rows: number, cols: number) {
		await ConsumableWritableStream.write(this._socketWriter, {
		await ConsumableWritableStream.write(this.#socketWriter, {
		id: AdbShellProtocolId.WindowSizeChange,
		data: encodeUtf8(
		// The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`
		@@ -237,6 +237,6 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
		}

		public kill() {
		return this._socket.close();
		return this.#socket.close();
		}
		}

libraries/adb/src/commands/sync/socket.ts

+29 −31

Original line number	Diff line number	Diff line
		@@ -13,16 +13,14 @@ import type { AdbSocket } from "../../adb.js";
		import { AutoResetEvent } from "../../utils/index.js";

		export class AdbSyncSocketLocked implements AsyncExactReadable {
		private readonly _writer: WritableStreamDefaultWriter<
		Consumable<Uint8Array>
		>;
		private readonly _readable: BufferedReadableStream;
		private readonly _socketLock: AutoResetEvent;
		private readonly _writeLock = new AutoResetEvent();
		private readonly _combiner: BufferCombiner;
		readonly #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
		readonly #readable: BufferedReadableStream;
		readonly #socketLock: AutoResetEvent;
		readonly #writeLock = new AutoResetEvent();
		readonly #combiner: BufferCombiner;

		public get position() {
		return this._readable.position;
		return this.#readable.position;
		}

		public constructor(
		@@ -31,71 +29,71 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
		bufferSize: number,
		lock: AutoResetEvent
		) {
		this._writer = writer;
		this._readable = readable;
		this._socketLock = lock;
		this._combiner = new BufferCombiner(bufferSize);
		this.#writer = writer;
		this.#readable = readable;
		this.#socketLock = lock;
		this.#combiner = new BufferCombiner(bufferSize);
		}

		private async writeInnerStream(buffer: Uint8Array) {
		await ConsumableWritableStream.write(this._writer, buffer);
		await ConsumableWritableStream.write(this.#writer, buffer);
		}

		public async flush() {
		try {
		await this._writeLock.wait();
		const buffer = this._combiner.flush();
		await this.#writeLock.wait();
		const buffer = this.#combiner.flush();
		if (buffer) {
		await this.writeInnerStream(buffer);
		}
		} finally {
		this._writeLock.notifyOne();
		this.#writeLock.notifyOne();
		}
		}

		public async write(data: Uint8Array) {
		try {
		await this._writeLock.wait();
		for (const buffer of this._combiner.push(data)) {
		await this.#writeLock.wait();
		for (const buffer of this.#combiner.push(data)) {
		await this.writeInnerStream(buffer);
		}
		} finally {
		this._writeLock.notifyOne();
		this.#writeLock.notifyOne();
		}
		}

		public async readExactly(length: number) {
		await this.flush();
		return await this._readable.readExactly(length);
		return await this.#readable.readExactly(length);
		}

		public release(): void {
		this._combiner.flush();
		this._socketLock.notifyOne();
		this.#combiner.flush();
		this.#socketLock.notifyOne();
		}
		}

		export class AdbSyncSocket {
		private _lock = new AutoResetEvent();
		private _socket: AdbSocket;
		private _locked: AdbSyncSocketLocked;
		readonly #lock = new AutoResetEvent();
		readonly #socket: AdbSocket;
		readonly #locked: AdbSyncSocketLocked;

		public constructor(socket: AdbSocket, bufferSize: number) {
		this._socket = socket;
		this._locked = new AdbSyncSocketLocked(
		this.#socket = socket;
		this.#locked = new AdbSyncSocketLocked(
		socket.writable.getWriter(),
		new BufferedReadableStream(socket.readable),
		bufferSize,
		this._lock
		this.#lock
		);
		}

		public async lock() {
		await this._lock.wait();
		return this._locked;
		await this.#lock.wait();
		return this.#locked;
		}

		public async close() {
		await this._socket.close();
		await this.#socket.close();
		}
		}