@yume-chan/scrcpy 0.0.20 → 0.0.22

package/src/control/hover-helper.ts

@@ -15,34 +15,33 @@ import { ScrcpyControlMessageType } from "./type.js";
  * so Scrcpy server can remove the previously hovering pointer.
  */
 export class ScrcpyHoverHelper {
-    // AFAIK, only mouse and pen can have hover state
-    // and you can't have two mouses or pens.
-    // So remember the last hovering pointer is enough.
-    private lastHoverMessage: ScrcpyInjectTouchControlMessage | undefined;
+    // There can be only one hovering pointer (either mouse or pen,
+    // touch can have multiple pointers but no hovering state).
+    #lastHoverMessage: ScrcpyInjectTouchControlMessage | undefined;
 
-    public process(
-        message: Omit<ScrcpyInjectTouchControlMessage, "type">
+    process(
+        message: Omit<ScrcpyInjectTouchControlMessage, "type">,
     ): ScrcpyInjectTouchControlMessage[] {
         const result: ScrcpyInjectTouchControlMessage[] = [];
 
         // A different pointer appeared,
         // Cancel previously hovering pointer so Scrcpy server can free up the pointer ID.
         if (
-            this.lastHoverMessage &&
-            this.lastHoverMessage.pointerId !== message.pointerId
+            this.#lastHoverMessage &&
+            this.#lastHoverMessage.pointerId !== message.pointerId
         ) {
             // TODO: Inject MotionEvent.ACTION_HOVER_EXIT
             // From testing, it seems no App cares about this event.
             result.push({
-                ...this.lastHoverMessage,
+                ...this.#lastHoverMessage,
                 action: AndroidMotionEventAction.Up,
             });
-            this.lastHoverMessage = undefined;
+            this.#lastHoverMessage = undefined;
         }
 
         if (message.action === AndroidMotionEventAction.HoverMove) {
             // TODO: Inject MotionEvent.ACTION_HOVER_ENTER
-            this.lastHoverMessage = message as ScrcpyInjectTouchControlMessage;
+            this.#lastHoverMessage = message as ScrcpyInjectTouchControlMessage;
         }
 
         (message as ScrcpyInjectTouchControlMessage).type =

package/src/control/inject-touch.ts

@@ -27,7 +27,6 @@ export enum AndroidMotionEventButton {
     StylusSecondary = 0x40,
 }
 
-// eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace ScrcpyPointerId {
     export const Mouse = -1n;
     export const Finger = -2n;

package/src/control/serializer.ts

@@ -3,6 +3,7 @@ import type {
     ScrcpyScrollController,
 } from "../options/index.js";
 
+import { BasicControlMessage } from "./basic.js";
 import type { AndroidKeyEventAction } from "./inject-keycode.js";
 import { ScrcpyInjectKeyCodeControlMessage } from "./inject-keycode.js";
 import type { ScrcpyInjectScrollControlMessage } from "./inject-scroll.js";
@@ -17,79 +18,99 @@ import {
 } from "./type.js";
 
 export class ScrcpyControlMessageSerializer {
-    private _options: ScrcpyOptions<object>;
-    private _typeValues: ScrcpyControlMessageTypeValue;
-    private _scrollController: ScrcpyScrollController;
+    #options: ScrcpyOptions<object>;
+    #typeValues: ScrcpyControlMessageTypeValue;
+    #scrollController: ScrcpyScrollController;
 
-    public constructor(options: ScrcpyOptions<object>) {
-        this._options = options;
-        this._typeValues = new ScrcpyControlMessageTypeValue(options);
-        this._scrollController = options.createScrollController();
+    constructor(options: ScrcpyOptions<object>) {
+        this.#options = options;
+        this.#typeValues = new ScrcpyControlMessageTypeValue(options);
+        this.#scrollController = options.createScrollController();
     }
 
-    public injectKeyCode(
-        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
-    ) {
+    injectKeyCode(message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">) {
         return ScrcpyInjectKeyCodeControlMessage.serialize(
-            this._typeValues.fillMessageType(
+            this.#typeValues.fillMessageType(
                 message,
-                ScrcpyControlMessageType.InjectKeyCode
-            )
+                ScrcpyControlMessageType.InjectKeyCode,
+            ),
         );
     }
 
-    public injectText(text: string) {
+    injectText(text: string) {
         return ScrcpyInjectTextControlMessage.serialize({
             text,
-            type: this._typeValues.get(ScrcpyControlMessageType.InjectText),
+            type: this.#typeValues.get(ScrcpyControlMessageType.InjectText),
         });
     }
 
     /**
      * `pressure` is a float value between 0 and 1.
      */
-    public injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
-        return this._options.serializeInjectTouchControlMessage(
-            this._typeValues.fillMessageType(
+    injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
+        return this.#options.serializeInjectTouchControlMessage(
+            this.#typeValues.fillMessageType(
                 message,
-                ScrcpyControlMessageType.InjectTouch
-            )
+                ScrcpyControlMessageType.InjectTouch,
+            ),
         );
     }
 
     /**
      * `scrollX` and `scrollY` are float values between 0 and 1.
      */
-    public injectScroll(
-        message: Omit<ScrcpyInjectScrollControlMessage, "type">
-    ) {
-        return this._scrollController.serializeScrollMessage(
-            this._typeValues.fillMessageType(
+    injectScroll(message: Omit<ScrcpyInjectScrollControlMessage, "type">) {
+        return this.#scrollController.serializeScrollMessage(
+            this.#typeValues.fillMessageType(
                 message,
-                ScrcpyControlMessageType.InjectScroll
-            )
+                ScrcpyControlMessageType.InjectScroll,
+            ),
         );
     }
 
-    public backOrScreenOn(action: AndroidKeyEventAction) {
-        return this._options.serializeBackOrScreenOnControlMessage({
+    backOrScreenOn(action: AndroidKeyEventAction) {
+        return this.#options.serializeBackOrScreenOnControlMessage({
             action,
-            type: this._typeValues.get(ScrcpyControlMessageType.BackOrScreenOn),
+            type: this.#typeValues.get(ScrcpyControlMessageType.BackOrScreenOn),
         });
     }
 
-    public setScreenPowerMode(mode: AndroidScreenPowerMode) {
+    setScreenPowerMode(mode: AndroidScreenPowerMode) {
         return ScrcpySetScreenPowerModeControlMessage.serialize({
             mode,
-            type: this._typeValues.get(
-                ScrcpyControlMessageType.SetScreenPowerMode
+            type: this.#typeValues.get(
+                ScrcpyControlMessageType.SetScreenPowerMode,
+            ),
+        });
+    }
+
+    expandNotificationPanel() {
+        return BasicControlMessage.serialize({
+            type: this.#typeValues.get(
+                ScrcpyControlMessageType.ExpandNotificationPanel,
+            ),
+        });
+    }
+
+    expandSettingPanel() {
+        return BasicControlMessage.serialize({
+            type: this.#typeValues.get(
+                ScrcpyControlMessageType.ExpandSettingPanel,
+            ),
+        });
+    }
+
+    collapseNotificationPanel() {
+        return BasicControlMessage.serialize({
+            type: this.#typeValues.get(
+                ScrcpyControlMessageType.CollapseNotificationPanel,
             ),
         });
     }
 
-    public rotateDevice() {
+    rotateDevice() {
         return ScrcpyRotateDeviceControlMessage.serialize({
-            type: this._typeValues.get(ScrcpyControlMessageType.RotateDevice),
+            type: this.#typeValues.get(ScrcpyControlMessageType.RotateDevice),
         });
     }
 }

package/src/control/type.ts

@@ -25,23 +25,23 @@ export enum ScrcpyControlMessageType {
  * This class provides a way to get the actual value for a given type.
  */
 export class ScrcpyControlMessageTypeValue {
-    private types: readonly ScrcpyControlMessageType[];
+    #types: readonly ScrcpyControlMessageType[];
 
-    public constructor(options: ScrcpyOptions<object>) {
-        this.types = options.controlMessageTypes;
+    constructor(options: ScrcpyOptions<object>) {
+        this.#types = options.controlMessageTypes;
     }
 
-    public get(type: ScrcpyControlMessageType): number {
-        const value = this.types.indexOf(type);
+    get(type: ScrcpyControlMessageType): number {
+        const value = this.#types.indexOf(type);
         if (value === -1) {
             throw new Error("Not supported");
         }
         return value;
     }
 
-    public fillMessageType<T extends { type: ScrcpyControlMessageType }>(
+    fillMessageType<T extends { type: ScrcpyControlMessageType }>(
         message: Omit<T, "type">,
-        type: T["type"]
+        type: T["type"],
     ): T {
         (message as T).type = this.get(type);
         return message as T;

package/src/control/writer.ts

@@ -16,72 +16,82 @@ import { ScrcpyControlMessageSerializer } from "./serializer.js";
 import type { AndroidScreenPowerMode } from "./set-screen-power-mode.js";
 
 export class ScrcpyControlMessageWriter {
-    private _writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
-    private _serializer: ScrcpyControlMessageSerializer;
+    #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    #serializer: ScrcpyControlMessageSerializer;
 
-    public constructor(
+    constructor(
         writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
-        options: ScrcpyOptions<object>
+        options: ScrcpyOptions<object>,
     ) {
-        this._writer = writer;
-        this._serializer = new ScrcpyControlMessageSerializer(options);
+        this.#writer = writer;
+        this.#serializer = new ScrcpyControlMessageSerializer(options);
     }
 
-    private async write(message: Uint8Array) {
-        await ConsumableWritableStream.write(this._writer, message);
+    async write(message: Uint8Array) {
+        await ConsumableWritableStream.write(this.#writer, message);
     }
 
-    public async injectKeyCode(
-        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">
+    async injectKeyCode(
+        message: Omit<ScrcpyInjectKeyCodeControlMessage, "type">,
     ) {
-        await this.write(this._serializer.injectKeyCode(message));
+        await this.write(this.#serializer.injectKeyCode(message));
     }
 
-    public async injectText(text: string) {
-        await this.write(this._serializer.injectText(text));
+    async injectText(text: string) {
+        await this.write(this.#serializer.injectText(text));
     }
 
     /**
      * `pressure` is a float value between 0 and 1.
      */
-    public async injectTouch(
-        message: Omit<ScrcpyInjectTouchControlMessage, "type">
-    ) {
-        await this.write(this._serializer.injectTouch(message));
+    async injectTouch(message: Omit<ScrcpyInjectTouchControlMessage, "type">) {
+        await this.write(this.#serializer.injectTouch(message));
     }
 
     /**
      * `scrollX` and `scrollY` are float values between 0 and 1.
      */
-    public async injectScroll(
-        message: Omit<ScrcpyInjectScrollControlMessage, "type">
+    async injectScroll(
+        message: Omit<ScrcpyInjectScrollControlMessage, "type">,
     ) {
-        const data = this._serializer.injectScroll(message);
+        const data = this.#serializer.injectScroll(message);
         if (data) {
             await this.write(data);
         }
     }
 
-    public async backOrScreenOn(action: AndroidKeyEventAction) {
-        const data = this._serializer.backOrScreenOn(action);
+    async backOrScreenOn(action: AndroidKeyEventAction) {
+        const data = this.#serializer.backOrScreenOn(action);
         if (data) {
             await this.write(data);
         }
     }
 
-    public async setScreenPowerMode(mode: AndroidScreenPowerMode) {
-        await this.write(this._serializer.setScreenPowerMode(mode));
+    async setScreenPowerMode(mode: AndroidScreenPowerMode) {
+        await this.write(this.#serializer.setScreenPowerMode(mode));
+    }
+
+    async expandNotificationPanel() {
+        await this.write(this.#serializer.expandNotificationPanel());
+    }
+
+    async expandSettingPanel() {
+        await this.write(this.#serializer.expandSettingPanel());
+    }
+
+    async collapseNotificationPanel() {
+        await this.write(this.#serializer.collapseNotificationPanel());
     }
 
-    public async rotateDevice() {
-        await this.write(this._serializer.rotateDevice());
+    async rotateDevice() {
+        await this.write(this.#serializer.rotateDevice());
     }
 
-    public releaseLock() {
-        this._writer.releaseLock();
+    releaseLock() {
+        this.#writer.releaseLock();
     }
 
-    public async close() {
-        await this._writer.close();
+    async close() {
+        await this.#writer.close();
     }
 }

package/src/device-message/stream.ts

@@ -21,11 +21,11 @@ export class ScrcpyDeviceMessageDeserializeStream extends BufferedTransformStrea
                 switch (type[0]) {
                     case ScrcpyDeviceMessageType.Clipboard:
                         return await ScrcpyClipboardDeviceMessage.deserialize(
-                            stream
+                            stream,
                         );
                     case ScrcpyDeviceMessageType.AckClipboard:
                         return await ScrcpyAckClipboardDeviceMessage.deserialize(
-                            stream
+                            stream,
                         );
                     default:
                         throw new Error("Unsupported control message type");

package/src/options/1_16/codec-options.ts

@@ -27,15 +27,23 @@ const CODEC_OPTION_TYPES: Partial<
 };
 
 export class CodecOptions implements ScrcpyOptionValue {
-    public value: Partial<CodecOptionsInit>;
+    options: Partial<CodecOptionsInit>;
 
-    public constructor(value: Partial<CodecOptionsInit> = {}) {
-        this.value = value;
+    constructor(options: Partial<CodecOptionsInit> = {}) {
+        for (const [key, value] of Object.entries(options)) {
+            if (typeof value !== "number") {
+                throw new Error(
+                    `Invalid option value for ${key}: ${String(value)}`,
+                );
+            }
+        }
+
+        this.options = options;
     }
 
-    public toOptionValue(): string | undefined {
-        const entries = Object.entries(this.value).filter(
-            ([, value]) => value !== undefined
+    toOptionValue(): string | undefined {
+        const entries = Object.entries(this.options).filter(
+            ([, value]) => value !== undefined,
         );
 
         if (entries.length === 0) {
@@ -44,8 +52,15 @@ export class CodecOptions implements ScrcpyOptionValue {
 
         return entries
             .map(([key, value]) => {
+                let result = toDashCase(key);
+
                 const type = CODEC_OPTION_TYPES[key as keyof CodecOptionsInit];
-                return `${toDashCase(key)}${type ? `:${type}` : ""}=${value}`;
+                if (type) {
+                    result += `:${type}`;
+                }
+
+                result += `=${value}`;
+                return result;
             })
             .join(",");
     }

package/src/options/1_16/float-to-uint16.ts

@@ -29,5 +29,5 @@ export const ScrcpyFloatToUint16NumberType: NumberFieldType = {
 };
 
 export const ScrcpyFloatToUint16FieldDefinition = new NumberFieldDefinition(
-    ScrcpyFloatToUint16NumberType
+    ScrcpyFloatToUint16NumberType,
 );

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

@@ -38,14 +38,14 @@ import type { ScrcpyScrollController } from "./scroll.js";
 import { ScrcpyScrollController1_16 } from "./scroll.js";
 
 export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
-    public static readonly DEFAULTS = {
+    static readonly DEFAULTS = {
         logLevel: ScrcpyLogLevel1_16.Debug,
         maxSize: 0,
         bitRate: 8_000_000,
         maxFps: 0,
         lockVideoOrientation: ScrcpyVideoOrientation1_16.Unlocked,
         tunnelForward: false,
-        crop: undefined,
+        crop: "",
         sendFrameMeta: true,
         control: true,
         displayId: 0,
@@ -54,7 +54,7 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         codecOptions: new CodecOptions(),
     } as const satisfies Required<ScrcpyOptionsInit1_16>;
 
-    public static readonly SERIALIZE_ORDER = [
+    static readonly SERIALIZE_ORDER = [
         "logLevel",
         "maxSize",
         "bitRate",
@@ -70,68 +70,64 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         "codecOptions",
     ] as const satisfies readonly (keyof ScrcpyOptionsInit1_16)[];
 
-    public static serialize<T>(options: T, order: readonly (keyof T)[]) {
+    static serialize<T>(options: T, order: readonly (keyof T)[]) {
         return order.map((key) => toScrcpyOptionValue(options[key], "-"));
     }
 
-    public static async parseCString(
+    static async parseCString(
         stream: AsyncExactReadable,
-        maxLength: number
+        maxLength: number,
     ): Promise<string> {
         let result = decodeUtf8(await stream.readExactly(maxLength));
         result = result.substring(0, result.indexOf("\0"));
         return result;
     }
 
-    public static async parseUint16BE(
-        stream: AsyncExactReadable
-    ): Promise<number> {
+    static async parseUint16BE(stream: AsyncExactReadable): Promise<number> {
         const buffer = await stream.readExactly(NumberFieldType.Uint16.size);
         return NumberFieldType.Uint16.deserialize(buffer, false);
     }
 
-    public static async parseUint32BE(
-        stream: AsyncExactReadable
-    ): Promise<number> {
+    static async parseUint32BE(stream: AsyncExactReadable): Promise<number> {
         const buffer = await stream.readExactly(NumberFieldType.Uint32.size);
         return NumberFieldType.Uint32.deserialize(buffer, false);
     }
 
-    public value: Required<ScrcpyOptionsInit1_16>;
+    value: Required<ScrcpyOptionsInit1_16>;
 
-    public readonly defaults: Required<ScrcpyOptionsInit1_16> =
+    readonly defaults: Required<ScrcpyOptionsInit1_16> =
         ScrcpyOptions1_16.DEFAULTS;
 
-    public readonly controlMessageTypes: readonly ScrcpyControlMessageType[] =
+    readonly controlMessageTypes: readonly ScrcpyControlMessageType[] =
         SCRCPY_CONTROL_MESSAGE_TYPES_1_16;
 
-    public constructor(init: ScrcpyOptionsInit1_16) {
+    constructor(init: ScrcpyOptionsInit1_16) {
         this.value = { ...ScrcpyOptions1_16.DEFAULTS, ...init };
     }
 
-    public serialize(): string[] {
+    serialize(): string[] {
         return ScrcpyOptions1_16.serialize(
             this.value,
-            ScrcpyOptions1_16.SERIALIZE_ORDER
+            ScrcpyOptions1_16.SERIALIZE_ORDER,
         );
     }
 
-    public setListEncoders(): void {
+    setListEncoders(): void {
         throw new Error("Not supported");
     }
 
-    public setListDisplays(): void {
+    setListDisplays(): void {
         // Set to an invalid value
         // Server will print valid values before crashing
         // (server will crash before opening sockets)
         this.value.displayId = -1;
     }
 
-    public parseEncoder(): ScrcpyEncoder | undefined {
+    parseEncoder(): ScrcpyEncoder | undefined {
         throw new Error("Not supported");
     }
 
-    public parseDisplay(line: string): ScrcpyDisplay | undefined {
+    parseDisplay(line: string): ScrcpyDisplay | undefined {
         const displayIdRegex = /\s+scrcpy --display (\d+)/;
         const match = line.match(displayIdRegex);
         if (match) {
@@ -142,8 +138,8 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         return undefined;
     }
 
-    public parseVideoStreamMetadata(
-        stream: ReadableStream<Uint8Array>
+    parseVideoStreamMetadata(
+        stream: ReadableStream<Uint8Array>,
     ): ValueOrPromise<ScrcpyVideoStream> {
         return (async () => {
             const buffered = new BufferedReadableStream(stream);
@@ -152,7 +148,7 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
             };
             metadata.deviceName = await ScrcpyOptions1_16.parseCString(
                 buffered,
-                64
+                64,
             );
             metadata.width = await ScrcpyOptions1_16.parseUint16BE(buffered);
             metadata.height = await ScrcpyOptions1_16.parseUint16BE(buffered);
@@ -160,11 +156,11 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         })();
     }
 
-    public parseAudioStreamMetadata(): never {
+    parseAudioStreamMetadata(): never {
         throw new Error("Not supported");
     }
 
-    public createMediaStreamTransformer(): TransformStream<
+    createMediaStreamTransformer(): TransformStream<
         Uint8Array,
         ScrcpyMediaStreamPacket
     > {
@@ -181,7 +177,7 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         }
 
         const deserializeStream = new StructDeserializeStream(
-            ScrcpyMediaStreamRawPacket
+            ScrcpyMediaStreamRawPacket,
         );
         return {
             writable: deserializeStream.writable,
@@ -202,19 +198,19 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
                             data: packet.data,
                         });
                     },
-                })
+                }),
             ),
         };
     }
 
-    public serializeInjectTouchControlMessage(
-        message: ScrcpyInjectTouchControlMessage
+    serializeInjectTouchControlMessage(
+        message: ScrcpyInjectTouchControlMessage,
     ): Uint8Array {
         return ScrcpyInjectTouchControlMessage1_16.serialize(message);
     }
 
-    public serializeBackOrScreenOnControlMessage(
-        message: ScrcpyBackOrScreenOnControlMessage
+    serializeBackOrScreenOnControlMessage(
+        message: ScrcpyBackOrScreenOnControlMessage,
     ) {
         if (message.action === AndroidKeyEventAction.Down) {
             return ScrcpyBackOrScreenOnControlMessage1_16.serialize(message);
@@ -223,13 +219,13 @@ export class ScrcpyOptions1_16 implements ScrcpyOptions<ScrcpyOptionsInit1_16> {
         return undefined;
     }
 
-    public serializeSetClipboardControlMessage(
-        message: ScrcpySetClipboardControlMessage
+    serializeSetClipboardControlMessage(
+        message: ScrcpySetClipboardControlMessage,
     ): Uint8Array {
         return ScrcpySetClipboardControlMessage1_15.serialize(message);
     }
 
-    public createScrollController(): ScrcpyScrollController {
+    createScrollController(): ScrcpyScrollController {
         return new ScrcpyScrollController1_16();
     }
 }

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

@@ -4,7 +4,7 @@ import type { ScrcpyInjectScrollControlMessage } from "../../control/index.js";
 
 export interface ScrcpyScrollController {
     serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage
+        message: ScrcpyInjectScrollControlMessage,
     ): Uint8Array | undefined;
 }
 
@@ -24,31 +24,31 @@ export const ScrcpyInjectScrollControlMessage1_16 = new Struct()
  * reaches 1 or -1.
  */
 export class ScrcpyScrollController1_16 implements ScrcpyScrollController {
-    private accumulatedX = 0;
-    private accumulatedY = 0;
+    #accumulatedX = 0;
+    #accumulatedY = 0;
 
     protected processMessage(
-        message: ScrcpyInjectScrollControlMessage
+        message: ScrcpyInjectScrollControlMessage,
     ): ScrcpyInjectScrollControlMessage | undefined {
-        this.accumulatedX += message.scrollX;
-        this.accumulatedY += message.scrollY;
+        this.#accumulatedX += message.scrollX;
+        this.#accumulatedY += message.scrollY;
 
         let scrollX = 0;
         let scrollY = 0;
-        if (this.accumulatedX >= 1) {
+        if (this.#accumulatedX >= 1) {
             scrollX = 1;
-            this.accumulatedX = 0;
-        } else if (this.accumulatedX <= -1) {
+            this.#accumulatedX = 0;
+        } else if (this.#accumulatedX <= -1) {
             scrollX = -1;
-            this.accumulatedX = 0;
+            this.#accumulatedX = 0;
         }
 
-        if (this.accumulatedY >= 1) {
+        if (this.#accumulatedY >= 1) {
             scrollY = 1;
-            this.accumulatedY = 0;
-        } else if (this.accumulatedY <= -1) {
+            this.#accumulatedY = 0;
+        } else if (this.#accumulatedY <= -1) {
             scrollY = -1;
-            this.accumulatedY = 0;
+            this.#accumulatedY = 0;
         }
 
         if (scrollX === 0 && scrollY === 0) {
@@ -60,8 +60,8 @@ export class ScrcpyScrollController1_16 implements ScrcpyScrollController {
         return message;
     }
 
-    public serializeScrollMessage(
-        message: ScrcpyInjectScrollControlMessage
+    serializeScrollMessage(
+        message: ScrcpyInjectScrollControlMessage,
     ): Uint8Array | undefined {
         const processed = this.processMessage(message);
         if (!processed) {