@yume-chan/scrcpy 0.0.17 → 0.0.18

package/src/adb/client.ts

@@ -1,12 +1,35 @@
-import { Adb, AdbSubprocessNoneProtocol, AdbSubprocessProtocol, AdbSync } from '@yume-chan/adb';
-import { AbortController, DecodeUtf8Stream, InspectStream, ReadableStream, SplitStringStream, WrapWritableStream, WritableStream, type ReadableStreamDefaultController, type ReadableStreamDefaultReader, type ReadableWritablePair } from '@yume-chan/stream-extra';
-
-import { ScrcpyControlMessageSerializer } from '../control/index.js';
-import { ScrcpyDeviceMessageDeserializeStream, type ScrcpyDeviceMessage } from '../device-message/index.js';
-import { DEFAULT_SERVER_PATH, type ScrcpyVideoStreamPacket } from '../options/index.js';
-import type { AdbScrcpyOptions } from './options/index.js';
-
-class ArrayToStream<T> extends ReadableStream<T>{
+import {
+    AdbSubprocessNoneProtocol,
+    type Adb,
+    type AdbSubprocessProtocol,
+    type AdbSync,
+} from "@yume-chan/adb";
+import {
+    AbortController,
+    DecodeUtf8Stream,
+    InspectStream,
+    ReadableStream,
+    SplitStringStream,
+    WrapWritableStream,
+    WritableStream,
+    type ReadableStreamDefaultController,
+    type ReadableStreamDefaultReader,
+    type ReadableWritablePair,
+} from "@yume-chan/stream-extra";
+
+import { ScrcpyControlMessageSerializer } from "../control/index.js";
+import {
+    ScrcpyDeviceMessageDeserializeStream,
+    type ScrcpyDeviceMessage,
+} from "../device-message/index.js";
+import {
+    DEFAULT_SERVER_PATH,
+    type ScrcpyVideoStreamPacket,
+} from "../options/index.js";
+
+import { type AdbScrcpyOptions } from "./options/index.js";
+
+class ArrayToStream<T> extends ReadableStream<T> {
     private array!: T[];
     private index = 0;
 
@@ -28,7 +51,7 @@ class ArrayToStream<T> extends ReadableStream<T>{
     }
 }
 
-class ConcatStream<T> extends ReadableStream<T>{
+class ConcatStream<T> extends ReadableStream<T> {
     private streams!: ReadableStream<T>[];
     private index = 0;
     private reader!: ReadableStreamDefaultReader<T>;
@@ -48,7 +71,7 @@ class ConcatStream<T> extends ReadableStream<T>{
                     return;
                 }
                 this.advance(controller);
-            }
+            },
         });
     }
 
@@ -62,11 +85,17 @@ class ConcatStream<T> extends ReadableStream<T>{
     }
 }
 
