@24i/bigscreen-sdk 1.0.4 → 1.0.5-4.alpha-2832

package/packages/driver-androidtv/src/DeviceAndroidTV.ts

@@ -0,0 +1,262 @@
+import {
+    DeviceBase,
+    ConnectionType,
+    ScreenSaverStatus,
+    VolumeRange,
+    IAPSuccessPayload,
+    IAPPurchaseProductData,
+} from '@24i/bigscreen-sdk/driver-base';
+import { IJavaScriptBridge, DeviceInfo } from './types';
+import { getFirmware } from './formatUserAgent';
+import { getKeyMap, AndroidKeyMap } from './keymap';
+
+interface CustomKeyboardEvent extends KeyboardEvent {
+    /** Flag indicating that the driver has already re-emitted this event. */
+    bigscreenSdkRelaunched?: boolean;
+}
+
+declare global {
+    interface Window extends IJavaScriptBridge {}
+}
+
+/**
+ * Android TV driver implementing API of Android TV Bridge.
+ *
+ * See https://github.com/24i/prd-smart-ott-androidtv
+ */
+export class DeviceAndroidTV extends DeviceBase {
+    keyMap = getKeyMap();
+
+    deviceInfo = window.JavaScriptBridge.bridgeJavaScriptToAndroid_GetDeviceInfo();
+
+    platformInfo: DeviceInfo = this.deviceInfo ? JSON.parse(this.deviceInfo) : '';
+
+    firmware = getFirmware(navigator.userAgent);
+
+    async initDevice(): Promise<void> {
+        this.initKeydownListener();
+        this.initKeyupListener();
+        this.initNetworkChangeListener();
+    }
+
+    initKeydownListener() {
+        window.addEventListener('keydown', this.relaunchKeyEvent, true);
+    }
+
+    initKeyupListener() {
+        window.addEventListener('keyup', this.relaunchKeyEvent, true);
+    }
+
+    /**
+     * Handles keydown/up events for the BACK, FF, REW, STOP, PLAY key which are
+     * dispatched on the document from the Android TV Bridge. We must catch them
+     * and re-emit them properly on the active (focused) element in the DOM tree.
+     * @param event keyboard event
+     */
+    // eslint-disable-next-line complexity
+    relaunchKeyEvent = (event: CustomKeyboardEvent) => {
+        if (event.bigscreenSdkRelaunched) { // prevent to relaunch event in loop
+            return;
+        }
+
+        const { key } = event;
+        let { keyCode } = event;
+
+        // KeyCodes collisions for some key sent from Android wrapper or JavaScript (webView)
+        if (
+            key === 'u' // keyCode 85, same like PLAYPAUSE
+            || key === 'v' // keyCode 86, same like STOP
+            || key === 'y' // keyCode 89, same like REW
+            || key === 'z' // keyCode 90, same like FF
+        ) {
+            return;
+        }
+
+        /**
+         * Remap KeyCode by its key value.
+         * On Android all colors keys and some others coming with "0" keyCode.
+         */
+        if (key === 'ColorF0Red') keyCode = this.keyMap.RED;
+        if (key === 'ColorF1Green') keyCode = this.keyMap.GREEN;
+        if (key === 'ColorF2Yellow') keyCode = this.keyMap.YELLOW;
+        if (key === 'ColorF3Blue') keyCode = this.keyMap.BLUE;
+        if (key === 'ClosedCaptionToggle') keyCode = this.keyMap.SUBTITLES;
+        if (keyCode === AndroidKeyMap.STOP) keyCode = this.keyMap.STOP;
+        if (keyCode === AndroidKeyMap.PAUSE) keyCode = this.keyMap.PAUSE;
+
+        if (keyCode === this.keyMap.BACK
+            || keyCode === this.keyMap.STOP
+            || keyCode === this.keyMap.FF
+            || keyCode === this.keyMap.REW
+            || keyCode === this.keyMap.PLAYPAUSE
+            || keyCode === this.keyMap.PLAY
+            || keyCode === this.keyMap.RED
+            || keyCode === this.keyMap.GREEN
+            || keyCode === this.keyMap.YELLOW
+            || keyCode === this.keyMap.BLUE
+            || keyCode === this.keyMap.SUBTITLES
+        ) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            const newEvent = new KeyboardEvent(event.type, {
+                keyCode, bubbles: true, cancelable: true, composed: true,
+            }) as CustomKeyboardEvent;
+            newEvent.bigscreenSdkRelaunched = true;
+            document.activeElement?.dispatchEvent(newEvent);
+        }
+    };
+
+    initNetworkChangeListener() {
+        window.addEventListener('online', () => {
+            this.triggerEvent('networkchange', { isConnected: true });
+        });
+        window.addEventListener('offline', () => {
+            this.triggerEvent('networkchange', { isConnected: false });
+        });
+    }
+
+    reboot(): void {
+        let rootPath = '';
+        const splitUrl = window.location.href.split('#');
+        if (splitUrl.length > 1) rootPath = splitUrl[0];
+        window.location.href = rootPath;
+    }
+
+    exit(): void {
+        window.JavaScriptBridge.bridgeJavaScriptToAndroid_Back();
+    }
+
+    async getManufacturerName(): Promise<string> {
+        return this.platformInfo.deviceBrand || '';
+    }
+
+    async getPlatformName(): Promise<string> {
+        return 'AndroidTV';
+    }
+
+    async getPlatformVersion(): Promise<string> {
+        return this.platformInfo.osVersion || '';
+    }
+
+    async getDeviceName(): Promise<string> {
+        const modelName = await this.getModelName();
+        const manufacturerName = await this.getManufacturerName();
+        return `AndroidTV ${manufacturerName} ${modelName}`.trim();
+    }
+
+    async getModelName(): Promise<string> {
+        return this.platformInfo.deviceModel || '';
+    }
+
+    async getFirmware(): Promise<string> {
+        return this.firmware || '';
+    }
+
+    async is4KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async is8KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async getUuid(): Promise<string> {
+        return this.getBaseUuid();
+    }
+
+    async getAdInfo() {
+        let adId = null;
+        let latEnabled = null;
+        const type = 'gaid';
+        try {
+            adId = window.JavaScriptBridge.bridgeJavaScriptToAndroid_GetAdId() ?? null;
+            latEnabled = window.JavaScriptBridge.bridgeJavaScriptToAndroid_GetLimitAdTracking()
+                ?? true;
+        } catch (e) {
+            latEnabled = true;
+            console.error('[DeviceAndroidTV] Failed to getAdInfo', e);
+        }
+        return { adId, type, latEnabled };
+    }
+
+    async getOsLanguage() {
+        try {
+            return window.JavaScriptBridge.bridgeJavaScriptToAndroid_GetOsLanguage() || '';
+        } catch (e) {
+            console.error('[DeviceAndroidTV] Failed to getOsLanguage', e);
+            return '';
+        }
+    }
+
+    async getVolume(): Promise<number> {
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    async getWrapperVersion(): Promise<string> {
+        return this.platformInfo.appVersion;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setVolume(volumePercentage: number): Promise<void> {
+        // not supported on AndroidTV platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async mute(mute: boolean): Promise<void> {
+        // not supported on AndroidTV platform
+    }
+
+    async isMute(): Promise<boolean> {
+        // not supported on AndroidTV platform
+        return false;
+    }
+
+    async getScreenSaver(): Promise<ScreenSaverStatus> {
+        // not supported on AndroidTV platform
+        return { enabled: false };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setScreenSaver(status: ScreenSaverStatus): Promise<void> {
+        // not supported on AndroidTV platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string): Promise<boolean> {
+        // not supported on AndroidTV platform
+        return false;
+    }
+
+    async isNetworkConnected(): Promise<boolean> {
+        return window.navigator.onLine;
+    }
+
+    async getConnectionType(): Promise<ConnectionType> {
+        // not supported on AndroidTV platform
+        return 'unknown';
+    }
+
+    async getLocalIP(): Promise<string> {
+        const ipv4RegExp = /\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b/;
+        const ip = this.platformInfo.ipLocal.toString().match(ipv4RegExp);
+        if (ip) return ip.toString();
+        return '';
+    }
+
+    async getMacAddress(): Promise<string> {
+        // not supported on AndroidTV platform
+        return '';
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async purchaseProduct(data: IAPPurchaseProductData): Promise<IAPSuccessPayload> {
+        // not supported
+        throw new Error('Not supported');
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async cancelSubscription(data: IAPPurchaseProductData): Promise<void> {
+        // not supported
+        throw new Error('Not supported');
+    }
+}

package/packages/driver-androidtv/src/__mocks__/javaScriptBridge.ts

@@ -0,0 +1,45 @@
+import { IJavaScriptBridge } from '../types';
+
+export const mockJavaScriptBridge: IJavaScriptBridge = {
+    JavaScriptBridge: {
+        bridgeJavaScriptToAndroid_GetDeviceInfo: () => (
+            JSON.stringify({
+                deviceBrand: 'Sony',
+                deviceModel: 'BRAVIA 4K 2015',
+                osVersion: '8.0.0',
+                appVersion: '0.0.1',
+                appFlavor: 'appstage-bigscreen',
+                drmKeySystems: '["W3C Clear Key", "Google Widevine"]',
+                ipLocal: '127.0.0.1',
+            })
+        ),
+        bridgeJavaScriptToAndroid_GetAdId: () => 'gaid-id',
+        bridgeJavaScriptToAndroid_GetLimitAdTracking: () => false,
+        bridgeJavaScriptToAndroid_GetOsLanguage: () => '',
+        bridgeJavaScriptToAndroid_GetMediaInfo: () => '{}',
+        bridgeJavaScriptToAndroid_Back: () => {},
+        bridgeJavaScriptToAndroid_ReloadPlayer: () => {},
+        bridgeJavaScriptToAndroid_StopVideo: () => {},
+        bridgeJavaScriptToAndroid_FullScreenVideo: () => {},
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        bridgeJavaScriptToAndroid_SetVideoPath: (url: string) => {},
+        bridgeJavaScriptToAndroid_IsPlaying: () => true,
+        bridgeJavaScriptToAndroid_PauseVideo: () => {},
+        bridgeJavaScriptToAndroid_PlayVideo: () => {},
+        bridgeJavaScriptToAndroid_IsLive: () => false,
+        bridgeJavaScriptToAndroid_GetCurrentTime: () => Date.now(),
+        bridgeJavaScriptToAndroid_GetTotalTime: () => Date.now(),
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        bridgeJavaScriptToAndroid_SeekTo: (milliseconds: number) => {},
+        bridgeJavaScriptToAndroid_getCurrentSubtitleTrack: () => '{}',
+        bridgeJavaScriptToAndroid_getCurrentAudioTrack: () => '{}',
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        bridgeJavaScriptToAndroid_SetTrack: (track: string) => {},
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        bridgeJavaScriptToAndroid_SetAudioTrack: (track: string) => {},
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        bridgeReceiptAmazonIAPValidation: (sku: string) => {},
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        bridgeReceiptAmazonIAPValidated: (receiptId: string) => {},
+    },
+};

package/packages/driver-androidtv/src/formatUserAgent.ts

@@ -0,0 +1,11 @@
+/**
+ * Parses software version of Android TV from user agent string.
+ * @param userAgent User agent string
+ * @returns software version string or undefined if not found. Ex. "QTS1.220504.008"
+ */
+export const getFirmware = (userAgent: string) => {
+    const [
+        , firmware,
+    ] = userAgent.match(/Build\/([^;]*)/) || [] as Array<undefined>;
+    return firmware;
+};

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

@@ -0,0 +1,2 @@
+export { DeviceAndroidTV } from './DeviceAndroidTV';
+export type { IAPErrorEvent, IAPSuccessEvent } from './types';

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

@@ -0,0 +1,27 @@
+/* eslint-disable no-magic-numbers */
+import { KeyMap } from '@24i/bigscreen-sdk/driver-base';
+
+export const getKeyMap = () => {
+    KeyMap.overrideValues({
+        BACK: { keyCode: 4 },
+        STOP: { keyCode: 86 },
+        FF: { keyCode: 90 },
+        REW: { keyCode: 89 },
+        PLAY: { keyCode: 126 },
+        PAUSE: { keyCode: 127 },
+        PLAYPAUSE: { keyCode: 85 },
+        SUBTITLES: { keyCode: 175 },
+    });
+    return KeyMap.generateKeyCodeKeyMap();
+};
+
+/**
+ * For the specific AndroidTV devices like Sony Bravia or Nvidia Shield
+ * there are different KeyCodes for some buttons than on other platforms.
+ * In that case we need to re-map this specific KeyCodes to the
+ * same values as we using in generic KeyMap list for the AndroidTV.
+ */
+export const AndroidKeyMap = {
+    STOP: 178,
+    PAUSE: 85,
+};

package/packages/driver-androidtv/src/types.ts

@@ -0,0 +1,155 @@
+interface JavaScriptBridge {
+    /**
+     * It returns a JSON string with device info.
+     * @return JSON string with the information about the device brand, model and Android version.
+     * Ex. '{"deviceBrand": "Sony", "deviceModel": "BRAVIA 4K 2015", "osVersion": "7.0",
+     * "appFlavor": "appstage-bigscreen", "drmKeySystems": ["Widewine", "W3C ClearKey"],
+     * "ipLocal": "fe80::475:3045:2928:3a32%wlan0127.0.0.1", "appVersion": '0.0.1' }'
+     */
+    bridgeJavaScriptToAndroid_GetDeviceInfo: () => string,
+
+    /**
+     * It returns advertising id.
+     * @return Advertising id or null if not available.
+     */
+    bridgeJavaScriptToAndroid_GetAdId: () => string | null,
+    /**
+     * It returns limit ad tracking status
+     * @return true if limit ad tracking is enabled, false if not and null if not available.
+     */
+    bridgeJavaScriptToAndroid_GetLimitAdTracking: () => boolean | null,
+    /**
+     * It returns the language of the OS.
+     * @return Language of the OS. Ex. "en"
+     */
+    bridgeJavaScriptToAndroid_GetOsLanguage: () => string,
+    /**
+     * It returns media info including statistics
+     */
+    bridgeJavaScriptToAndroid_GetMediaInfo: () => string;
+    /**
+     * It simulates a native Android back press.
+     */
+    bridgeJavaScriptToAndroid_Back: () => void,
+    /**
+     * It reloads the video player
+     */
+    bridgeJavaScriptToAndroid_ReloadPlayer: () => void;
+    /**
+     * It simulates a native Android stop button press.
+     */
+    bridgeJavaScriptToAndroid_StopVideo: () => void;
+    /**
+     * It sets the video to fullscreen mode
+     */
+    bridgeJavaScriptToAndroid_FullScreenVideo: () => void;
+    /**
+     * It sets the video url
+     */
+    bridgeJavaScriptToAndroid_SetVideoPath: (url: string) => void;
+    /**
+     * It returns whether the video is playing
+     */
+    bridgeJavaScriptToAndroid_IsPlaying: () => boolean;
+    /**
+     * It pauses the video
+     */
+    bridgeJavaScriptToAndroid_PauseVideo: () => void;
+    /**
+     * It plays the video
+     */
+    bridgeJavaScriptToAndroid_PlayVideo: () => void;
+    /**
+     * It returns whether the video is live
+     */
+    bridgeJavaScriptToAndroid_IsLive: () => boolean;
+    /**
+     * It returns current time of currently played video
+     */
+    bridgeJavaScriptToAndroid_GetCurrentTime: () => number;
+    /**
+     * It returns total duration of the video
+     */
+    bridgeJavaScriptToAndroid_GetTotalTime: () => number;
+    /**
+     * It seeks the video to specified milliseconds
+     */
+    bridgeJavaScriptToAndroid_SeekTo: (milliseconds: number) => void;
+    /**
+     * It returns current text track
+     */
+    bridgeJavaScriptToAndroid_getCurrentSubtitleTrack: () => string | undefined;
+    /**
+     * It returns current audio track
+     */
+    bridgeJavaScriptToAndroid_getCurrentAudioTrack: () => string | undefined;
+    /**
+     * It sets text track to be shown.
+    */
+    bridgeJavaScriptToAndroid_SetTrack: (track: string) => void;
+    /**
+     * It sets audio track to be used.
+     */
+    bridgeJavaScriptToAndroid_SetAudioTrack: (track: string) => void;
+    /**
+     * It launch in app purchase.
+     */
+    bridgeReceiptAmazonIAPValidation: (sku: string) => void;
+    /**
+     * It validate purchase.
+     */
+    bridgeReceiptAmazonIAPValidated: (receiptId: string) => void;
+}
+
+export type DeviceInfo = {
+    /**
+     * Device brand. Ex. "Sony"
+     */
+    deviceBrand: string,
+    /**
+     * Device model. Ex. "BRAVIA 4K 2015"
+     */
+    deviceModel: string,
+    /**
+     * Android version. Ex. "7.0"
+     */
+    osVersion: string,
+    /**
+     * Android wrapper version. Ex. "0.0.1"
+     */
+    appVersion: string,
+    /**
+     * Android flavor. Ex. "appstage-bigscreen"
+     */
+    appFlavor: string,
+    /**
+     * Underlying player engine name. Ex. "exoplayer"
+     */
+    engineName: string,
+    /**
+     * Version of player engine. Ex. "2.18.1"
+     */
+    engineVersion: string,
+    /**
+     * Android DRM key systems. Ex. ["Widewine", "W3C ClearKey"]
+     */
+    drmKeySystems: Array<string>,
+    /**
+     * Android local IP adress in array Ex. "fe80::475:3045:2928:3a32%wlan0127.0.0.1"
+     */
+    ipLocal: string,
+};
+
+export interface IJavaScriptBridge {
+    JavaScriptBridge: JavaScriptBridge,
+}
+
+export type IAPSuccessEvent = {
+    userId: string;
+    receipt: string;
+    sku: string;
+};
+
+export type IAPErrorEvent = {
+    message: string;
+};

package/packages/driver-base/src/DeviceBase.ts

@@ -1,4 +1,5 @@
 import { Storage } from '@24i/bigscreen-sdk/storage';
+import { config } from '@24i/bigscreen-sdk/runtime-config';
 import { generateUuid } from '@24i/bigscreen-sdk/utils/generateUuid';
 import { EventsManager, IEvents, EventMapType } from '@24i/bigscreen-sdk/events-manager';
 import { isRtl } from '@24i/bigscreen-sdk/i18n';
@@ -7,15 +8,22 @@ import { ScreenSize } from './ScreenSize';
 import { VolumeRange } from './VolumeRange';
 import { KeycodeKeyMap } from './types/KeycodeKeyMap';
 import { DeviceEventMap } from './types/DeviceEvent';
+import { AdInfo } from './types/AdInfo';
 import { ScreenSaverStatus } from './types/ScreenSaverStatus';
 import { ExitOptions } from './types/ExitOptions';
 import { inRange } from './utils';
 import { ErrorTemplate } from './errors';
 import { bindPreventDefaultEvent } from './bindPreventDefaultEvent';
-import { LEFT, RIGHT, UP, DOWN, ENTER, BACK } from './KeyMap';
+import { LEFT, RIGHT, UP, DOWN, ENTER, BACK, ESC } from './KeyMap';
+import { IAPPurchaseProductData, IAPSuccessPayload } from './types/InAppPurchase';
 
 export const STORAGE_UUID_KEY = '__UUID__';
 
+const DEFAULT_POLLING_INTERVAL = 15000;
+const DEFAULT_POLLING_TIMEOUT = 15000;
+
+const CHECKED_URL = '//www.google-analytics.com/__utm.gif';
+
 export abstract class DeviceBase<
     CustomEventMap extends EventMapType = {},
     EventMap extends EventMapType = DeviceEventMap & CustomEventMap,
@@ -41,6 +49,14 @@ export abstract class DeviceBase<
 
     screenSize: ScreenSize = 'unknown';
 
+    pollingInterval: number = DEFAULT_POLLING_INTERVAL;
+
+    pollingTimeout: number = DEFAULT_POLLING_TIMEOUT;
+
+    imageTimeout: number = 0;
+
+    isOffline: boolean = false;
+
     // MARK: Initialization
 
     /**
@@ -52,6 +68,7 @@ export abstract class DeviceBase<
         if (!this.isInitialized) {
             this.bindPreventDefaultEvents(rootElement);
             const initializer = await this.internalInit();
+            this.checkNetworkConnection();
             this.isInitialized = true;
             return initializer;
         }
@@ -71,6 +88,46 @@ export abstract class DeviceBase<
         return this.initializer;
     }
 
+    doOnlineCheck = () => {
+        const protocol = window.location.protocol === 'http:' ? 'http:' : 'https:';
+        const tester = new Image();
+        this.imageTimeout = window.setTimeout(() => {
+            this.connectionNotFound();
+        }, this.pollingTimeout || DEFAULT_POLLING_TIMEOUT);
+        tester.onload = this.connectionFound;
+        tester.onerror = this.connectionNotFound;
+        tester.src = `${protocol}${CHECKED_URL}?ts=${Date.now()}`;
+    };
+
+    connectionFound = () => {
+        window.clearTimeout(this.imageTimeout);
+        if (!this.isOffline) return;
+        this.triggerEvent('networkchange',
+            { isConnected: true } as any);
+        this.isOffline = false;
+    };
+
+    connectionNotFound = () => {
+        window.clearTimeout(this.imageTimeout);
+        if (this.isOffline) return;
+        this.triggerEvent('networkchange',
+            { isConnected: false } as any);
+        this.isOffline = true;
+    };
+
+    checkNetworkConnection() {
+        const networkConfig: any = config.get('network.checkConnection');
+        this.pollingInterval = Number(networkConfig?.pollingInterval);
+        this.pollingTimeout = Number(networkConfig?.pollingTimeout);
+        const enableCheckNetwork: any = Boolean(networkConfig?.enableCheckNetwork) ?? false;
+        if (enableCheckNetwork) {
+            window.setInterval(
+                this.doOnlineCheck,
+                this.pollingInterval || DEFAULT_POLLING_INTERVAL,
+            );
+        }
+    }
+
     // MARK: Interface implemented by individual platform-specific drivers
 
     abstract initDevice(): Promise<void>;
@@ -97,6 +154,10 @@ export abstract class DeviceBase<
 
     abstract getUuid(): Promise<string>;
 
+    abstract getAdInfo(): Promise<AdInfo>;
+
+    abstract getOsLanguage(): Promise<string>;
+
     abstract getVolume(): Promise<number>;
 
     abstract setVolume(volumePercentage: number): Promise<void>;
@@ -119,11 +180,17 @@ export abstract class DeviceBase<
 
     abstract getMacAddress(): Promise<string>;
 
+    abstract purchaseProduct(data: IAPPurchaseProductData): Promise<IAPSuccessPayload>;
+
+    abstract cancelSubscription(data: IAPPurchaseProductData): Promise<void>;
+
     // MARK: Private functions
 
     private bindPreventDefaultEvents(rootElement: HTMLElement) {
         // prevent default to focus the next focusable element of event target
         bindPreventDefaultEvent(rootElement, 'keydown');
+        // prevent default not to lose focus (Seen on Android TV Bridge)
+        bindPreventDefaultEvent(rootElement, 'keyup');
         // prevent default to focus the nearest focusable ancestor of event target
         bindPreventDefaultEvent(rootElement, 'mousedown');
     }
@@ -203,7 +270,7 @@ export abstract class DeviceBase<
     }
 
     isBackOrEscape(event: MouseEvent | KeyboardEvent) {
-        return BACK.is(event as KeyboardEvent);
+        return BACK.is(event as KeyboardEvent) || ESC.is(event as KeyboardEvent);
     }
 
     getDeviceClass() : string {
@@ -215,4 +282,8 @@ export abstract class DeviceBase<
     isMouseUsed() {
         return this.isMouseActive;
     }
+
+    getResolution() {
+        return { width: window.screen?.width, height: window.screen?.height };
+    }
 }

package/packages/driver-base/src/KeyMap/Key.ts

@@ -12,21 +12,25 @@ export class Key {
 
     alternativeKeyCodes: number[];
 
+    key: string;
+
     constructor({
         id,
         code = '',
         keyCode = 0,
         alternativeCodes = [],
         alternativeKeyCodes = [],
+        key = '',
     }: Partial<KeyConfig> = {}) {
         this.id = id!;
         this.code = code;
         this.keyCode = keyCode;
         this.alternativeCodes = alternativeCodes;
         this.alternativeKeyCodes = alternativeKeyCodes;
+        this.key = key;
     }
 
-    is({ keyCode, code }: KeyboardEvent) {
+    is({ keyCode, code, key }: KeyboardEvent) {
         return Boolean(
             code && ( // empty string code means unknown/invalid --> should not compare
                 code === this.code
@@ -35,6 +39,9 @@ export class Key {
             || keyCode && ( // keyCode 0 means unknown/invalid --> should not compare
                 keyCode === this.keyCode
                 || this.alternativeKeyCodes.length && includes(this.alternativeKeyCodes, keyCode)
+            )
+            || key && ( // empty string code means unknown/invalid --> should not compare
+                key === this.key
             ),
         );
     }