@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.1.4 → 0.3.0

package/src/Inputs/IInputController.ts

@@ -0,0 +1,17 @@
+/**
+ * The base interface for all input controllers.
+ * Since controllers mostly just register events and handle them the external interface is limited
+ * to register/unregister
+ */
+export interface IInputController {
+    /**
+     * Tells the controller to register itself to the events it needs to operate.
+     */
+    register(): void;
+
+    /**
+     * Tells the cnotroller to unregister from the events it previously registered to.
+     * No behaviour through the controller should happen past this point until register is called again.
+     */
+    unregister(): void;
+}

package/src/Inputs/InputClassesFactory.ts

@@ -1,15 +1,18 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
-import { FakeTouchController } from './FakeTouchController';
 import { KeyboardController } from './KeyboardController';
 import { MouseController } from './MouseController';
+import { MouseControllerLocked } from './MouseControllerLocked';
+import { MouseControllerHovering } from './MouseControllerHovering';
 import { TouchController } from './TouchController';
-import { GamePadController } from './GamepadController';
+import { TouchControllerFake } from './TouchControllerFake';
+import { GamepadController } from './GamepadController';
 import { Config, ControlSchemeType } from '../Config/Config';
 import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
-import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { InputCoordTranslator } from '../Util/InputCoordTranslator';
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
 import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { IInputController } from './IInputController';
 
 /**
  * Class for making and setting up input class types
@@ -17,7 +20,7 @@ import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
 export class InputClassesFactory {
     toStreamerMessagesProvider: StreamMessageController;
     videoElementProvider: VideoPlayer;
-    coordinateConverter: CoordinateConverter;
+    coordinateConverter: InputCoordTranslator;
     activeKeys: ActiveKeys = new ActiveKeys();
 
     /**
@@ -28,7 +31,7 @@ export class InputClassesFactory {
     constructor(
         toStreamerMessagesProvider: StreamMessageController,
         videoElementProvider: VideoPlayer,
-        coordinateConverter: CoordinateConverter
+        coordinateConverter: InputCoordTranslator
     ) {
         this.toStreamerMessagesProvider = toStreamerMessagesProvider;
         this.videoElementProvider = videoElementProvider;
@@ -39,13 +42,13 @@ export class InputClassesFactory {
      * Registers browser key events.
      */
     registerKeyBoard(config: Config) {
-        Logger.Log(Logger.GetStackTrace(), 'Register Keyboard Events', 7);
+        Logger.Info('Register Keyboard Events');
         const keyboardController = new KeyboardController(
             this.toStreamerMessagesProvider,
             config,
             this.activeKeys
         );
-        keyboardController.registerKeyBoardEvents();
+        keyboardController.register();
         return keyboardController;
     }
 
