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

package/packages/driver-saphi/src/DeviceSaphi.ts

@@ -0,0 +1,144 @@
+import {
+    DeviceBase,
+    ConnectionType,
+    ScreenSaverStatus,
+    VolumeRange,
+} from '@24i/bigscreen-sdk/driver-base';
+import { getDeviceInfo, getFirmware, getPlatformInfo } from './formatUserAgent';
+import { ISmartTvAApi } from './types';
+import { getKeyMap } from './keymap';
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+declare const SmartTvA_API: ISmartTvAApi;
+
+export class DeviceSaphi extends DeviceBase {
+    keyMap = getKeyMap();
+
+    platformInfo = getPlatformInfo(window.navigator.userAgent);
+
+    deviceInfo = getDeviceInfo(window.navigator.userAgent);
+
+    firmware = getFirmware(window.navigator.userAgent);
+
+    async initDevice(): Promise<void> {
+        this.initNetworkChangeListener();
+    }
+
+    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 {
+        SmartTvA_API.exit();
+    }
+
+    async getManufacturerName(): Promise<string> {
+        return 'Philips';
+    }
+
+    async getPlatformName(): Promise<string> {
+        const { platformName } = this.platformInfo;
+        return platformName ? `Saphi ${platformName}` : '';
+    }
+
+    async getPlatformVersion(): Promise<string> {
+        return this.platformInfo.platformVersion || '';
+    }
+
+    async getDeviceName(): Promise<string> {
+        return this.deviceInfo.deviceName || '';
+    }
+
+    async getModelName(): Promise<string> {
+        return this.deviceInfo.modelName || '';
+    }
+
+    async getFirmware(): Promise<string> {
+        return this.firmware || '';
+    }
+
+    async is4KSupported(): Promise<boolean> {
+        return SmartTvA_API.hasCapability('UHD');
+    }
+
+    async is8KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async getUuid(): Promise<string> {
+        return this.getBaseUuid();
+    }
+
+    async getVolume(): Promise<number> {
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setVolume(volumePercentage: number): Promise<void> {
+        // not supported on Saphi platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async mute(mute: boolean): Promise<void> {
+        // not supported on Saphi platform
+    }
+
+    async isMute(): Promise<boolean> {
+        // not supported on Saphi platform
+        return false;
+    }
+
+    async getScreenSaver(): Promise<ScreenSaverStatus> {
+        // not supported on Saphi platform
+        return { enabled: false };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setScreenSaver(status: ScreenSaverStatus): Promise<void> {
+        // not supported on Saphi platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string): Promise<boolean> {
+        // not supported on Saphi platform
+        return false;
+    }
+
+    async isNetworkConnected(): Promise<boolean> {
+        return window.navigator.onLine;
+    }
+
+    async getConnectionType(): Promise<ConnectionType> {
+        const { connectionType } = getDeviceInfo(window.navigator.userAgent);
+        switch (connectionType) {
+            case 'wired':
+                return 'cable';
+            case 'wireless':
+                return 'wifi';
+            default:
+                return 'unknown';
+        }
+    }
+
+    async getLocalIP(): Promise<string> {
+        // not supported on Saphi platform
+        return '';
+    }
+
+    async getMacAddress(): Promise<string> {
+        // not supported on Saphi platform
+        return '';
+    }
+}

package/packages/driver-saphi/src/constants.ts

@@ -0,0 +1 @@
+export type NetworkConnectionType = 'wired' | 'wireless';

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

@@ -0,0 +1,19 @@
+export const getPlatformInfo = (userAgent: string) => {
+    if (typeof userAgent !== 'string') return {};
+    const [, platformName, platformVersion] = userAgent.match(/(NETTV)\/([.\d]*)/) || [];
+    return { platformName, platformVersion };
+};
+
+export const getDeviceInfo = (userAgent: string) => {
+    if (typeof userAgent !== 'string') return {};
+    const [,
+        deviceName, modelName, connectionType,
+    ] = userAgent.match(/(Philips), ([\w\d]*), ([\w\d]*)/) || [];
+    return { deviceName, modelName, connectionType };
+};
+
+export const getFirmware = (userAgent: string) => {
+    if (typeof userAgent !== 'string') return '';
+    const [firmware] = userAgent.match(/_TV_[\w./\d]*/) || [];
+    return firmware;
+};

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

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

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

@@ -0,0 +1,64 @@
+/* eslint-disable no-magic-numbers */
+import { KeyMap } from '@24i/bigscreen-sdk/driver-base';
+import { SaphiKeys } from './types';
+
+declare const window: Window & SaphiKeys;
+
+export const getKeyMap = () => {
+    KeyMap.overrideValues({
+        LEFT: { keyCode: window.VK_LEFT },
+        RIGHT: { keyCode: window.VK_RIGHT },
+        UP: { keyCode: window.VK_UP },
+        DOWN: { keyCode: window.VK_DOWN },
+        ENTER: { keyCode: window.VK_ENTER },
+        BACK: { keyCode: window.VK_BACK },
+        ESC: { keyCode: window.VK_ESCAPE },
+
+        RED: { keyCode: window.VK_RED },
+        GREEN: { keyCode: window.VK_GREEN },
+        YELLOW: { keyCode: window.VK_YELLOW },
+        BLUE: { keyCode: window.VK_BLUE },
+
+        PLAY: { keyCode: window.VK_PLAY },
+        PAUSE: { keyCode: window.VK_PAUSE },
+        PLAYPAUSE: { keyCode: window.VK_PLAY_PAUSE || 463 },
+        STOP: { keyCode: window.VK_STOP },
+        FF: { keyCode: window.VK_FAST_FWD },
+        REW: { keyCode: window.VK_REWIND },
+        REC: { keyCode: window.VK_RECORD },
+
+        NUM_0: { keyCode: window.VK_0 },
+        NUM_1: { keyCode: window.VK_1 },
+        NUM_2: { keyCode: window.VK_2 },
+        NUM_3: { keyCode: window.VK_3 },
+        NUM_4: { keyCode: window.VK_4 },
+        NUM_5: { keyCode: window.VK_5 },
+        NUM_6: { keyCode: window.VK_6 },
+        NUM_7: { keyCode: window.VK_7 },
+        NUM_8: { keyCode: window.VK_8 },
+        NUM_9: { keyCode: window.VK_9 },
+        KP_0: { keyCode: window.VK_NUMPAD0 },
+        KP_1: { keyCode: window.VK_NUMPAD1 },
+        KP_2: { keyCode: window.VK_NUMPAD2 },
+        KP_3: { keyCode: window.VK_NUMPAD3 },
+        KP_4: { keyCode: window.VK_NUMPAD4 },
+        KP_5: { keyCode: window.VK_NUMPAD5 },
+        KP_6: { keyCode: window.VK_NUMPAD6 },
+        KP_7: { keyCode: window.VK_NUMPAD7 },
+        KP_8: { keyCode: window.VK_NUMPAD8 },
+        KP_9: { keyCode: window.VK_NUMPAD9 },
+
+        HOME: { keyCode: window.VK_HOME },
+        END: { keyCode: window.VK_END },
+        CHANNEL_UP: { keyCode: window.VK_CHANNEL_UP || 427 },
+        CHANNEL_DOWN: { keyCode: window.VK_CHANNEL_DOWN || 428 },
+        CHANNEL_PREVIOUS: { keyCode: window.VK_PREV || 424 },
+        VOL_UP: { keyCode: window.VK_VOLUME_UP },
+        VOL_DOWN: { keyCode: window.VK_VOLUME_DOWN },
+        MUTE: { keyCode: window.VK_MUTE },
+        TXT: { keyCode: window.VK_TELETEXT },
+        INFO: { keyCode: window.VK_INFO },
+        GUIDE: { keyCode: window.VK_GUIDE },
+    });
+    return KeyMap.generateKeyCodeKeyMap();
+};

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

@@ -0,0 +1,75 @@
+export interface ISmartTvAApi {
+    /**
+     * Query an optional or conditionally mandatory function on the TV Device.
+     * @param query - This string is the optional or conditionally mandatory function
+     * name to query support for.
+     * Note: this string is case sensitive.
+     * @param params - This string contains additional query information
+     * as a variable number of param arguments (param1, …, paramN). The number of arguments
+     * depends on the query string (refer to hasCapability method arguments table).
+     * Note: this string is case sensitive.
+     * @return It is set to true if the given function is supported, otherwise false.
+     */
+    hasCapability: (query: string, ...params: string[]) => boolean;
+    /**
+     * Notify the TV Device that an application is ready to exit and returns
+     * control back to the device.
+     */
+    exit: () => void;
+}
+
+export type SaphiKeys = {
+    readonly VK_LEFT: number,
+    readonly VK_RIGHT: number,
+    readonly VK_UP: number,
+    readonly VK_DOWN: number,
+    readonly VK_ENTER: number,
+    readonly VK_BACK: number,
+    readonly VK_ESCAPE: number,
+
+    readonly VK_RED: number,
+    readonly VK_GREEN: number,
+    readonly VK_YELLOW: number,
+    readonly VK_BLUE: number,
+
+    readonly VK_PLAY: number,
+    readonly VK_PAUSE: number,
+    readonly VK_PLAY_PAUSE: number,
+    readonly VK_STOP: number,
+    readonly VK_FAST_FWD: number,
+    readonly VK_REWIND: number,
+    readonly VK_RECORD: number,
+
+    readonly VK_0: number,
+    readonly VK_1: number,
+    readonly VK_2: number,
+    readonly VK_3: number,
+    readonly VK_4: number,
+    readonly VK_5: number,
+    readonly VK_6: number,
+    readonly VK_7: number,
+    readonly VK_8: number,
+    readonly VK_9: number,
+    readonly VK_NUMPAD0: number,
+    readonly VK_NUMPAD1: number,
+    readonly VK_NUMPAD2: number,
+    readonly VK_NUMPAD3: number,
+    readonly VK_NUMPAD4: number,
+    readonly VK_NUMPAD5: number,
+    readonly VK_NUMPAD6: number,
+    readonly VK_NUMPAD7: number,
+    readonly VK_NUMPAD8: number,
+    readonly VK_NUMPAD9: number,
+
+    readonly VK_HOME: number,
+    readonly VK_END: number,
+    readonly VK_CHANNEL_UP: number,
+    readonly VK_CHANNEL_DOWN: number,
+    readonly VK_PREV: number,
+    readonly VK_VOLUME_UP: number,
+    readonly VK_VOLUME_DOWN: number,
+    readonly VK_MUTE: number,
+    readonly VK_TELETEXT: number,
+    readonly VK_INFO: number,
+    readonly VK_GUIDE: number,
+};

package/packages/driver-tizen/src/DeviceTizen.ts

@@ -0,0 +1,296 @@
+import {
+    DeviceBase,
+    STORAGE_UUID_KEY,
+    ScreenSaverStatus,
+    VolumeRange,
+    ExitOptions,
+} from '@24i/bigscreen-sdk/driver-base';
+import { Storage } from '@24i/bigscreen-sdk/storage';
+import { runAsync } from '@24i/bigscreen-sdk/utils/timers';
+import { TizenKeys } from './TizenKeys';
+import {
+    VENDOR,
+    NetworkState,
+    NetworkActiveConnectionType,
+    AppCommonScreenSaverState,
+} from './constants';
+import { IWebapis, ITizen, TizenApplication } from './types';
+
+declare const webapis: IWebapis;
+declare const tizen: ITizen;
+
+const isNetworkConnected = (state: NetworkState) => {
+    switch (state) {
+        case NetworkState.GATEWAY_CONNECTED: return true;
+        case NetworkState.GATEWAY_DISCONNECTED: return false;
+        case NetworkState.LAN_CABLE_ATTACHED: return true;
+        case NetworkState.LAN_CABLE_DETACHED: return false;
+        case NetworkState.LAN_CABLE_STATE_UNKNOWN: return false;
+        case NetworkState.WIFI_MODULE_STATE_ATTACHED: return true;
+        case NetworkState.WIFI_MODULE_STATE_DETACHED: return false;
+        case NetworkState.WIFI_MODULE_STATE_UNKNOWN: return false;
+        default: return false;
+    }
+};
+
+export class DeviceTizen extends DeviceBase {
+    // MARK: Properties
+
+    application: TizenApplication = tizen.application.getCurrentApplication();
+
+    keys: TizenKeys = new TizenKeys();
+
+    deviceName?: string;
+
+    version?: string;
+
+    screenSaverStatus: AppCommonScreenSaverState = AppCommonScreenSaverState.SCREEN_SAVER_OFF;
+
+    // MARK: Initialization
+
+    async initDevice(): Promise<void> {
+        this.initVisibilityChangeListener();
+        this.initNetworkChangeListener();
+        this.initMouseActiveListener();
+        this.initKeyMap();
+        this.version = this.recognizeVersion(navigator.userAgent);
+    }
+
+    recognizeVersion(userAgent: string) {
+        const matches = userAgent.match(/Tizen ([.\d]*)/);
+        if (matches) {
+            return matches[1] || '';
+        }
+        return '';
+    }
+
+    initVisibilityChangeListener() {
+        document.addEventListener('visibilitychange', () => {
+            this.triggerEvent('visibilitychange', { isVisible: !document.hidden });
+        });
+    }
+
+    initNetworkChangeListener() {
+        webapis.network.addNetworkStateChangeListener((state: NetworkState) => {
+            this.triggerEvent('networkchange', ({
+                isConnected: isNetworkConnected(state),
+            }));
+        });
+    }
+
+    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 });
+    };
+
+    initKeyMap() {
+        this.keys.init();
+        this.keyMap = this.keys.getKeyMap();
+    }
+
+    // MARK: Platform
+
+    exit({ forceExit }: ExitOptions = { forceExit: false }) {
+        if (forceExit) {
+            this.application.exit();
+        } else {
+            this.application.hide();
+        }
+    }
+
+    reboot() {
+        // Not supported on Samsung Tizen platform
+    }
+
+    async getManufacturerName() {
+        return 'Samsung';
+    }
+
+    async getPlatformName() {
+        return 'Tizen';
+    }
+
+    async getPlatformVersion() {
+        return this.version || '';
+    }
+
+    async getDeviceName() {
+        if (this.deviceName) return this.deviceName;
+        this.deviceName = VENDOR;
+        if (typeof webapis.productinfo.getRealModel === 'function') {
+            this.deviceName += `, ${webapis.productinfo.getRealModel()}`;
+        }
+        if (typeof webapis.productinfo.getModelCode === 'function') {
+            this.deviceName += `, ${webapis.productinfo.getModelCode()}`;
+        }
+        return this.deviceName;
+    }
+
+    async getModelName() {
+        try {
+            return webapis.productinfo.getRealModel() || '';
+        } catch (e) {
+            console.error('[DeviceTizen] Failed to getModelName', e);
+            return '';
+        }
+    }
+
+    async getFirmware() {
+        try {
+            return webapis.productinfo.getFirmware() || '';
+        } catch (e) {
+            console.error('[DeviceTizen] Failed getFirmware', e);
+            return '';
+        }
+    }
+
+    async is4KSupported() {
+        try {
+            return webapis.productinfo.isUdPanelSupported() || false;
+        } catch (e) {
+            console.error('[DeviceTizen] Failed is4KSupported', e);
+            return false;
+        }
+    }
+
+    async is8KSupported() {
+        try {
+            return webapis.productinfo.is8KPanelSupported() || false;
+        } catch (e) {
+            console.error('[DeviceTizen] Failed is8KSupported', e);
+            return false;
+        }
+    }
+
+    async getUuid() {
+        const storedUuid = await Storage.getItem(STORAGE_UUID_KEY);
+        if (storedUuid) return storedUuid;
+
+        let duid;
+        try {
+            duid = webapis.productinfo.getDuid();
+        } catch (e) {
+            console.error('[DeviceTizen] Failed getUuid', e);
+        }
+        if (duid) {
+            await Storage.setItem(STORAGE_UUID_KEY, duid);
+            return duid;
+        }
+        return '';
+    }
+
+    async getVolume() {
+        try {
+            const volume = tizen.tvaudiocontrol.getVolume();
+            return volume ?? VolumeRange.UNSUPPORTED;
+        } catch (e) {
+            console.error('[DeviceTizen] Failed getVolume', e);
+        }
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    async setVolume(volumePercentage: number) {
+        const errorMsg = this.validateVolumeValue(volumePercentage);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        try {
+            tizen.tvaudiocontrol.setVolume(volumePercentage);
+        } catch (e) {
+            console.error('[DeviceTizen] Failed setVolume', e);
+        }
+    }
+
+    async mute(mute: boolean) {
+        try {
+            tizen.tvaudiocontrol.setMute(mute);
+        } catch (e) {
+            console.error('[DeviceTizen] Failed mute', e);
+        }
+    }
+
+    async isMute() {
+        try {
+            const isMuted = tizen.tvaudiocontrol.isMute();
+            return !!isMuted;
+        } catch (e) {
+            console.error('[DeviceTizen] Failed isMute', e);
+        }
+        return false;
+    }
+
+    async getScreenSaver(): Promise<ScreenSaverStatus> {
+        return { enabled: this.screenSaverStatus === AppCommonScreenSaverState.SCREEN_SAVER_ON };
+    }
+
+    async setScreenSaver({ enabled }: ScreenSaverStatus): Promise<void> {
+        const status: AppCommonScreenSaverState = enabled
+            ? AppCommonScreenSaverState.SCREEN_SAVER_ON
+            : AppCommonScreenSaverState.SCREEN_SAVER_OFF;
+        return new Promise((resolve) => {
+            webapis.appCommon.setScreenSaver(
+                status,
+                () => {
+                    this.screenSaverStatus = status;
+                    resolve();
+                },
+                () => { resolve(); },
+            );
+        });
+    }
+
+    async setUserAgent(userAgent: string): Promise<boolean> {
+        return new Promise((resolve) => {
+            tizen.websetting.setUserAgentString(
+                userAgent,
+                () => resolve(true),
+                () => resolve(false),
+            );
+        });
+    }
+
+    // MARK: Connection
+
+    async isNetworkConnected() {
+        return webapis.network.isConnectedToGateway();
+    }
+
+    async getConnectionType() {
+        if (!this.isNetworkConnected()) return 'none';
+        const tizenConnectionType = webapis.network.getActiveConnectionType();
+        switch (tizenConnectionType) {
+            case NetworkActiveConnectionType.CELLULAR:
+            case NetworkActiveConnectionType.WIFI:
+                return 'wifi';
+            case NetworkActiveConnectionType.ETHERNET:
+                return 'cable';
+            default: return 'unknown';
+        }
+    }
+
+    async getLocalIP() {
+        return webapis.network.getIp();
+    }
+
+    async getMacAddress() {
+        return webapis.network.getMac();
+    }
+}