+export class ScrcpyExitedError extends Error {
+    public output: string[];
+
+    public constructor(output: string[]) {
+        super("scrcpy server exited prematurely");
+        this.output = output;
+    }
+}
+
 export class AdbScrcpyClient {
-    public static pushServer(
-        adb: Adb,
-        path = DEFAULT_SERVER_PATH,
-    ) {
+    public static pushServer(adb: Adb, path = DEFAULT_SERVER_PATH) {
         let sync!: AdbSync;
         return new WrapWritableStream<Uint8Array>({
             async start() {
@@ -83,7 +112,7 @@ export class AdbScrcpyClient {
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<any>
+        options: AdbScrcpyOptions<object>
     ) {
         const connection = options.createConnection(adb);
         let process: AdbSubprocessProtocol | undefined;
@@ -95,9 +124,9 @@ export class AdbScrcpyClient {
                 [
                     // cspell: disable-next-line
                     `CLASSPATH=${path}`,
-                    'app_process',
-                    /* unused */ '/',
-                    'com.genymobile.scrcpy.Server',
+                    "app_process",
+                    /* unused */ "/",
+                    "com.genymobile.scrcpy.Server",
                     version,
                     ...options.formatServerArguments(),
                 ],
@@ -110,31 +139,34 @@ export class AdbScrcpyClient {
 
             const stdout = process.stdout
                 .pipeThrough(new DecodeUtf8Stream())
-                .pipeThrough(new SplitStringStream('\n'));
+                .pipeThrough(new SplitStringStream("\n"));
 
             // Read stdout, otherwise `process.exit` won't resolve.
             const output: string[] = [];
             const abortController = new AbortController();
             const pipe = stdout
-                .pipeTo(new WritableStream({
-                    write(chunk) {
-                        output.push(chunk);
+                .pipeTo(
+                    new WritableStream({
+                        write(chunk) {
+                            output.push(chunk);
+                        },
+                    }),
+                    {
+                        signal: abortController.signal,
+                        preventCancel: true,
                     }
-                }), {
-                    signal: abortController.signal,
-                    preventCancel: true,
-                })
-                .catch(() => { });
+                )
+                .catch((e) => {
+                    void e;
+                });
 
             const result = await Promise.race([
                 process.exit,
                 connection.getStreams(),
             ]);
 
-            if (typeof result === 'number') {
-                const error = new Error('scrcpy server exited prematurely');
-                (error as any).output = output;
-                throw error;
+            if (typeof result === "number") {
+                throw new ScrcpyExitedError(output);
             }
 
             abortController.abort();
@@ -144,10 +176,7 @@ export class AdbScrcpyClient {
             return new AdbScrcpyClient(
                 options,
                 process,
-                new ConcatStream(
-                    new ArrayToStream(output),
-                    stdout,
-                ),
+                new ConcatStream(new ArrayToStream(output), stdout),
                 videoStream,
                 controlStream
             );
@@ -167,35 +196,34 @@ export class AdbScrcpyClient {
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<any>
+        options: AdbScrcpyOptions<object>
     ): Promise<string[]> {
-        // Provide an invalid encoder name
-        // So the server will return all available encoders
-        options.value.encoderName = '_';
-        // Disable control for faster connection in 1.22+
-        options.value.control = false;
-        options.value.sendDeviceMeta = false;
-        options.value.sendDummyByte = false;
+        Object.assign(options.value, {
+            // Provide an invalid encoder name
+            // So the server will return all available encoders
+            encoderName: "_",
+            // Disable control for faster connection in 1.22+
+            control: false,
+            sendDeviceMeta: false,
+            sendDummyByte: false,
+        });
 
         // Scrcpy server will open connections, before initializing encoder
         // Thus although an invalid encoder name is given, the start process will success
-        const client = await AdbScrcpyClient.start(
-            adb,
-            path,
-            version,
-            options
-        );
+        const client = await AdbScrcpyClient.start(adb, path, version, options);
 
         const encoderNameRegex = options.getOutputEncoderNameRegex();
         const encoders: string[] = [];
-        await client.stdout.pipeTo(new WritableStream({
-            write(line) {
-                const match = line.match(encoderNameRegex);
-                if (match) {
-                    encoders.push(match[1]!);
-                }
-            },
-        }));
+        await client.stdout.pipeTo(
+            new WritableStream({
+                write(line) {
+                    const match = line.match(encoderNameRegex);
+                    if (match) {
+                        encoders.push(match[1]!);
+                    }
+                },
+            })
+        );
 
         return encoders;
     }
@@ -208,25 +236,25 @@ export class AdbScrcpyClient {
         adb: Adb,
         path: string,
         version: string,
-        options: AdbScrcpyOptions<any>
+        options: AdbScrcpyOptions<object>
     ): Promise<number[]> {
-        // Similar to `getEncoders`, pass an invalid option and parse the output
-        options.value.displayId = -1;
-
-        options.value.control = false;
-        options.value.sendDeviceMeta = false;
-        options.value.sendDummyByte = false;
+        Object.assign(options.value, {
+            // Similar to `getEncoders`, pass an invalid option and parse the output
+            displayId: -1,
+            // Disable control for faster connection in 1.22+
+            control: false,
+            sendDeviceMeta: false,
+            sendDummyByte: false,
+        });
 
         try {
             // Server will exit before opening connections when an invalid display id was given.
             await AdbScrcpyClient.start(adb, path, version, options);
         } catch (e) {
-            if (e instanceof Error) {
-                const output = (e as any).output as string[];
-
+            if (e instanceof ScrcpyExitedError) {
                 const displayIdRegex = /\s+scrcpy --display (\d+)/;
                 const displays: number[] = [];
-                for (const line of output) {
+                for (const line of e.output) {
                     const match = line.match(displayIdRegex);
                     if (match) {
                         displays.push(Number.parseInt(match[1]!, 10));
@@ -236,53 +264,78 @@ export class AdbScrcpyClient {
             }
         }
 
-        throw new Error('failed to get displays');
+        throw new Error("failed to get displays");
     }
 
     private process: AdbSubprocessProtocol;
 
     private _stdout: ReadableStream<string>;
-    public get stdout() { return this._stdout; }
+    public get stdout() {
+        return this._stdout;
+    }
 
-    public get exit() { return this.process.exit; }
+    public get exit() {
+        return this.process.exit;
+    }
 
     private _screenWidth: number | undefined;
-    public get screenWidth() { return this._screenWidth; }
+    public get screenWidth() {
+        return this._screenWidth;
+    }
 
     private _screenHeight: number | undefined;
-    public get screenHeight() { return this._screenHeight; }
+    public get screenHeight() {
+        return this._screenHeight;
+    }
 
     private _videoStream: ReadableStream<ScrcpyVideoStreamPacket>;
-    public get videoStream() { return this._videoStream; }
+    public get videoStream() {
+        return this._videoStream;
+    }
 
-    private _controlMessageSerializer: ScrcpyControlMessageSerializer | undefined;
-    public get controlMessageSerializer() { return this._controlMessageSerializer; }
+    private _controlMessageSerializer:
+        | ScrcpyControlMessageSerializer
+        | undefined;
+    public get controlMessageSerializer() {
+        return this._controlMessageSerializer;
+    }
 
-    private _deviceMessageStream: ReadableStream<ScrcpyDeviceMessage> | undefined;
-    public get deviceMessageStream() { return this._deviceMessageStream; }
+    private _deviceMessageStream:
+        | ReadableStream<ScrcpyDeviceMessage>
+        | undefined;
+    public get deviceMessageStream() {
+        return this._deviceMessageStream;
+    }
 
     public constructor(
-        options: AdbScrcpyOptions<any>,
+        options: AdbScrcpyOptions<object>,
         process: AdbSubprocessProtocol,
         stdout: ReadableStream<string>,
         videoStream: ReadableStream<Uint8Array>,
-        controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined,
+        controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined
     ) {
         this.process = process;
         this._stdout = stdout;
 
         this._videoStream = videoStream
             .pipeThrough(options.createVideoStreamTransformer())
-            .pipeThrough(new InspectStream(packet => {
-                if (packet.type === 'configuration') {
-                    this._screenWidth = packet.data.croppedWidth;
-                    this._screenHeight = packet.data.croppedHeight;
-                }
-            }));
+            .pipeThrough(
+                new InspectStream((packet) => {
+                    if (packet.type === "configuration") {
+                        this._screenWidth = packet.data.croppedWidth;
+                        this._screenHeight = packet.data.croppedHeight;
+                    }
+                })
+            );
 
         if (controlStream) {
-            this._controlMessageSerializer = new ScrcpyControlMessageSerializer(controlStream.writable, options);
-            this._deviceMessageStream = controlStream.readable.pipeThrough(new ScrcpyDeviceMessageDeserializeStream());
+            this._controlMessageSerializer = new ScrcpyControlMessageSerializer(
+                controlStream.writable,
+                options
+            );
+            this._deviceMessageStream = controlStream.readable.pipeThrough(
+                new ScrcpyDeviceMessageDeserializeStream()
+            );
         }
     }
 

package/src/adb/connection.ts

@@ -1,8 +1,13 @@
-import type { Adb } from '@yume-chan/adb';
-import { delay } from '@yume-chan/async';
-import type { Disposable } from '@yume-chan/event';
-import { TransformStream, type ReadableStream, type ReadableStreamDefaultReader, type ReadableWritablePair } from '@yume-chan/stream-extra';
-import type { ValueOrPromise } from '@yume-chan/struct';
+import { type Adb } from "@yume-chan/adb";
+import { delay } from "@yume-chan/async";
+import { type Disposable } from "@yume-chan/event";
+import {
+    TransformStream,
+    type ReadableStream,
+    type ReadableStreamDefaultReader,
+    type ReadableWritablePair,
+} from "@yume-chan/stream-extra";
+import { type ValueOrPromise } from "@yume-chan/struct";
 
 export interface AdbScrcpyConnectionOptions {
     control: boolean;
@@ -28,20 +33,33 @@ export abstract class AdbScrcpyConnection implements Disposable {
         this.options = options;
     }
 
-    public initialize(): ValueOrPromise<void> { }
-
-    public abstract getStreams(): ValueOrPromise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]>;
+    public initialize(): ValueOrPromise<void> {
+        // do nothing
+    }
 
-    public dispose(): void { }
+    public abstract getStreams(): ValueOrPromise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | undefined
+        ]
+    >;
+
+    public dispose(): void {
+        // do nothing
+    }
 }
 
 export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
     private connect(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
-        return this.adb.createSocket('localabstract:scrcpy');
+        return this.adb.createSocket("localabstract:scrcpy");
     }
 
-    private async connectAndRetry(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
-        for (let i = 0; i < 100; i++) {
+    private async connectAndRetry(): Promise<
+        ReadableWritablePair<Uint8Array, Uint8Array>
+    > {
+        for (let i = 0; i < 100; i += 1) {
             try {
                 return await this.connect();
             } catch (e) {
@@ -58,17 +76,26 @@ export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
             const { done, value } = await reader.read();
             // server will write a `0` to signal connection success
             if (done || value.byteLength !== 1 || value[0] !== 0) {
-                throw new Error('Unexpected response from server');
+                throw new Error("Unexpected response from server");
             }
             reader.releaseLock();
         }
         return videoStream;
     }
 
-    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
+    public async getStreams(): Promise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | undefined
+        ]
+    > {
         const videoStream = await this.connectVideoStream();
 
-        let controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined;
+        let controlStream:
+            | ReadableWritablePair<Uint8Array, Uint8Array>
+            | undefined;
         if (this.options.control) {
             controlStream = await this.connectAndRetry();
         }
@@ -79,7 +106,7 @@ export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
             const { done, value } = await reader.read();
             // 64 bytes device name + 2 bytes video width + 2 bytes video height
             if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error('Unexpected response from server');
+                throw new Error("Unexpected response from server");
             }
             reader.releaseLock();
         }
@@ -89,35 +116,53 @@ export class AdbScrcpyForwardConnection extends AdbScrcpyConnection {
 }
 
 export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
-    private streams!: ReadableStreamDefaultReader<ReadableWritablePair<Uint8Array, Uint8Array>>;
+    private streams!: ReadableStreamDefaultReader<
+        ReadableWritablePair<Uint8Array, Uint8Array>
+    >;
 
     private address!: string;
 
     public override async initialize(): Promise<void> {
         // try to unbind first, ignore errors
-        await this.adb.reverse.remove('localabstract:scrcpy').catch(() => { });
-
-        const queue = new TransformStream<ReadableWritablePair<Uint8Array, Uint8Array>>();
+        await this.adb.reverse.remove("localabstract:scrcpy").catch((e) => {
+            void e;
+        });
+
+        const queue = new TransformStream<
+            ReadableWritablePair<Uint8Array, Uint8Array>,
+            ReadableWritablePair<Uint8Array, Uint8Array>
+        >();
         this.streams = queue.readable.getReader();
         const writer = queue.writable.getWriter();
         this.address = await this.adb.reverse.add(
-            'localabstract:scrcpy',
-            'tcp:27183',
-            socket => {
-                writer.write(socket);
+            "localabstract:scrcpy",
+            "tcp:27183",
+            (socket) => {
+                void writer.write(socket);
                 return true;
-            },
+            }
         );
     }
 
-    private async accept(): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+    private async accept(): Promise<
+        ReadableWritablePair<Uint8Array, Uint8Array>
+    > {
         return (await this.streams.read()).value!;
     }
 
-    public async getStreams(): Promise<[videoSteam: ReadableStream<Uint8Array>, controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined]> {
+    public async getStreams(): Promise<
+        [
+            videoSteam: ReadableStream<Uint8Array>,
+            controlStream:
+                | ReadableWritablePair<Uint8Array, Uint8Array>
+                | undefined
+        ]
+    > {
         const { readable: videoStream } = await this.accept();
 
-        let controlStream: ReadableWritablePair<Uint8Array, Uint8Array> | undefined;
+        let controlStream:
+            | ReadableWritablePair<Uint8Array, Uint8Array>
+            | undefined;
         if (this.options.control) {
             controlStream = await this.accept();
         }
@@ -128,7 +173,7 @@ export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
             const { done, value } = await reader.read();
             // 64 bytes device name + 2 bytes video width + 2 bytes video height
             if (done || value.byteLength !== 64 + 2 + 2) {
-                throw new Error('Unexpected response from server');
+                throw new Error("Unexpected response from server");
             }
             reader.releaseLock();
         }
@@ -140,6 +185,8 @@ export class AdbScrcpyReverseConnection extends AdbScrcpyConnection {
         // Don't await this!
         // `reverse.remove`'s response will never arrive
         // before we read all pending data from `videoStream`
-        this.adb.reverse.remove(this.address);
+        this.adb.reverse.remove(this.address).catch((e) => {
+            void e;
+        });
     }
 }

package/src/adb/options/1_16.ts

@@ -1,11 +1,18 @@
-import type { Adb } from '@yume-chan/adb';
+import { type Adb } from "@yume-chan/adb";
 
-import type { ScrcpyOptionsInit1_16 } from '../../options/index.js';
-import { AdbScrcpyConnection, AdbScrcpyConnectionOptions, AdbScrcpyForwardConnection, AdbScrcpyReverseConnection } from '../connection.js';
-import { AdbScrcpyOptionsBase } from './types.js';
+import { type ScrcpyOptionsInit1_16 } from "../../options/index.js";
+import {
+    AdbScrcpyForwardConnection,
+    AdbScrcpyReverseConnection,
+    type AdbScrcpyConnection,
+    type AdbScrcpyConnectionOptions,
+} from "../connection.js";
 
-export class AdbScrcpyOptions1_16<T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16>
-    extends AdbScrcpyOptionsBase<T> {
+import { AdbScrcpyOptionsBase } from "./types.js";
+
+export class AdbScrcpyOptions1_16<
+    T extends ScrcpyOptionsInit1_16 = ScrcpyOptionsInit1_16
+> extends AdbScrcpyOptionsBase<T> {
     public override createConnection(adb: Adb): AdbScrcpyConnection {
         const options: AdbScrcpyConnectionOptions = {
             // Old versions always have control stream no matter what the option is

package/src/adb/options/1_22.ts

@@ -1,11 +1,17 @@
-import type { Adb } from '@yume-chan/adb';
+import { type Adb } from "@yume-chan/adb";
 
-import type { ScrcpyOptionsInit1_22 } from '../../options/index.js';
-import { AdbScrcpyConnection, AdbScrcpyForwardConnection, AdbScrcpyReverseConnection } from '../connection.js';
-import { AdbScrcpyOptions1_16 } from './1_16.js';
+import { type ScrcpyOptionsInit1_22 } from "../../options/index.js";
+import {
+    type AdbScrcpyConnection,
+    AdbScrcpyForwardConnection,
+    AdbScrcpyReverseConnection,
+} from "../connection.js";
 
-export class AdbScrcpyOptions1_22<T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22>
-    extends AdbScrcpyOptions1_16<T> {
+import { AdbScrcpyOptions1_16 } from "./1_16.js";
+
+export class AdbScrcpyOptions1_22<
+    T extends ScrcpyOptionsInit1_22 = ScrcpyOptionsInit1_22
+> extends AdbScrcpyOptions1_16<T> {
     public override createConnection(adb: Adb): AdbScrcpyConnection {
         const options = {
             ...this.getDefaultValue(),

package/src/adb/options/types.ts

@@ -1,19 +1,32 @@
-import type { Adb } from '@yume-chan/adb';
-import type { TransformStream } from '@yume-chan/stream-extra';
+import { type Adb } from "@yume-chan/adb";
+import { type TransformStream } from "@yume-chan/stream-extra";
 
-import type { ScrcpyControlMessageType } from '../../control/index.js';
-import type { ScrcpyBackOrScreenOnControlMessage1_18, ScrcpyInjectScrollControlMessage1_22, ScrcpyOptions, ScrcpyVideoStreamPacket } from '../../options/index.js';
-import type { AdbScrcpyConnection } from '../connection.js';
+import {
+    type ScrcpyBackOrScreenOnControlMessage,
+    type ScrcpyControlMessageType,
+    type ScrcpySetClipboardControlMessage,
+} from "../../control/index.js";
+import {
+    type ScrcpyOptions,
+    type ScrcpyVideoStreamPacket,
+} from "../../options/index.js";
+import { type AdbScrcpyConnection } from "../connection.js";
 
-export interface AdbScrcpyOptions<T> extends ScrcpyOptions<T> {
+export interface AdbScrcpyOptions<T extends object> extends ScrcpyOptions<T> {
     createConnection(adb: Adb): AdbScrcpyConnection;
 }
 
-export abstract class AdbScrcpyOptionsBase<T> implements ScrcpyOptions<T> {
+export abstract class AdbScrcpyOptionsBase<T extends object>
+    implements ScrcpyOptions<T>
+{
     private raw: ScrcpyOptions<T>;
 
-    public get value(): Partial<T> { return this.raw.value; }
-    public set value(value: Partial<T>) { this.raw.value = value; }
+    public get value(): Partial<T> {
+        return this.raw.value;
+    }
+    public set value(value: Partial<T>) {
+        this.raw.value = value;
+    }
 
     public constructor(raw: ScrcpyOptions<T>) {
         this.raw = raw;
@@ -31,7 +44,10 @@ export abstract class AdbScrcpyOptionsBase<T> implements ScrcpyOptions<T> {
         return this.raw.getOutputEncoderNameRegex();
     }
 
-    public createVideoStreamTransformer(): TransformStream<Uint8Array, ScrcpyVideoStreamPacket> {
+    public createVideoStreamTransformer(): TransformStream<
+        Uint8Array,
+        ScrcpyVideoStreamPacket
+    > {
         return this.raw.createVideoStreamTransformer();
     }
 
@@ -40,15 +56,19 @@ export abstract class AdbScrcpyOptionsBase<T> implements ScrcpyOptions<T> {
     }
 
     public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage1_18,
+        message: ScrcpyBackOrScreenOnControlMessage
     ): Uint8Array | undefined {
         return this.raw.serializeBackOrScreenOnControlMessage(message);
     }
 
-    public serializeInjectScrollControlMessage(
-        message: ScrcpyInjectScrollControlMessage1_22,
+    public serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage
     ): Uint8Array {
-        return this.raw.serializeInjectScrollControlMessage(message);
+        return this.raw.serializeSetClipboardControlMessage(message);
+    }
+
+    public getScrollController() {
+        return this.raw.getScrollController();
     }
 
     public abstract createConnection(adb: Adb): AdbScrcpyConnection;