@@ -54,30 +57,25 @@ export class InputClassesFactory {
      * @param controlScheme - if the mouse is either hovering or locked
      */
     registerMouse(controlScheme: ControlSchemeType) {
-        Logger.Log(Logger.GetStackTrace(), 'Register Mouse Events', 7);
-        const mouseController = new MouseController(
-            this.toStreamerMessagesProvider,
-            this.videoElementProvider,
-            this.coordinateConverter,
-            this.activeKeys
-        );
-
-        switch (controlScheme) {
-            case ControlSchemeType.LockedMouse:
-                mouseController.registerLockedMouseEvents(mouseController);
-                break;
-            case ControlSchemeType.HoveringMouse:
-                mouseController.registerHoveringMouseEvents(mouseController);
-                break;
-            default:
-                Logger.Info(
-                    Logger.GetStackTrace(),
-                    'unknown Control Scheme Type Defaulting to Locked Mouse Events'
-                );
-                mouseController.registerLockedMouseEvents(mouseController);
-                break;
+        Logger.Info('Register Mouse Events');
+        let mouseController: MouseController;
+        if (controlScheme == ControlSchemeType.HoveringMouse) {
+            mouseController = new MouseControllerHovering(
+                this.toStreamerMessagesProvider,
+                this.videoElementProvider,
+                this.coordinateConverter,
+                this.activeKeys
+            );
+        } else {
+            mouseController = new MouseControllerLocked(
+                this.toStreamerMessagesProvider,
+                this.videoElementProvider,
+                this.coordinateConverter,
+                this.activeKeys
+            );
         }
 
+        mouseController.register();
         return mouseController;
     }
 
@@ -85,39 +83,34 @@ export class InputClassesFactory {
      * register touch events
      * @param fakeMouseTouch - the faked mouse touch event
      */
-    registerTouch(
-        fakeMouseTouch: boolean,
-        videoElementParentClientRect: DOMRect
-    ) {
-        Logger.Log(Logger.GetStackTrace(), 'Registering Touch', 6);
+    registerTouch(fakeMouseTouch: boolean) {
+        Logger.Info('Registering Touch');
+        let touchController: IInputController;
         if (fakeMouseTouch) {
-            const fakeTouchController = new FakeTouchController(
+            touchController = new TouchControllerFake(
                 this.toStreamerMessagesProvider,
                 this.videoElementProvider,
                 this.coordinateConverter
             );
-            fakeTouchController.setVideoElementParentClientRect(
-                videoElementParentClientRect
-            );
-            return fakeTouchController;
         } else {
-            return new TouchController(
+            touchController = new TouchController(
                 this.toStreamerMessagesProvider,
                 this.videoElementProvider,
                 this.coordinateConverter
             );
         }
+        touchController.register();
+        return touchController;
     }
 
     /**
      * registers a gamepad
      */
     registerGamePad() {
-        Logger.Log(Logger.GetStackTrace(), 'Register Game Pad', 7);
-        const gamePadController = new GamePadController(
-            this.toStreamerMessagesProvider
-        );
-        return gamePadController;
+        Logger.Info('Register Game Pad');
+        const gamepadController = new GamepadController(this.toStreamerMessagesProvider);
+        gamepadController.register();
+        return gamepadController;
     }
 }
 

package/src/Inputs/KeyCodes.ts

@@ -0,0 +1,114 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+interface ICodeToKeyCode {
+    [key: string]: number;
+}
+
+/*
+ * New browser APIs have moved away from KeyboardEvent.keyCode to KeyboardEvent.Code.
+ * For details see: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode#constants_for_keycode_value
+ * We still use old KeyboardEvent.keyCode integers in the UE C++ side, so we need a way to map the new
+ * string-based KeyboardEvent.Code to the old integers.
+ */
+export const CodeToKeyCode: ICodeToKeyCode = Object.freeze({
+    Escape: 27,
+    Digit0: 48,
+    Digit1: 49,
+    Digit2: 50,
+    Digit3: 51,
+    Digit4: 52,
+    Digit5: 53,
+    Digit6: 54,
+    Digit7: 55,
+    Digit8: 56,
+    Digit9: 57,
+    Minus: 173,
+    Equal: 187,
+    Backspace: 8,
+    Tab: 9,
+    KeyQ: 81,
+    KeyW: 87,
+    KeyE: 69,
+    KeyR: 82,
+    KeyT: 84,
+    KeyY: 89,
+    KeyU: 85,
+    KeyI: 73,
+    KeyO: 79,
+    KeyP: 80,
+    BracketLeft: 219,
+    BracketRight: 221,
+    Enter: 13,
+    ControlLeft: 17,
+    KeyA: 65,
+    KeyS: 83,
+    KeyD: 68,
+    KeyF: 70,
+    KeyG: 71,
+    KeyH: 72,
+    KeyJ: 74,
+    KeyK: 75,
+    KeyL: 76,
+    Semicolon: 186,
+    Quote: 222,
+    Backquote: 192,
+    ShiftLeft: 16,
+    Backslash: 220,
+    KeyZ: 90,
+    KeyX: 88,
+    KeyC: 67,
+    KeyV: 86,
+    KeyB: 66,
+    KeyN: 78,
+    KeyM: 77,
+    Comma: 188,
+    Period: 190,
+    Slash: 191,
+    ShiftRight: 253,
+    AltLeft: 18,
+    Space: 32,
+    CapsLock: 20,
+    F1: 112,
+    F2: 113,
+    F3: 114,
+    F4: 115,
+    F5: 116,
+    F6: 117,
+    F7: 118,
+    F8: 119,
+    F9: 120,
+    F10: 121,
+    F11: 122,
+    F12: 123,
+    Pause: 19,
+    ScrollLock: 145,
+    NumpadDivide: 111,
+    NumpadMultiply: 106,
+    NumpadSubtract: 109,
+    NumpadAdd: 107,
+    NumpadDecimal: 110,
+    Numpad9: 105,
+    Numpad8: 104,
+    Numpad7: 103,
+    Numpad6: 102,
+    Numpad5: 101,
+    Numpad4: 100,
+    Numpad3: 99,
+    Numpad2: 98,
+    Numpad1: 97,
+    Numpad0: 96,
+    NumLock: 144,
+    ControlRight: 254,
+    AltRight: 255,
+    Home: 36,
+    End: 35,
+    ArrowUp: 38,
+    ArrowLeft: 37,
+    ArrowRight: 39,
+    ArrowDown: 40,
+    PageUp: 33,
+    PageDown: 34,
+    Insert: 45,
+    Delete: 46,
+    ContextMenu: 93
+});

package/src/Inputs/KeyboardController.ts

@@ -5,206 +5,57 @@ import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
 import { ActiveKeys } from './InputClassesFactory';
 import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
 import { Config, Flags } from '../Config/Config';
-import { EventListenerTracker } from '../Util/EventListenerTracker';
-
-interface ICodeToKeyCode {
-    [key: string]: number;
-}
+import { IInputController } from './IInputController';
+import { CodeToKeyCode } from './KeyCodes';
 
 /**
  * Handles the Keyboard Inputs for the document
  */
-export class KeyboardController {
-    toStreamerMessagesProvider: StreamMessageController;
-    activeKeysProvider: ActiveKeys;
+export class KeyboardController implements IInputController {
+    streamMessageController: StreamMessageController;
+    activeKeys: ActiveKeys;
     config: Config;
 
-    // Utility for keeping track of event handlers and to unregister them.
-    private keyboardEventListenerTracker = new EventListenerTracker();
-
-    /*
-     * New browser APIs have moved away from KeyboardEvent.keyCode to KeyboardEvent.Code.
-     * For details see: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode#constants_for_keycode_value
-     * We still use old KeyboardEvent.keyCode integers in the UE C++ side, so we need a way to map the new
-     * string-based KeyboardEvent.Code to the old integers.
-     */
-    CodeToKeyCode: ICodeToKeyCode = {
-        Escape: 27,
-        Digit0: 48,
-        Digit1: 49,
-        Digit2: 50,
-        Digit3: 51,
-        Digit4: 52,
-        Digit5: 53,
-        Digit6: 54,
-        Digit7: 55,
-        Digit8: 56,
-        Digit9: 57,
-        Minus: 173,
-        Equal: 187,
-        Backspace: 8,
-        Tab: 9,
-        KeyQ: 81,
-        KeyW: 87,
-        KeyE: 69,
-        KeyR: 82,
-        KeyT: 84,
-        KeyY: 89,
-        KeyU: 85,
-        KeyI: 73,
-        KeyO: 79,
-        KeyP: 80,
-        BracketLeft: 219,
-        BracketRight: 221,
-        Enter: 13,
-        ControlLeft: 17,
-        KeyA: 65,
-        KeyS: 83,
-        KeyD: 68,
-        KeyF: 70,
-        KeyG: 71,
-        KeyH: 72,
-        KeyJ: 74,
-        KeyK: 75,
-        KeyL: 76,
-        Semicolon: 186,
-        Quote: 222,
-        Backquote: 192,
-        ShiftLeft: 16,
-        Backslash: 220,
-        KeyZ: 90,
-        KeyX: 88,
-        KeyC: 67,
-        KeyV: 86,
-        KeyB: 66,
-        KeyN: 78,
-        KeyM: 77,
-        Comma: 188,
-        Period: 190,
-        Slash: 191,
-        ShiftRight: 253,
-        AltLeft: 18,
-        Space: 32,
-        CapsLock: 20,
-        F1: 112,
-        F2: 113,
-        F3: 114,
-        F4: 115,
-        F5: 116,
-        F6: 117,
-        F7: 118,
-        F8: 119,
-        F9: 120,
-        F10: 121,
-        F11: 122,
-        F12: 123,
-        Pause: 19,
-        ScrollLock: 145,
-        NumpadDivide: 111,
-        NumpadMultiply: 106,
-        NumpadSubtract: 109,
-        NumpadAdd: 107,
-        NumpadDecimal: 110,
-        Numpad9: 105,
-        Numpad8: 104,
-        Numpad7: 103,
-        Numpad6: 102,
-        Numpad5: 101,
-        Numpad4: 100,
-        Numpad3: 99,
-        Numpad2: 98,
-        Numpad1: 97,
-        Numpad0: 96,
-        NumLock: 144,
-        ControlRight: 254,
-        AltRight: 255,
-        Home: 36,
-        End: 35,
-        ArrowUp: 38,
-        ArrowLeft: 37,
-        ArrowRight: 39,
-        ArrowDown: 40,
-        PageUp: 33,
-        PageDown: 34,
-        Insert: 45,
-        Delete: 46,
-        ContextMenu: 93
-    };
+    onKeyDownListener: (event: KeyboardEvent) => void;
+    onKeyUpListener: (event: KeyboardEvent) => void;
+    onKeyPressListener: (event: KeyboardEvent) => void;
+    onCompositionEndListener: (event: KeyboardEvent) => void;
 
-    /**
-     * @param toStreamerMessagesProvider Stream message provider class object
-     * @param config The applications configuration. We're interested in the suppress browser keys option
-     * @param activeKeysProvider Active keys provider class object
-     */
-    constructor(
-        toStreamerMessagesProvider: StreamMessageController,
-        config: Config,
-        activeKeysProvider: ActiveKeys
-    ) {
-        this.toStreamerMessagesProvider = toStreamerMessagesProvider;
+    constructor(streamMessageController: StreamMessageController, config: Config, activeKeys: ActiveKeys) {
+        this.streamMessageController = streamMessageController;
         this.config = config;
-        this.activeKeysProvider = activeKeysProvider;
-    }
-
-    /**
-     * Registers document keyboard events with the controller
-     */
-    registerKeyBoardEvents() {
-        const compositionEndHandler = (ev: CompositionEvent) => this.handleOnCompositionEnd(ev);
-        const keyDownHandler = (ev: KeyboardEvent) => this.handleOnKeyDown(ev);
-        const keyUpHandler = (ev: KeyboardEvent) => this.handleOnKeyUp(ev);
-        const keyPressHandler = (ev: KeyboardEvent) => this.handleOnKeyPress(ev);
+        this.activeKeys = activeKeys;
 
-        document.addEventListener("compositionend", compositionEndHandler);
-        document.addEventListener("keydown", keyDownHandler);
-        document.addEventListener("keyup", keyUpHandler);
+        this.onKeyDownListener = this.handleOnKeyDown.bind(this);
+        this.onKeyUpListener = this.handleOnKeyUp.bind(this);
+        this.onKeyPressListener = this.handleOnKeyPress.bind(this);
+        this.onCompositionEndListener = this.handleOnCompositionEnd.bind(this);
+    }
 
+    register() {
+        document.addEventListener('compositionend', this.onCompositionEndListener);
+        document.addEventListener('keydown', this.onKeyDownListener);
+        document.addEventListener('keyup', this.onKeyUpListener);
         //This has been deprecated as at Jun 13 2021
-        document.addEventListener("keypress", keyPressHandler);
-
-        this.keyboardEventListenerTracker.addUnregisterCallback(
-            () => document.removeEventListener("compositionend", compositionEndHandler)
-        );
-        this.keyboardEventListenerTracker.addUnregisterCallback(
-            () => document.removeEventListener("keydown", keyDownHandler)
-        );
-        this.keyboardEventListenerTracker.addUnregisterCallback(
-            () => document.removeEventListener("keyup", keyUpHandler)
-        );
-        this.keyboardEventListenerTracker.addUnregisterCallback(
-            () => document.removeEventListener("keypress", keyPressHandler)
-        );
+        document.addEventListener('keypress', this.onKeyPressListener);
     }
 
-    /**
-     * Unregister document keyboard events.
-     */
-    unregisterKeyBoardEvents() {
-        this.keyboardEventListenerTracker.unregisterAll();
+    unregister() {
+        document.removeEventListener('compositionend', this.onCompositionEndListener);
+        document.removeEventListener('keydown', this.onKeyDownListener);
+        document.removeEventListener('keyup', this.onKeyUpListener);
+        document.removeEventListener('keypress', this.onKeyPressListener);
     }
 
-    /**
-     * Handles When a key is down
-     * @param keyboardEvent - Keyboard event
-     */
-    handleOnKeyDown(keyboardEvent: KeyboardEvent) {
+    private handleOnKeyDown(keyboardEvent: KeyboardEvent) {
         const keyCode = this.getKeycode(keyboardEvent);
         if (!keyCode || keyCode === 229) {
             return;
         }
 
-        Logger.Log(
-            Logger.GetStackTrace(),
-            `key down ${keyCode}, repeat = ${keyboardEvent.repeat}`,
-            6
-        );
-        const toStreamerHandlers =
-            this.toStreamerMessagesProvider.toStreamerHandlers;
-        toStreamerHandlers.get('KeyDown')([
-            this.getKeycode(keyboardEvent),
-            keyboardEvent.repeat ? 1 : 0
-        ]);
-        const activeKeys = this.activeKeysProvider.getActiveKeys();
+        const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
+        toStreamerHandlers.get('KeyDown')([this.getKeycode(keyboardEvent), keyboardEvent.repeat ? 1 : 0]);
+        const activeKeys = this.activeKeys.getActiveKeys();
         activeKeys.push(keyCode);
         // Backspace is not considered a keypress in JavaScript but we need it
         // to be so characters may be deleted in a UE text entry field.
@@ -216,66 +67,39 @@ export class KeyboardController {
             );
         }
 
-        if (
-            this.config.isFlagEnabled(Flags.SuppressBrowserKeys) &&
-            this.isKeyCodeBrowserKey(keyCode)
-        ) {
+        if (this.config.isFlagEnabled(Flags.SuppressBrowserKeys) && this.isKeyCodeBrowserKey(keyCode)) {
             keyboardEvent.preventDefault();
         }
     }
 
-    /**
-     * handles when a key is up
-     * @param keyboardEvent - Keyboard event
-     */
-    handleOnKeyUp(keyboardEvent: KeyboardEvent) {
+    private handleOnKeyUp(keyboardEvent: KeyboardEvent) {
         const keyCode = this.getKeycode(keyboardEvent);
         if (!keyCode) {
             return;
         }
 
-        Logger.Log(Logger.GetStackTrace(), `key up ${keyCode}`, 6);
-        const toStreamerHandlers =
-            this.toStreamerMessagesProvider.toStreamerHandlers;
-        toStreamerHandlers.get('KeyUp')([ keyCode ]);
+        const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
+        toStreamerHandlers.get('KeyUp')([keyCode]);
 
-        if (
-            this.config.isFlagEnabled(Flags.SuppressBrowserKeys) &&
-            this.isKeyCodeBrowserKey(keyCode)
-        ) {
+        if (this.config.isFlagEnabled(Flags.SuppressBrowserKeys) && this.isKeyCodeBrowserKey(keyCode)) {
             keyboardEvent.preventDefault();
         }
     }
 
-    /**
-     * Handles when a key is press
-     * @param keyboard - Keyboard Event
-     */
-    handleOnKeyPress(keyboard: KeyboardEvent) {
-        if (!('charCode' in keyboard)) {
-            Logger.Warning(
-                Logger.GetStackTrace(),
-                'KeyboardEvent.charCode is deprecated in this browser, cannot send key press.'
-            );
+    private handleOnKeyPress(keyboardEvent: KeyboardEvent) {
+        const keyCode = this.getKeycode(keyboardEvent);
+        if (!keyCode) {
             return;
         }
 
-        const charCode = keyboard.charCode;
-        Logger.Log(Logger.GetStackTrace(), `key press ${charCode}`, 6);
-
-        const toStreamerHandlers =
-            this.toStreamerMessagesProvider.toStreamerHandlers;
-        toStreamerHandlers.get('KeyPress')([charCode]);
+        const toStreamerHandlers = this.streamMessageController.toStreamerHandlers;
+        toStreamerHandlers.get('KeyPress')([keyCode]);
     }
 
-    /**
-     * Handle whenever composition ends (eg chinese simplified)
-     * @param compositionEvent - the composition event
-     */
-    handleOnCompositionEnd(compositionEvent: CompositionEvent) {
+    private handleOnCompositionEnd(compositionEvent: CompositionEvent) {
         if (compositionEvent.data && compositionEvent.data.length) {
             compositionEvent.data.split('').forEach((char) => {
-                // This keydown, keypress, keyup flow is required to mimic the way characters are 
+                // This keydown, keypress, keyup flow is required to mimic the way characters are
                 // normally triggered
                 this.handleOnKeyDown(
                     new KeyboardEvent('keydown', {
@@ -304,17 +128,16 @@ export class KeyboardController {
      * @param keyboardEvent - Key board Event
      * @returns - the key code of the Key
      */
-    getKeycode(keyboardEvent: KeyboardEvent) {
+    private getKeycode(keyboardEvent: KeyboardEvent) {
         // If we don't have keyCode property because browser API is deprecated then use KeyboardEvent.code instead.
         // See: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode#constants_for_keycode_value
         if (!('keyCode' in keyboardEvent)) {
             // Convert KeyboardEvent.code string into integer-based key code for backwards compatibility reasons.
             const event = keyboardEvent as KeyboardEvent;
-            if (event.code in this.CodeToKeyCode) {
-                return this.CodeToKeyCode[event.code];
+            if (event.code in CodeToKeyCode) {
+                return CodeToKeyCode[event.code];
             } else {
                 Logger.Warning(
-                    Logger.GetStackTrace(),
                     `Keyboard code of ${event.code} is not supported in our mapping, ignoring this key.`
                 );
                 return null;
@@ -323,20 +146,14 @@ export class KeyboardController {
 
         // If we made it here KeyboardEvent.keyCode is still supported so we can safely use it.
 
-        if (
-            keyboardEvent.keyCode === SpecialKeyCodes.shift &&
-            keyboardEvent.code === 'ShiftRight'
-        ) {
+        if (keyboardEvent.keyCode === SpecialKeyCodes.shift && keyboardEvent.code === 'ShiftRight') {
             return SpecialKeyCodes.rightShift;
         } else if (
             keyboardEvent.keyCode === SpecialKeyCodes.control &&
             keyboardEvent.code === 'ControlRight'
         ) {
             return SpecialKeyCodes.rightControl;
-        } else if (
-            keyboardEvent.keyCode === SpecialKeyCodes.alt &&
-            keyboardEvent.code === 'AltRight'
-        ) {
+        } else if (keyboardEvent.keyCode === SpecialKeyCodes.alt && keyboardEvent.code === 'AltRight') {
             return SpecialKeyCodes.rightAlt;
         } else {
             return keyboardEvent.keyCode;
@@ -347,7 +164,7 @@ export class KeyboardController {
      * Browser keys do not have a charCode so we only need to test keyCode.
      * @param keyCode - the browser keycode number
      */
-    isKeyCodeBrowserKey(keyCode: number) {
+    private isKeyCodeBrowserKey(keyCode: number) {
         // Function keys or tab key are considered "browser keys" that we may wish to suppress by preventing them being process by browser.
         return (keyCode >= 112 && keyCode <= 123) || keyCode === 9;
     }