@24i/bigscreen-sdk 0.9.9-alpha.2147

package/packages/driver-xbox/src/DeviceXbox.ts

@@ -0,0 +1,231 @@
+import { DeviceBase, ScreenSaverStatus, VolumeRange } from '@24i/bigscreen-sdk/driver-base';
+import { runAsync } from '@24i/bigscreen-sdk/utils/timers';
+import { generateUuid } from '@24i/bigscreen-sdk/utils/generateUuid';
+import { find } from '@24i/bigscreen-sdk/perf-utils/array';
+import { parseVersionNumberString } from './utils';
+import { DeviceInformation, Windows as IWindows } from './interfaces';
+import { getKeyMap } from './keymap';
+
+declare const Windows: IWindows;
+
+export class DeviceXbox extends DeviceBase {
+    keyMap = getKeyMap();
+
+    private lastConnectionStatus: boolean | undefined;
+
+    private deviceInformation: DeviceInformation | undefined;
+
+    // MARK: initialization
+
+    async initDevice() {
+        this.initNetworkChangeListener();
+        this.initVisibilityChangeListener();
+        this.initMouseActiveListener();
+    }
+
+    initNetworkChangeListener() {
+        Windows.Networking.Connectivity.NetworkInformation.onnetworkstatuschanged = () => {
+            this.checkNetworkStatus();
+        };
+    }
+
+    setConnectionStatus(isConnected: boolean) {
+        if (this.lastConnectionStatus !== isConnected) {
+            this.triggerEvent('networkchange', { isConnected });
+        }
+        this.lastConnectionStatus = isConnected;
+    }
+
+    checkNetworkStatus() {
+        const { NetworkInformation, NetworkConnectivityLevel } = Windows.Networking.Connectivity;
+        const internetConnectionProfile = NetworkInformation.getInternetConnectionProfile();
+        if (!internetConnectionProfile) {
+            this.setConnectionStatus(false);
+            return false;
+        }
+        const connectivityLevel = internetConnectionProfile.getNetworkConnectivityLevel();
+        switch (connectivityLevel) {
+            case NetworkConnectivityLevel.internetAccess:
+                this.setConnectionStatus(true);
+                return true;
+            case NetworkConnectivityLevel.none:
+            case NetworkConnectivityLevel.localAccess:
+            case NetworkConnectivityLevel.constrainedInternetAccess:
+            default:
+                this.setConnectionStatus(false);
+                return false;
+        }
+    }
+
+    initVisibilityChangeListener() {
+        document.addEventListener('visibilitychange', () => {
+            this.triggerEvent('visibilitychange', {
+                isVisible: document.visibilityState === 'visible',
+            });
+        });
+    }
+
+    initMouseActiveListener() {
+        document.addEventListener('mousemove', this.onMouseActive);
+    }
+
+    onMouseActive = () => {
+        document.removeEventListener('mousemove', this.onMouseActive);
+        document.addEventListener('keydown', this.onMouseInactive, true);
+        this.isMouseActive = true;
+        this.triggerEvent('mouseactive', { isMouseActive: true });
+    };
+
+    onMouseInactive = (event: KeyboardEvent) => {
+        if (!this.isDirectionalArrow(event)) return;
+        document.removeEventListener('keydown', this.onMouseInactive);
+        this.initMouseActiveListener();
+
+        // to let other handlers to use this property before change
+        runAsync(() => {
+            this.isMouseActive = false;
+        });
+        this.triggerEvent('mouseactive', { isMouseActive: false });
+    };
+
+    exit() {
+        window.open('', '_self')?.close();
+    }
+
+    reboot() {
+        window.location.reload();
+    }
+
+    private getDeviceInformation() {
+        if (!this.deviceInformation) {
+            const { EasClientDeviceInformation } = Windows.Security.ExchangeActiveSyncProvisioning;
+            this.deviceInformation = new EasClientDeviceInformation();
+        }
+        return this.deviceInformation;
+    }
+
+    async getManufacturerName() {
+        const deviceInformation = this.getDeviceInformation();
+        return deviceInformation.systemManufacturer;
+    }
+
+    async getPlatformName() {
+        const deviceInformation = this.getDeviceInformation();
+        return deviceInformation.operatingSystem;
+    }
+
+    async getPlatformVersion() {
+        const deviceInformation = this.getDeviceInformation();
+        return deviceInformation.systemFirmwareVersion;
+    }
+
+    async getDeviceName() {
+        const deviceInformation = this.getDeviceInformation();
+        return deviceInformation.systemProductName;
+    }
+
+    async getModelName() {
+        const deviceInformation = this.getDeviceInformation();
+        return deviceInformation.systemSku;
+    }
+
+    async getFirmware() {
+        const { deviceFamilyVersion } = Windows.System.Profile.AnalyticsInfo.versionInfo;
+        return parseVersionNumberString(deviceFamilyVersion);
+    }
+
+    async is4KSupported() {
+        return false;
+    }
+
+    async is8KSupported() {
+        return false;
+    }
+
+    async getUuid() {
+        const currentApplicationData = Windows.Storage.ApplicationData.current;
+        let uuid = currentApplicationData.localSettings.values.storedUuid;
+        if (!uuid) {
+            uuid = generateUuid();
+            currentApplicationData.localSettings.values.storedUuid = uuid;
+        }
+        return uuid;
+    }
+
+    async getVolume() {
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setVolume(volumePercentage: number) {
+        // not supported on UWP platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async mute(mute: boolean) {
+        // not supported on UWP platform
+    }
+
+    async isMute() {
+        return false;
+    }
+
+    async getScreenSaver() {
+        // not supported on UWP platform
+        return { enabled: false };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setScreenSaver(status: ScreenSaverStatus) {
+        // not supported on UWP platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string) {
+        // not supported on UWP platform
+        return false;
+    }
+
+    async getConnectionType() {
+        this.checkNetworkStatus();
+        if (!this.isNetworkConnected) {
+            return 'none';
+        }
+        const { NetworkInformation } = Windows.Networking.Connectivity;
+        const internetConnectionProfile = NetworkInformation.getInternetConnectionProfile();
+        if (internetConnectionProfile) {
+            if (internetConnectionProfile.isWlanConnectionProfile) {
+                return 'wifi';
+            }
+            return 'cable';
+        }
+        return 'unknown';
+    }
+
+    async isNetworkConnected() {
+        return this.checkNetworkStatus();
+    }
+
+    async getLocalIP() {
+        const { NetworkInformation } = Windows.Networking.Connectivity;
+        const internetConnectionProfile = NetworkInformation.getInternetConnectionProfile();
+        if (internetConnectionProfile?.networkAdapter) {
+            const { networkAdapterId } = internetConnectionProfile.networkAdapter;
+            const hostNames = NetworkInformation.getHostNames();
+            const hostName = find(hostNames, (value) => (
+                networkAdapterId === value.ipInformation?.networkAdapter.networkAdapterId
+            ));
+            return hostName?.canonicalName ?? '';
+        }
+        return '';
+    }
+
+    async getMacAddress() {
+        // Xbox platform does not allow to obtain the MAC address
+        return '';
+    }
+
+    getDeviceClass(): string {
+        return 'xbox';
+    }
+}

package/packages/driver-xbox/src/index.ts

@@ -0,0 +1 @@
+export { DeviceXbox } from './DeviceXbox';

package/packages/driver-xbox/src/interfaces.ts

@@ -0,0 +1,138 @@
+export interface Windows {
+    Networking: Networking,
+    Security: {
+        ExchangeActiveSyncProvisioning: ExchangeActiveSyncProvisioning,
+    },
+    System: {
+        VirtualKey: IVirtualKey,
+        Profile: {
+            AnalyticsInfo: {
+                versionInfo: {
+                    deviceFamilyVersion: string,
+                },
+            },
+        },
+    },
+    Storage: {
+        ApplicationData: {
+            current: {
+                localSettings: {
+                    values: {
+                        storedUuid: string,
+                    },
+                },
+            },
+        },
+    },
+}
+
+export interface ExchangeActiveSyncProvisioning {
+    EasClientDeviceInformation: EasClientDeviceInformation,
+}
+
+export interface DeviceInformation {
+    friendlyName: string,
+    id: string,
+    operatingSystem: string,
+    systemFirmwareVersion: string,
+    systemHardwareVersion: string,
+    systemManufacturer: string,
+    systemProductName: string,
+    systemSku: string,
+}
+
+export interface EasClientDeviceInformation {
+    new (): DeviceInformation,
+}
+
+export interface NetworkAdapter {
+    networkAdapterId: string,
+}
+
+export interface HostName {
+    ipInformation: {
+        networkAdapter: NetworkAdapter,
+    };
+    canonicalName?: string,
+}
+
+export interface InternetConnectionProfile {
+    networkAdapter: NetworkAdapter,
+    getNetworkConnectivityLevel(): NetworkConnectivityLevel,
+    isWlanConnectionProfile: boolean,
+}
+
+export enum NetworkConnectivityLevel {
+    none, localAccess, constrainedInternetAccess, internetAccess,
+}
+
+export interface Networking {
+    Connectivity: {
+        NetworkInformation: {
+            getHostNames(): HostName[],
+            getInternetConnectionProfile(): InternetConnectionProfile | null,
+            onnetworkstatuschanged(): void,
+        },
+        NetworkConnectivityLevel: typeof NetworkConnectivityLevel,
+    };
+}
+export interface IVirtualKey {
+    left: number,
+    right: number,
+    up: number,
+    down: number,
+    back: number,
+    enter: number,
+    escape: number,
+
+    number0: number,
+    number1: number,
+    number2: number,
+    number3: number,
+    number4: number,
+    number5: number,
+    number6: number,
+    number7: number,
+    number8: number,
+    number9: number,
+    numberPad0: number,
+    numberPad1: number,
+    numberPad2: number,
+    numberPad3: number,
+    numberPad4: number,
+    numberPad5: number,
+    numberPad6: number,
+    numberPad7: number,
+    numberPad8: number,
+    numberPad9: number,
+
+    pageUp: number,
+    pageDown: number,
+
+    gamepadLeftThumbstickUp : number,
+    gamepadRightThumbstickUp: number,
+    gamepadLeftThumbstickDown: number,
+    gamepadRightThumbstickDown: number,
+    gamepadLeftThumbstickLeft: number,
+    gamepadRightThumbstickLeft: number,
+    gamepadLeftThumbstickRight: number,
+    gamepadRightThumbstickRight: number,
+    gamepadLeftThumbstickPush: number,
+    gamepadRightThumbstickPush: number,
+    GamepadLeftShoulder: number,
+    GamepadLeftTrigger: number,
+    GamepadRightShoulder: number,
+    GamepadRightTrigger: number,
+    gamepadA: number,
+    gamepadB: number,
+    gamepadDPadLeft: number,
+    gamepadDPadRight: number,
+    gamepadDPadUp: number,
+    gamepadDPadDown: number,
+}
+
+declare global {
+    interface Window {
+        Windows: Windows,
+    }
+}

package/packages/driver-xbox/src/keymap.ts

@@ -0,0 +1,96 @@
+/**
+ * https://docs.microsoft.com/en-us/uwp/api/windows.system.virtualkey?view=winrt-22000
+ */
+import { KeyMap } from '@24i/bigscreen-sdk/driver-base';
+
+export const getKeyMap = () => {
+    const { VirtualKey } = window.Windows?.System;
+    KeyMap.overrideValues({
+        LEFT: {
+            keyCode: VirtualKey.left,
+            alternativeKeyCodes: [
+                VirtualKey.gamepadDPadLeft,
+                VirtualKey.gamepadLeftThumbstickLeft,
+                VirtualKey.gamepadRightThumbstickLeft,
+            ],
+        },
+        RIGHT: {
+            keyCode: VirtualKey.right,
+            alternativeKeyCodes: [
+                VirtualKey.gamepadDPadRight,
+                VirtualKey.gamepadLeftThumbstickRight,
+                VirtualKey.gamepadRightThumbstickRight,
+            ],
+        },
+        UP: {
+            keyCode: VirtualKey.up,
+            alternativeKeyCodes: [
+                VirtualKey.gamepadDPadUp,
+                VirtualKey.gamepadLeftThumbstickUp,
+                VirtualKey.gamepadRightThumbstickUp,
+            ],
+        },
+        DOWN: {
+            keyCode: VirtualKey.down,
+            alternativeKeyCodes: [
+                VirtualKey.gamepadDPadDown,
+                VirtualKey.gamepadLeftThumbstickDown,
+                VirtualKey.gamepadRightThumbstickDown,
+            ],
+        },
+        BACK: {
+            keyCode: VirtualKey.back,
+            alternativeKeyCodes: [
+                VirtualKey.gamepadB,
+            ],
+        },
+        ENTER: {
+            keyCode: VirtualKey.enter,
+            alternativeKeyCodes: [
+                VirtualKey.gamepadA,
+                VirtualKey.escape,
+            ],
+        },
+        ESC: { keyCode: VirtualKey.escape },
+        NUM_0: { keyCode: VirtualKey.number0 },
+        NUM_1: { keyCode: VirtualKey.number1 },
+        NUM_2: { keyCode: VirtualKey.number2 },
+        NUM_3: { keyCode: VirtualKey.number3 },
+        NUM_4: { keyCode: VirtualKey.number4 },
+        NUM_5: { keyCode: VirtualKey.number5 },
+        NUM_6: { keyCode: VirtualKey.number6 },
+        NUM_7: { keyCode: VirtualKey.number7 },
+        NUM_8: { keyCode: VirtualKey.number8 },
+        NUM_9: { keyCode: VirtualKey.number9 },
+        KP_0: { keyCode: VirtualKey.numberPad0 },
+        KP_1: { keyCode: VirtualKey.numberPad1 },
+        KP_2: { keyCode: VirtualKey.numberPad2 },
+        KP_3: { keyCode: VirtualKey.numberPad3 },
+        KP_4: { keyCode: VirtualKey.numberPad4 },
+        KP_5: { keyCode: VirtualKey.numberPad5 },
+        KP_6: { keyCode: VirtualKey.numberPad6 },
+        KP_7: { keyCode: VirtualKey.numberPad7 },
+        KP_8: { keyCode: VirtualKey.numberPad8 },
+        KP_9: { keyCode: VirtualKey.numberPad9 },
+        CHANNEL_UP: { keyCode: VirtualKey.pageUp },
+        CHANNEL_DOWN: { keyCode: VirtualKey.pageDown },
+        // Xbox specials
+        GAMEPAD_LEFT_THUMBSTICK_UP: { keyCode: VirtualKey.gamepadLeftThumbstickUp },
+        GAMEPAD_RIGHT_THUMBSTICK_UP: { keyCode: VirtualKey.gamepadRightThumbstickUp },
+        GAMEPAD_LEFT_THUMBSTICK_DOWN: { keyCode: VirtualKey.gamepadLeftThumbstickDown },
+        GAMEPAD_RIGHT_THUMBSTICK_DOWN: { keyCode: VirtualKey.gamepadRightThumbstickDown },
+        GAMEPAD_LEFT_THUMBSTICK_LEFT: { keyCode: VirtualKey.gamepadLeftThumbstickLeft },
+        GAMEPAD_RIGHT_THUMBSTICK_LEFT: { keyCode: VirtualKey.gamepadRightThumbstickLeft },
+        GAMEPAD_LEFT_THUMBSTICK_RIGHT: { keyCode: VirtualKey.gamepadLeftThumbstickRight },
+        GAMEPAD_RIGHT_THUMBSTICK_RIGHT: { keyCode: VirtualKey.gamepadRightThumbstickRight },
+        GAMEPAD_RIGHT_THUMBSTICK_PUSH: { keyCode: VirtualKey.gamepadLeftThumbstickPush },
+        GAMEPAD_LEFT_THUMBSTICK_PUSH: { keyCode: VirtualKey.gamepadRightThumbstickPush },
+        LEFT_BUMPER: { keyCode: VirtualKey.GamepadLeftShoulder },
+        LEFT_TRIGGER: { keyCode: VirtualKey.GamepadLeftTrigger },
+        RIGHT_BUMPER: { keyCode: VirtualKey.GamepadRightShoulder },
+        RIGHT_TRIGGER: { keyCode: VirtualKey.GamepadRightTrigger },
+        GAMEPAD_A: { keyCode: VirtualKey.gamepadA },
+        GAMEPAD_B: { keyCode: VirtualKey.gamepadB }, // Backspace
+    });
+    return KeyMap.generateKeyCodeKeyMap();
+};

package/packages/driver-xbox/src/utils.ts

@@ -0,0 +1,23 @@
+import { map } from '@24i/bigscreen-sdk/perf-utils/array';
+
+const HEXADECIMAL = 16;
+const FIRMWARE_STRING_LENGTH_IN_BYTES = 16;
+const VERSION_CHUNK_SIZE_IN_BYTES = 4;
+const CHUNKIFY_REGEX = new RegExp(`[0-9A-F]{${VERSION_CHUNK_SIZE_IN_BYTES}}`, 'g');
+
+/**
+ * Parses and formats string version number.
+ * @param decimalIntegerString version as decimal integer string (e.g.: 2814750438211613)
+ * @returns version as formatted string (e.g.: 10.0.10240.16405)
+ */
+export const parseVersionNumberString = (decimalIntegerString: string) => {
+    const decimalInteger = parseInt(decimalIntegerString, 10);
+    if (Number.isNaN(decimalInteger)) return '';
+    const hexString = decimalInteger
+        .toString(HEXADECIMAL)
+        .toUpperCase()
+        .padStart(FIRMWARE_STRING_LENGTH_IN_BYTES, '0');
+    const versionChunks = hexString.match(CHUNKIFY_REGEX);
+    if (!versionChunks) return '';
+    return map(versionChunks, (chunk) => parseInt(chunk, HEXADECIMAL)).join('.');
+};