feat(adb): allow `reverse.add` to accept any string local address

import { decodeUtf8, WritableStream } from "@yume-chan/adb";

import { makeAutoObservable, reaction, runInAction } from "mobx";

import { observer } from "mobx-react-lite";

import { NextPage } from "next";

import { GlobalState } from "../state";

const state = makeAutoObservable({

    log: [] as string[],

});

reaction(() => GlobalState.device, async device => {

    if (!device) {

        return;

    }

    await device.reverse.remove('tcp:3000').catch(() => { });

    await device.reverse.add('tcp:3000', 'tcp:1234', socket => {

        runInAction(() => {

            state.log.push(`received stream ${socket.localId}`);

        });

        socket.readable.pipeTo(new WritableStream({

            write: chunk => {

                runInAction(() => {

                    state.log.push(`data from ${socket.localId}: ${decodeUtf8(chunk)}`);

                });

            }

        }));

        // Return true to accept the connection.

        return true;

    });

}, { fireImmediately: true });

const ReverseTesterPage: NextPage = () => {

    return (

        <div>

            {state.log.map(line => (

                <div>{line}</div>

            ))}

        </div>

    );

};

export default observer(ReverseTesterPage);

}

const AdbReverseStringResponse =

    new Struct({ littleEndian: true })

    new Struct()

        .string('length', { length: 4 })

        .string('content', { lengthField: 'length', lengthFieldBase: 16 });

        .string('content', { lengthField: 'length', lengthFieldRadix: 16 });

const AdbReverseErrorResponse =

    new Struct({ littleEndian: true })

    new Struct()

        .fields(AdbReverseStringResponse)

        .postDeserialize((value) => {

            throw new Error(value.content);

        });

export class AdbReverseCommand extends AutoDisposable {

    protected localPortToHandler = new Map<number, AdbIncomingSocketHandler>();

    protected localAddressToHandler = new Map<string, AdbIncomingSocketHandler>();

    protected deviceAddressToLocalPort = new Map<string, number>();

    protected deviceAddressToLocalAddress = new Map<string, string>();

    protected adb: Adb;

    }

    protected handleIncomingSocket = async (socket: AdbSocket) => {

        const address = socket.serviceString;

        // Address format: `tcp:12345\0`

        const port = Number.parseInt(address.substring(4));

        return !!(await this.localPortToHandler.get(port)?.(socket));

        let address = socket.serviceString;

        // ADB daemon appends `\0` to the service string

        address = address.replace(/\0/g, '');

        return !!(await this.localAddressToHandler.get(address)?.(socket));

    };

    private async createBufferedStream(service: string) {

    /**

     * @param deviceAddress The address adbd on device is listening on. Can be `tcp:0` to let adbd choose an available TCP port by itself.

     * @param localPort Native ADB will open a connection to localPort when reverse connection starts. In webadb, it's only used to uniquely identify a reverse registry, `handler` will be called on connection.

     * @param localAddress Native ADB client will open a connection to this address when reverse connection received. In WebADB, it's only used to uniquely identify a reverse tunnel registry, `handler` will be called to handle the connection.

     * @param handler A callback to handle incoming connections

     * @returns If `deviceAddress` is `tcp:0`, return `tcp:{ACTUAL_LISTENING_PORT}`; otherwise, return `deviceAddress`.

     */

    public async add(

        deviceAddress: string,

        localPort: number,

        localAddress: string,

        handler: AdbIncomingSocketHandler,

    ): Promise<string> {

        const stream = await this.sendRequest(`reverse:forward:${deviceAddress};tcp:${localPort}`);

        const stream = await this.sendRequest(`reverse:forward:${deviceAddress};${localAddress}`);

        // `tcp:0` tells the device to pick an available port.

        // Begin with Android 8, device will respond with the selected port for all `tcp:` requests.

            }

        }

        this.localPortToHandler.set(localPort, handler);

        this.deviceAddressToLocalPort.set(deviceAddress, localPort);

        this.localAddressToHandler.set(localAddress, handler);

        this.deviceAddressToLocalAddress.set(deviceAddress, localAddress);

        return deviceAddress;

        // No need to close the stream, device will close it

    public async remove(deviceAddress: string): Promise<void> {

        await this.sendRequest(`reverse:killforward:${deviceAddress}`);

        if (this.deviceAddressToLocalPort.has(deviceAddress)) {

            this.localPortToHandler.delete(this.deviceAddressToLocalPort.get(deviceAddress)!);

            this.deviceAddressToLocalPort.delete(deviceAddress);

        if (this.deviceAddressToLocalAddress.has(deviceAddress)) {

            this.localAddressToHandler.delete(this.deviceAddressToLocalAddress.get(deviceAddress)!);

            this.deviceAddressToLocalAddress.delete(deviceAddress);

        }

        // No need to close the stream, device will close it

    public async removeAll(): Promise<void> {

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

        this.deviceAddressToLocalPort.clear();

        this.localPortToHandler.clear();

        this.deviceAddressToLocalAddress.clear();

        this.localAddressToHandler.clear();

        // No need to close the stream, device will close it

    }

        const writer = queue.writable.getWriter();

        this.address = await this.device.reverse.add(

            'localabstract:scrcpy',

            27183,

            'tcp:27183',

            socket => {

                writer.write(socket);

                return true;