Add native MKB support for Android app

src/modules/mkb/mkb-handler.ts

@@ -1,5 +1,5 @@
 import { MkbPreset } from "./mkb-preset";
-import { GamepadKey, MkbPresetKey, GamepadStick, MouseMapTo } from "./definitions";
+import { GamepadKey, MkbPresetKey, GamepadStick, MouseMapTo, WheelCode } from "./definitions";
 import { createButton, ButtonStyle, CE } from "@utils/html";
 import { BxEvent } from "@utils/bx-event";
 import { PrefKey, getPref } from "@utils/preferences";
@@ -12,25 +12,19 @@ import { showStreamSettings } from "@modules/stream/stream-ui";
 import { AppInterface, STATES } from "@utils/global";
 import { UserAgent } from "@utils/user-agent";
 import { BxLogger } from "@utils/bx-logger";
-import { BxIcon } from "@utils/bx-icon";
 import { PointerClient } from "./pointer-client";
+import { NativeMkbHandler } from "./native-mkb-handler";
+import { MkbHandler, MouseDataProvider } from "./base-mkb-handler";
 
 const LOG_TAG = 'MkbHandler';
 
-
-abstract class MouseDataProvider {
-    protected mkbHandler: MkbHandler;
-    constructor(handler: MkbHandler) {
-        this.mkbHandler = handler;
-    }
-
-    abstract init(): void;
-    abstract start(): void;
-    abstract stop(): void;
-    abstract destroy(): void;
-    abstract toggle(enabled: boolean): void;
+const PointerToMouseButton = {
+    1: 0,
+    2: 2,
+    4: 1,
 }
 
+
 class WebSocketMouseDataProvider extends MouseDataProvider {
     #pointerClient: PointerClient | undefined
     #connected = false
@@ -57,36 +51,22 @@ class WebSocketMouseDataProvider extends MouseDataProvider {
     destroy(): void {
         this.#connected && this.#pointerClient?.stop();
     }
-
-    toggle(enabled: boolean): void {
-        if (!this.#connected) {
-            enabled = false;
-        }
-
-        enabled ? this.mkbHandler.start() : this.mkbHandler.stop();
-        this.mkbHandler.waitForMouseData(!enabled);
-    }
 }
 
 class PointerLockMouseDataProvider extends MouseDataProvider {
-    init(): void {
-        document.addEventListener('pointerlockchange', this.#onPointerLockChange);
-        document.addEventListener('pointerlockerror', this.#onPointerLockError);
-    }
+    init(): void {}
 
     start(): void {
-        if (!document.pointerLockElement) {
-            document.body.requestPointerLock();
-        }
-
         window.addEventListener('mousemove', this.#onMouseMoveEvent);
         window.addEventListener('mousedown', this.#onMouseEvent);
         window.addEventListener('mouseup', this.#onMouseEvent);
-        window.addEventListener('wheel', this.#onWheelEvent);
+        window.addEventListener('wheel', this.#onWheelEvent, {passive: false});
         window.addEventListener('contextmenu', this.#disableContextMenu);
     }
 
     stop(): void {
+        document.pointerLockElement && document.exitPointerLock();
+
         window.removeEventListener('mousemove', this.#onMouseMoveEvent);
         window.removeEventListener('mousedown', this.#onMouseEvent);
         window.removeEventListener('mouseup', this.#onMouseEvent);
@@ -94,32 +74,7 @@ class PointerLockMouseDataProvider extends MouseDataProvider {
         window.removeEventListener('contextmenu', this.#disableContextMenu);
     }
 
-    destroy(): void {
-        document.removeEventListener('pointerlockchange', this.#onPointerLockChange);
-        document.removeEventListener('pointerlockerror', this.#onPointerLockError);
-    }
-
-    toggle(enabled: boolean): void {
-        enabled ? document.pointerLockElement && this.mkbHandler.start() : this.mkbHandler.stop();
-
-        if (enabled) {
-            !document.pointerLockElement && this.mkbHandler.waitForMouseData(true);
-        } else {
-            this.mkbHandler.waitForMouseData(false);
-            document.pointerLockElement && document.exitPointerLock();
-        }
-    }
-
-    #onPointerLockChange = () => {
-        if (this.mkbHandler.isEnabled() && !document.pointerLockElement) {
-            this.mkbHandler.stop();
-        }
-    }
-
-    #onPointerLockError = (e: Event) => {
-        console.log(e);
-        this.stop();
-    }
+    destroy(): void {}
 
     #onMouseMoveEvent = (e: MouseEvent) => {
         this.mkbHandler.handleMouseMove({
@@ -132,10 +87,9 @@ class PointerLockMouseDataProvider extends MouseDataProvider {
         e.preventDefault();
 
         const isMouseDown = e.type === 'mousedown';
-        const key = KeyHelper.getKeyFromEvent(e);
         const data: MkbMouseClick = {
-            key: key,
-            pressed: isMouseDown
+            mouseButton: e.button,
+            pressed: isMouseDown,
         };
 
         this.mkbHandler.handleMouseClick(data);
@@ -147,7 +101,12 @@ class PointerLockMouseDataProvider extends MouseDataProvider {
             return;
         }
 
-        if (this.mkbHandler.handleMouseWheel({key})) {
+        const data: MkbMouseWheel = {
+            vertical: e.deltaY,
+            horizontal: e.deltaX,
+        };
+
+        if (this.mkbHandler.handleMouseWheel(data)) {
             e.preventDefault();
         }
     }
@@ -159,14 +118,14 @@ class PointerLockMouseDataProvider extends MouseDataProvider {
 This class uses some code from Yuzu emulator to handle mouse's movements
 Source: https://github.com/yuzu-emu/yuzu-mainline/blob/master/src/input_common/drivers/mouse.cpp
 */
-export class MkbHandler {
-    static #instance: MkbHandler;
-    static get INSTANCE() {
-        if (!MkbHandler.#instance) {
-            MkbHandler.#instance = new MkbHandler();
+export class EmulatedMkbHandler extends MkbHandler {
+    static #instance: EmulatedMkbHandler;
+    public static getInstance(): EmulatedMkbHandler {
+        if (!EmulatedMkbHandler.#instance) {
+            EmulatedMkbHandler.#instance = new EmulatedMkbHandler();
         }
 
-        return MkbHandler.#instance;
+        return EmulatedMkbHandler.#instance;
     }
 
     #CURRENT_PRESET_DATA = MkbPreset.convert(MkbPreset.DEFAULT_PRESET);
@@ -178,7 +137,7 @@ export class MkbHandler {
     static VIRTUAL_GAMEPAD_ID = 'Xbox 360 Controller';
 
     #VIRTUAL_GAMEPAD = {
-            id: MkbHandler.VIRTUAL_GAMEPAD_ID,
+            id: EmulatedMkbHandler.VIRTUAL_GAMEPAD_ID,
             index: 3,
             connected: false,
             hapticActuators: null,
@@ -203,6 +162,8 @@ export class MkbHandler {
 
     #$message?: HTMLElement;
 
+    #escKeyDownTime: number = -1;
+
     #STICK_MAP: {[key in GamepadKey]?: [GamepadKey[], number, number]};
     #LEFT_STICK_X: GamepadKey[] = [];
     #LEFT_STICK_Y: GamepadKey[] = [];
@@ -210,6 +171,8 @@ export class MkbHandler {
     #RIGHT_STICK_Y: GamepadKey[] = [];
 
     constructor() {
+        super();
+
         this.#STICK_MAP = {
             [GamepadKey.LS_LEFT]: [this.#LEFT_STICK_X, 0, -1],
             [GamepadKey.LS_RIGHT]: [this.#LEFT_STICK_X, 0, 1],
@@ -307,20 +270,34 @@ export class MkbHandler {
         const isKeyDown = e.type === 'keydown';
 
         // Toggle MKB feature
-        if (isKeyDown) {
-            if (e.code === 'F8') {
+        if (e.code === 'F8') {
+            if (!isKeyDown) {
                 e.preventDefault();
                 this.toggle();
-                return;
-            } else if (e.code === 'Escape') {
-                e.preventDefault();
-                this.#enabled && this.stop();
-                return;
             }
 
-            if (!this.#isPolling) {
-                return;
+            return;
+        }
+
+        // Hijack the Esc button
+        if (e.code === 'Escape') {
+            e.preventDefault();
+
+            // Hold the Esc for 1 second to disable MKB
+            if (this.#enabled && isKeyDown) {
+                if (this.#escKeyDownTime === -1) {
+                    this.#escKeyDownTime = performance.now();
+                } else if (performance.now() - this.#escKeyDownTime >= 1000) {
+                    this.stop();
+                }
+            } else {
+                this.#escKeyDownTime = -1;
             }
+            return;
+        }
+
+        if (!this.#isPolling) {
+            return;
         }
 
         const buttonIndex = this.#CURRENT_PRESET_DATA.mapping[e.code || e.key]!;
@@ -347,11 +324,24 @@ export class MkbHandler {
     }
 
     handleMouseClick = (data: MkbMouseClick) => {
-        if (!data || !data.key) {
+        let mouseButton;
+        if (typeof data.mouseButton !== 'undefined') {
+            mouseButton = data.mouseButton;
+        } else if (typeof data.pointerButton !== 'undefined') {
+            mouseButton = PointerToMouseButton[data.pointerButton as keyof typeof PointerToMouseButton];
+        }
+
+        const keyCode = 'Mouse' + mouseButton;
+        const key = {
+            code: keyCode,
+            name: KeyHelper.codeToKeyName(keyCode),
+        };
+
+        if (!key.name) {
             return;
         }
 
-        const buttonIndex = this.#CURRENT_PRESET_DATA.mapping[data.key.code]!;
+        const buttonIndex = this.#CURRENT_PRESET_DATA.mapping[key.code]!;
         if (typeof buttonIndex === 'undefined') {
             return;
         }
@@ -379,9 +369,9 @@ export class MkbHandler {
         if (length !== 0 && length < deadzoneCounterweight) {
             x *= deadzoneCounterweight / length;
             y *= deadzoneCounterweight / length;
-        } else if (length > MkbHandler.MAXIMUM_STICK_RANGE) {
-            x *= MkbHandler.MAXIMUM_STICK_RANGE / length;
-            y *= MkbHandler.MAXIMUM_STICK_RANGE / length;
+        } else if (length > EmulatedMkbHandler.MAXIMUM_STICK_RANGE) {
+            x *= EmulatedMkbHandler.MAXIMUM_STICK_RANGE / length;
+            y *= EmulatedMkbHandler.MAXIMUM_STICK_RANGE / length;
         }
 
         const analog = mouseMapTo === MouseMapTo.LS ? GamepadStick.LEFT : GamepadStick.RIGHT;
@@ -389,16 +379,32 @@ export class MkbHandler {
     }
 
     handleMouseWheel = (data: MkbMouseWheel): boolean => {
-        if (!data || !data.key) {
+        let code = '';
+        if (data.vertical < 0) {
+            code = WheelCode.SCROLL_UP;
+        } else if (data.vertical > 0) {
+            code = WheelCode.SCROLL_DOWN;
+        } else if (data.horizontal < 0) {
+            code = WheelCode.SCROLL_LEFT;
+        } else if (data.horizontal > 0) {
+            code = WheelCode.SCROLL_RIGHT;
+        }
+
+        if (!code) {
             return false;
         }
 
-        const buttonIndex = this.#CURRENT_PRESET_DATA.mapping[data.key.code]!;
+        const key = {
+            code: code,
+            name: KeyHelper.codeToKeyName(code),
+        };
+
+        const buttonIndex = this.#CURRENT_PRESET_DATA.mapping[key.code]!;
         if (typeof buttonIndex === 'undefined') {
             return false;
         }
 
-        if (this.#prevWheelCode === null || this.#prevWheelCode === data.key.code) {
+        if (this.#prevWheelCode === null || this.#prevWheelCode === key.code) {
             this.#wheelStoppedTimeout && clearTimeout(this.#wheelStoppedTimeout);
             this.#pressButton(buttonIndex, true);
         }
@@ -418,8 +424,11 @@ export class MkbHandler {
             this.#enabled = !this.#enabled;
         }
 
-        Toast.show(t('mouse-and-keyboard'), t(this.#enabled ? 'enabled' : 'disabled'), {instant: true});
-        this.#mouseDataProvider?.toggle(this.#enabled);
+        if (this.#enabled) {
+            document.body.requestPointerLock();
+        } else {
+            document.pointerLockElement && document.exitPointerLock();
+        }
     }
 
     #getCurrentPreset = (): Promise<MkbStoredPreset> => {
@@ -455,9 +464,97 @@ export class MkbHandler {
         }
     }
 
+    #onDialogShown = () => {
+        document.pointerLockElement && document.exitPointerLock();
+    }
+
+    #initMessage = () => {
+        if (!this.#$message) {
+            this.#$message = CE('div', {'class': 'bx-mkb-pointer-lock-msg bx-gone'},
+                CE('div', {},
+                    CE('p', {}, t('virtual-controller')),
+                    CE('p', {}, t('press-key-to-toggle-mkb', {key: 'F8'})),
+                ),
+
+                CE('div', {'data-type': 'virtual'},
+                    createButton({
+                        style: ButtonStyle.PRIMARY | ButtonStyle.TALL | ButtonStyle.FULL_WIDTH,
+                        label: t('activate'),
+                        onClick: ((e: Event) => {
+                            e.preventDefault();
+                            e.stopPropagation();
+
+                            this.toggle(true);
+                        }).bind(this),
+                    }),
+
+                    CE('div', {},
+                        createButton({
+                            label: t('ignore'),
+                            style: ButtonStyle.GHOST,
+                            onClick: e => {
+                                e.preventDefault();
+                                e.stopPropagation();
+
+                                this.toggle(false);
+                                this.waitForMouseData(false);
+                            },
+                        }),
+
+                        createButton({
+                            label: t('edit'),
+                            onClick: e => {
+                                e.preventDefault();
+                                e.stopPropagation();
+
+                                showStreamSettings('mkb');
+                            },
+                        }),
+                    ),
+                ),
+            );
+        }
+
+        if (!this.#$message.isConnected) {
+            document.documentElement.appendChild(this.#$message);
+        }
+    }
+
+    #onPointerLockChange = () => {
+        if (document.pointerLockElement) {
+            this.start();
+        } else {
+            this.stop();
+        }
+    }
+
+    #onPointerLockError = (e: Event) => {
+        console.log(e);
+        this.stop();
+    }
+
+    #onPointerLockRequested = () => {
+        this.start();
+    }
+
+    #onPointerLockExited = () => {
+        this.#mouseDataProvider?.stop();
+    }
+
+    handleEvent(event: Event) {
+        switch (event.type) {
+            case BxEvent.POINTER_LOCK_REQUESTED:
+                this.#onPointerLockRequested();
+                break;
+            case BxEvent.POINTER_LOCK_EXITED:
+                this.#onPointerLockExited();
+                break;
+        }
+    }
+
     init = () => {
         this.refreshPresetData();
-        this.#enabled = true;
+        this.#enabled = false;
 
         if (AppInterface) {
             this.#mouseDataProvider = new WebSocketMouseDataProvider(this);
@@ -467,48 +564,29 @@ export class MkbHandler {
         this.#mouseDataProvider.init();
 
         window.addEventListener('keydown', this.#onKeyboardEvent);
-
-        if (!this.#$message) {
-            this.#$message = CE('div', {'class': 'bx-mkb-pointer-lock-msg'},
-                CE('div', {},
-                    CE('p', {}, t('mkb-click-to-activate')),
-                    CE('p', {}, t('press-key-to-toggle-mkb', {key: 'F8'})),
-                ),
-
-                CE('div', {},
-                    createButton({
-                        icon: BxIcon.MOUSE_SETTINGS,
-                        label: t('edit'),
-                        style: ButtonStyle.PRIMARY,
-                        onClick: e => {
-                            e.preventDefault();
-                            e.stopPropagation();
-
-                            showStreamSettings('mkb');
-                        },
-                    }),
-
-                    createButton({
-                        label: t('disable'),
-                        onClick: e => {
-                            e.preventDefault();
-                            e.stopPropagation();
-
-                            this.toggle(false);
-                            this.waitForMouseData(false);
-                        },
-                    }),
-                ),
-            );
-
-            this.#$message.addEventListener('click', this.start.bind(this));
-            document.documentElement.appendChild(this.#$message);
-        }
+        window.addEventListener('keyup', this.#onKeyboardEvent);
 
         window.addEventListener(BxEvent.XCLOUD_POLLING_MODE_CHANGED, this.#onPollingModeChanged);
+        window.addEventListener(BxEvent.XCLOUD_DIALOG_SHOWN, this.#onDialogShown);
 
-        this.#$message.classList.add('bx-gone');
-        this.waitForMouseData(true);
+        if (AppInterface) {
+            // Android app doesn't support PointerLock API so we need to use a different method
+            window.addEventListener(BxEvent.POINTER_LOCK_REQUESTED, this);
+            window.addEventListener(BxEvent.POINTER_LOCK_EXITED, this);
+        } else {
+            document.addEventListener('pointerlockchange', this.#onPointerLockChange);
+            document.addEventListener('pointerlockerror', this.#onPointerLockError);
+        }
+
+        this.#initMessage();
+        this.#$message?.classList.add('bx-gone');
+
+        if (AppInterface) {
+            Toast.show(t('press-key-to-toggle-mkb', {key: `<b>F8</b>`}), t('virtual-controller'), {html: true});
+            this.waitForMouseData(false);
+        } else {
+            this.waitForMouseData(true);
+        }
     }
 
     destroy = () => {
@@ -520,6 +598,18 @@ export class MkbHandler {
         document.pointerLockElement && document.exitPointerLock();
 
         window.removeEventListener('keydown', this.#onKeyboardEvent);
+        window.removeEventListener('keyup', this.#onKeyboardEvent);
+
+        if (AppInterface) {
+            window.removeEventListener(BxEvent.POINTER_LOCK_REQUESTED, this);
+            window.removeEventListener(BxEvent.POINTER_LOCK_EXITED, this);
+        } else {
+            document.removeEventListener('pointerlockchange', this.#onPointerLockChange);
+            document.removeEventListener('pointerlockerror', this.#onPointerLockError);
+        }
+
+        window.removeEventListener(BxEvent.XCLOUD_POLLING_MODE_CHANGED, this.#onPollingModeChanged);
+        window.removeEventListener(BxEvent.XCLOUD_DIALOG_SHOWN, this.#onDialogShown);
 
         this.#mouseDataProvider?.destroy();
 
@@ -529,17 +619,17 @@ export class MkbHandler {
     start = () => {
         if (!this.#enabled) {
             this.#enabled = true;
-            Toast.show(t('mouse-and-keyboard'), t('enabled'), {instant: true});
+            Toast.show(t('virtual-controller'), t('enabled'), {instant: true});
         }
 
         this.#isPolling = true;
+        this.#escKeyDownTime = -1;
 
         this.#resetGamepad();
         window.navigator.getGamepads = this.#patchedGetGamepads;
 
         this.waitForMouseData(false);
 
-        window.addEventListener('keyup', this.#onKeyboardEvent);
         this.#mouseDataProvider?.start();
 
         // Dispatch "gamepadconnected" event
@@ -550,36 +640,48 @@ export class MkbHandler {
         BxEvent.dispatch(window, 'gamepadconnected', {
                 gamepad: virtualGamepad,
             });
+
+        window.BX_EXPOSED.stopTakRendering = true;
+
+        Toast.show(t('virtual-controller'), t('enabled'), {instant: true});
     }
 
     stop = () => {
+        this.#enabled = false;
         this.#isPolling = false;
-
-        // Dispatch "gamepaddisconnected" event
-        this.#resetGamepad();
+        this.#escKeyDownTime = -1;
 
         const virtualGamepad = this.#getVirtualGamepad();
-        virtualGamepad.connected = false;
-        virtualGamepad.timestamp = performance.now();
+        if (virtualGamepad.connected) {
+            // Dispatch "gamepaddisconnected" event
+            this.#resetGamepad();
 
-        BxEvent.dispatch(window, 'gamepaddisconnected', {
-                gamepad: virtualGamepad,
-            });
+            virtualGamepad.connected = false;
+            virtualGamepad.timestamp = performance.now();
 
-        window.navigator.getGamepads = this.#nativeGetGamepads;
+            BxEvent.dispatch(window, 'gamepaddisconnected', {
+                    gamepad: virtualGamepad,
+                });
 
-        window.removeEventListener('keyup', this.#onKeyboardEvent);
+            window.navigator.getGamepads = this.#nativeGetGamepads;
+        }
 
         this.waitForMouseData(true);
         this.#mouseDataProvider?.stop();
+
+        // Toast.show(t('virtual-controller'), t('disabled'), {instant: true});
     }
 
     static setupEvents() {
-        getPref(PrefKey.MKB_ENABLED) && (AppInterface || !UserAgent.isMobile()) && window.addEventListener(BxEvent.STREAM_PLAYING, () => {
-            // Enable MKB
-            if (!STATES.currentStream.titleInfo?.details.hasMkbSupport) {
-                BxLogger.info(LOG_TAG, 'Emulate MKB');
-                MkbHandler.INSTANCE.init();
+        window.addEventListener(BxEvent.STREAM_PLAYING, () => {
+            if (STATES.currentStream.titleInfo?.details.hasMkbSupport) {
+                // Enable native MKB in Android app
+                if (AppInterface && getPref(PrefKey.NATIVE_MKB_ENABLED) === 'on') {
+                    AppInterface && NativeMkbHandler.getInstance().init();
+                }
+            } else if (getPref(PrefKey.MKB_ENABLED) && (AppInterface || !UserAgent.isMobile())) {
+                    BxLogger.info(LOG_TAG, 'Emulate MKB');
+                    EmulatedMkbHandler.getInstance().init();
             }
         });
     }