@24i/bigscreen-sdk 0.9.9-alpha.2148 → 0.9.9-alpha.2150

package/__mocks__/@24i/bigscreen-sdk/animations.ts

@@ -0,0 +1,2 @@
+export { AnimationUtils } from '@24i/bigscreen-sdk/animations';
+export { JSAnimations } from '@24i/bigscreen-sdk/animations/mock';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@24i/bigscreen-sdk",
-    "version": "0.9.9-alpha.2148",
+    "version": "0.9.9-alpha.2150",
     "description": "SmartApps BIGscreen SDK monorepo",
     "main": "index.js",
     "scripts": {

package/packages/animations/src/__mocks__/JSAnimations.ts

@@ -0,0 +1,30 @@
+export class JSAnimations {
+    animationRunning = false;
+
+    from = 0;
+
+    to = 0;
+
+    frameCallback?: (value: number) => void;
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    start(from: number, to: number, time: number, easingFunction: any): JSAnimations {
+        this.to = to;
+        this.animationRunning = true;
+        this.frameCallback = undefined;
+        setTimeout(this.frame, 0);
+        return this;
+    }
+
+    frame = (): void => {
+        if (this.frameCallback) {
+            this.frameCallback(this.to);
+        }
+    };
+
+    onFrame(callback: (value: number) => void) {
+        if (typeof callback === 'function') {
+            this.frameCallback = callback;
+        }
+    }
+}

package/packages/conviva/src/__mocks__/ConvivaMock.ts

@@ -0,0 +1,36 @@
+import type { ConvivaSDK } from '../ConvivaSDK';
+
+export const ConvivaMock: ConvivaSDK = {
+    Constants: {
+        StreamType: {
+            LIVE: 'LIVE',
+            VOD: 'VOD',
+        },
+        LogLevel: {
+            DEBUG: 0,
+            INFO: 1,
+            WARNING: 2,
+            ERROR: 3,
+            NONE: 4,
+        },
+        DeviceMetadata: {
+            MANUFACTURER: 'MANUFACTURER',
+            MODEL: 'MODEL',
+            TYPE: 'TYPE',
+        },
+        DeviceType: {
+            SMARTTV: 'SMARTTV',
+        },
+        ASSET_NAME: 'ASSET_NAME',
+        CUSTOMER_KEY: 'CUSTOMER_KEY',
+        DEFAULT_RESOURCE: 'DEFAULT_RESOURCE',
+        DURATION: 'DURATION',
+        ENCODED_FRAMERATE: 'ENCODED_FRAMERATE',
+        GATEWAY_URL: 'GATEWAY_URL',
+        IS_LIVE: 'IS_LIVE',
+        LOG_LEVEL: 'LOG_LEVEL',
+        PLAYER_NAME: 'PLAYER_NAME',
+        STREAM_URL: 'STREAM_URL',
+        VIEWER_ID: 'VIEWER_ID',
+    },
+};

package/packages/developer-tools/src/DeveloperConsole/utils/formatTime.ts

@@ -0,0 +1,13 @@
+export const formatTimeToHMS = (timestamp: number) => {
+    if (!timestamp) {
+        return '00:00:00';
+    }
+    const date = new Date(timestamp);
+    const lastTwoChars = -2;
+
+    const hours = (`0${date.getHours()}`).slice(lastTwoChars);
+    const minutes = (`0${date.getMinutes()}`).slice(lastTwoChars);
+    const seconds = (`0${date.getSeconds()}`).slice(lastTwoChars);
+
+    return `${hours}:${minutes}:${seconds}`;
+};

package/packages/developer-tools/src/DeveloperConsole/utils/index.ts

@@ -0,0 +1,3 @@
+export { formatTimeToHMS } from './formatTime';
+export { getStatusCodeClass } from './styles';
+export { stringifyObjectData } from './stringify';

package/packages/developer-tools/src/DeveloperConsole/utils/stringify.ts

@@ -0,0 +1,10 @@
+export const stringifyObjectData = (data: any) => {
+    if (typeof data === 'object') {
+        try {
+            return JSON.stringify(data);
+        } catch (error) {
+            return '';
+        }
+    }
+    return data || '';
+};

package/packages/developer-tools/src/DeveloperConsole/utils/styles.ts

@@ -0,0 +1,24 @@
+const HttpStatusCodesLevels = {
+    LEVEL_2XX: '2',
+    LEVEL_3XX: '3',
+    LEVEL_4XX: '4',
+    LEVEL_5XX: '5',
+};
+
+export const getStatusCodeClass = (statusCode: number) => {
+    const { LEVEL_2XX, LEVEL_3XX, LEVEL_4XX, LEVEL_5XX } = HttpStatusCodesLevels;
+    const stringStatusCode = String(statusCode);
+    if (stringStatusCode.startsWith(LEVEL_2XX)) {
+        return 'status-ok';
+    }
+    if (stringStatusCode.startsWith(LEVEL_3XX)) {
+        return 'status-redirect';
+    }
+    if (stringStatusCode.startsWith(LEVEL_4XX)) {
+        return 'status-client-error';
+    }
+    if (stringStatusCode.startsWith(LEVEL_5XX)) {
+        return 'status-server-error';
+    }
+    return '';
+};

package/packages/developer-tools/src/EnvironmentSelection/utils/format.ts

@@ -0,0 +1,4 @@
+export const capitalizeFirstLetter = (string: string) => {
+    if (typeof string !== 'string' || string.length === 0) return string;
+    return string.charAt(0).toUpperCase() + string.substring(1);
+};

package/packages/developer-tools/src/TechnicalInfo/__mocks__/Device.ts

@@ -0,0 +1,51 @@
+class Device {
+    async getUuid() {
+        return 'uuidXYZ';
+    }
+
+    async getManufacturerName() {
+        return 'manufacturer name';
+    }
+
+    async getPlatformName() {
+        return 'platform name';
+    }
+
+    async getPlatformVersion() {
+        return 'platform version';
+    }
+
+    async getDeviceName() {
+        return 'device name';
+    }
+
+    async getModelName() {
+        return 'model name';
+    }
+
+    async getFirmware() {
+        return 'device firmware';
+    }
+
+    async is4KSupported() {
+        return true;
+    }
+
+    async is8KSupported() {
+        return false;
+    }
+
+    async getLocalIP() {
+        return 'local ip';
+    }
+
+    async getConnectionType() {
+        return 'connection type';
+    }
+
+    async getMacAddress() {
+        return 'mac address';
+    }
+}
+
+export { Device };

package/packages/developer-tools/src/TechnicalInfo/__mocks__/Player.ts

@@ -0,0 +1,7 @@
+class Player {
+    static playerName = 'PlayerEngine';
+
+    static version = 'v1.0.0';
+}
+
+export { Player };

package/packages/developer-tools/src/TechnicalInfo/__mocks__/Storage.ts

@@ -0,0 +1,9 @@
+/* eslint-disable no-magic-numbers */
+
+class Storage {
+    async getUsedSize() {
+        return 2048; // 2 kB
+    }
+}
+
+export { Storage };

package/packages/developer-tools/src/TechnicalInfo/utils/eme01bSupport.ts

@@ -0,0 +1,58 @@
+/**
+ * To detect Encrypted Media Extensions (EME) and Content Decryption Module (CDM)
+ * support in a browser for various DRM technologies.
+ *
+ * Encrypted Media Extensions v0.1b (draft proposal)
+ * - The EME v0.1b is implemented on old devices like Tizen 2016, LG webOS 3.0
+ */
+
+/**
+ * Check the Encrypted Media Extensions v0.1b is supported in
+ */
+function hasEMESupport() {
+    const videoEl = document.createElement('video');
+    // any because the method is defined in EME v0.1b
+    const addKey = (videoEl as any).webkitAddKey;
+    return !!addKey;
+}
+
+/**
+ * @param videoEl Video element
+ * @param keySystem Key System Identifier of a content protection (DRM) mechanism.
+ * @returns A boolean indicating whether key system is supported
+ */
+function isKeySystemSupported(videoEl: HTMLVideoElement, keySystem: string) {
+    // @ts-ignore - the optional second parameter is defined in EME v0.1b
+    return !!videoEl.canPlayType('video/mp4;codecs="avc1.42E01E"', keySystem);
+}
+
+const KeySystems = {
+    'webkit-org.w3.clearkey': { name: 'W3C Clear Key' }, // prefixed for EME v0.1b
+    'org.w3.clearkey': { name: 'W3C Clear Key' },
+    'com.microsoft.playready': { name: 'Microsoft PlayReady' },
+    'com.youtube.playready': { name: 'YouTube PlayReady' },
+    'com.widevine.alpha': { name: 'Google Widevine' },
+    'com.apple.fairplay': { name: 'Apple FairPlay' },
+    'com.adobe.access': { name: 'Adobe Access' },
+};
+
+/**
+ * Get list of supported DRM/CDM
+ */
+async function getListOfSupportedDRM() {
+    const keySystems = Object.keys(KeySystems) as Array<keyof typeof KeySystems>;
+    const videoEl = document.createElement('video');
+
+    const supportedSystems = [];
+    for (let i = 0; i < keySystems.length; i++) {
+        const keySystem = keySystems[i];
+        const isSupported = isKeySystemSupported(videoEl, keySystem);
+        if (isSupported) {
+            supportedSystems.push({ id: keySystem, name: KeySystems[keySystem].name });
+        }
+    }
+
+    return supportedSystems;
+}
+
+export { hasEMESupport, getListOfSupportedDRM };

package/packages/developer-tools/src/TechnicalInfo/utils/emeSupport.ts

@@ -0,0 +1,80 @@
+/**
+ * To detect Encrypted Media Extensions (EME) and Content Decryption Module (CDM)
+ * support in a browser for various DRM technologies.
+ */
+
+/**
+ * Check the EME (Encrypted Media Extensions API) is supported in
+ */
+function hasEMESupport() {
+    // verified only "window.MediaKeys", other prefixed keys were not tested
+    const eme = window.MediaKeys || (window as any).MSMediaKeys || (window as any).WebKitMediaKeys;
+    return !!eme;
+}
+
+/**
+ * Check the navigator.requestMediaKeySystemAccess method is supported in
+ * Note: it can be used for EME support check, alternatively instead of hasEMESupport.
+ */
+function hasRMKSASupport() {
+    const rmksa = window.navigator.requestMediaKeySystemAccess;
+    return !!rmksa;
+}
+
+/**
+ * @param keySystem Key System Identifier of a content protection (DRM) mechanism.
+ * @param config A non-empty array of MediaKeySystemConfiguration objects.
+ */
+function isKeySystemSupported(keySystem: string, config: MediaKeySystemConfiguration[])
+    : Promise<boolean> {
+    return new Promise((resolve) => {
+        try {
+            window.navigator.requestMediaKeySystemAccess(keySystem, config)
+                .then(() => { resolve(true); })
+                .catch(() => { resolve(false); });
+        } catch (e) {
+            resolve(false);
+        }
+    });
+}
+
+const KeySystems = {
+    // 'webkit-org.w3.clearkey': { name: 'W3C Clear Key' }, // only EME v0.1b
+    'org.w3.clearkey': { name: 'W3C Clear Key' },
+    'com.microsoft.playready': { name: 'Microsoft PlayReady' },
+    'com.youtube.playready': { name: 'YouTube PlayReady' },
+    'com.widevine.alpha': { name: 'Google Widevine' },
+    'com.apple.fairplay': { name: 'Apple FairPlay' },
+    'com.adobe.access': { name: 'Adobe Access' },
+};
+
+/**
+ * Get list of supported DRM/CDM
+ */
+async function getListOfSupportedDRM() {
+    const keySystems = Object.keys(KeySystems) as Array<keyof typeof KeySystems>;
+
+    const keySystemConfig = [{
+        initDataTypes: ['cenc'],
+        audioCapabilities: [{
+            contentType: 'audio/mp4;codecs="mp4a.40.2"',
+        }],
+        videoCapabilities: [{
+            contentType: 'video/mp4;codecs="avc1.42E01E"',
+        }],
+    }];
+
+    const supportedSystems = [];
+    for (let i = 0; i < keySystems.length; i++) {
+        const keySystem = keySystems[i];
+        // eslint-disable-next-line no-await-in-loop
+        const isSupported = await isKeySystemSupported(keySystem, keySystemConfig);
+        if (isSupported) {
+            supportedSystems.push({ id: keySystem, name: KeySystems[keySystem].name });
+        }
+    }
+
+    return supportedSystems;
+}
+
+export { hasEMESupport, hasRMKSASupport, getListOfSupportedDRM };

package/packages/developer-tools/src/TechnicalInfo/utils/formatTimezone.ts

@@ -0,0 +1,15 @@
+const MINUTES_PER_HOUR = 60;
+
+/**
+ * @param timezoneOffsetInMinutes The time-zone offset, in minutes, from local time to UTC.
+ * @returns time-zone string in RFC 822 4-digit time zone format, e.g. "+0100"
+ */
+function formatTimezone(timezoneOffsetInMinutes = 0) {
+    const hours = Math.floor(Math.abs(timezoneOffsetInMinutes / MINUTES_PER_HOUR));
+    const minutes = timezoneOffsetInMinutes % MINUTES_PER_HOUR;
+    const formattedHours = `0${hours}`.slice(-2); // eslint-disable-line no-magic-numbers
+    const formattedMinutes = `0${minutes}`.slice(-2); // eslint-disable-line no-magic-numbers
+    return `${timezoneOffsetInMinutes > 0 ? '-' : '+'}${formattedHours}${formattedMinutes}`;
+}
+
+export { formatTimezone };

package/packages/developer-tools/src/TechnicalInfo/utils/mseSupport.ts

@@ -0,0 +1,14 @@
+/**
+ * To detect Media Source Extensions API (MSE) support in a browser.
+ */
+
+/**
+ * Check the MSE (Media Source Extensions API) is supported in
+ */
+function hasMSESupport() {
+    // any because webkit-prefixed key needed on old devices like LG webOS 1.0 (2014)
+    const mse = window.MediaSource || (window as any).WebKitMediaSource;
+    return !!mse;
+}
+
+export { hasMSESupport };

package/packages/developer-tools/src/utils/reload.ts

@@ -0,0 +1,6 @@
+export const reloadApp = () => {
+    let rootPath = '';
+    const splitUrl = window.location.href.split('#');
+    if (splitUrl.length > 1) rootPath = splitUrl[0];
+    window.location.href = rootPath;
+};

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

@@ -0,0 +1,100 @@
+import { DeviceBase as AbstractDeviceBase } from '../DeviceBase';
+import { ScreenSaverStatus } from '../types/ScreenSaverStatus';
+import { ConnectionType } from '../ConnectionType';
+
+export class DeviceBase extends AbstractDeviceBase {
+    volume = 0;
+
+    isMuted = false;
+
+    screenSaverStatus = { enabled: false };
+
+    async initDevice() {
+        return undefined;
+    }
+
+    exit() {}
+
+    reboot() {}
+
+    async getManufacturerName() {
+        return 'manufacturer name';
+    }
+
+    async getPlatformName() {
+        return 'platform name';
+    }
+
+    async getPlatformVersion() {
+        return 'platform version';
+    }
+
+    async getDeviceName() {
+        return 'device name';
+    }
+
+    async getModelName() {
+        return 'model name';
+    }
+
+    async getFirmware() {
+        return 'device firmware';
+    }
+
+    async is4KSupported() {
+        return true;
+    }
+
+    async is8KSupported() {
+        return false;
+    }
+
+    async getUuid() {
+        return this.getBaseUuid();
+    }
+
+    async getVolume() {
+        return this.volume;
+    }
+
+    async setVolume(volumePercentage: number) {
+        this.volume = volumePercentage;
+    }
+
+    async mute(mute: boolean) {
+        this.isMuted = mute;
+    }
+
+    async isMute() {
+        return this.isMuted;
+    }
+
+    async getScreenSaver() {
+        return this.screenSaverStatus;
+    }
+
+    async setScreenSaver(status: ScreenSaverStatus) {
+        this.screenSaverStatus.enabled = status.enabled;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string) {
+        return false;
+    }
+
+    async isNetworkConnected() {
+        return true;
+    }
+
+    async getConnectionType() {
+        return 'unknown' as ConnectionType;
+    }
+
+    async getLocalIP() {
+        return '1.2.3.4';
+    }
+
+    async getMacAddress() {
+        return '00:11:22:33:44:55';
+    }
+}

package/packages/driver-base/src/__mocks__/keyMap.ts

@@ -0,0 +1,41 @@
+export const KEYMAP = {
+    LEFT: 37,
+    RIGHT: 39,
+    UP: 38,
+    DOWN: 40,
+    BACK: 8,
+    ENTER: 13,
+    ESC: 27,
+    PLAY: 415,
+    PAUSE: 19,
+    PLAYPAUSE: 1000,
+    STOP: 413,
+    FF: 417,
+    REW: 412,
+    RED: 82,
+    GREEN: 71,
+    YELLOW: 89,
+    BLUE: 66,
+    NUM_0: 48,
+    NUM_1: 49,
+    NUM_2: 50,
+    NUM_3: 51,
+    NUM_4: 52,
+    NUM_5: 53,
+    NUM_6: 54,
+    NUM_7: 55,
+    NUM_8: 56,
+    NUM_9: 57,
+    KP_0: 96,
+    KP_1: 97,
+    KP_2: 98,
+    KP_3: 99,
+    KP_4: 100,
+    KP_5: 101,
+    KP_6: 102,
+    KP_7: 103,
+    KP_8: 104,
+    KP_9: 105,
+    CHANNEL_UP: 33,
+    CHANNEL_DOWN: 34,
+};