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

package/packages/driver-webos/src/DeviceWebos.ts

@@ -0,0 +1,305 @@
+import {
+    DeviceBase,
+    STORAGE_UUID_KEY,
+    ScreenSaverStatus,
+    VolumeRange,
+    ExitOptions,
+} from '@24i/bigscreen-sdk/driver-base';
+import { Storage } from '@24i/bigscreen-sdk/storage';
+import { initWebOSTVjs } from './webOSTVjs/webOSTVjs.export';
+import { getKeyMap } from './keymap';
+import { isMinVersion } from './utils';
+import { Errors, BasePlatform, ApiUrls } from './constants';
+import {
+    WiredStatus, WifiStatus, ConnectionManager, IWebOS, IPalmSystem, DeviceInfo,
+} from './types';
+
+declare const webOS: IWebOS;
+declare const PalmSystem: IPalmSystem;
+
+const isConnected = (connectionStatus: WiredStatus | WifiStatus) => (
+    connectionStatus?.state === 'connected'
+);
+
+export class DeviceWebos extends DeviceBase {
+    keyMap = getKeyMap();
+
+    platformBase?: BasePlatform;
+
+    connectionManager?: ConnectionManager;
+
+    deviceInfo?: DeviceInfo;
+
+    duid?: string;
+
+    // MARK: Initialization
+
+    async initDevice() {
+        initWebOSTVjs();
+        this.checkEnvironment();
+        await this.initDeviceInfo();
+        await this.initConnectionManager();
+        this.initVisibilityChangeListener();
+        this.initMouseActiveListener();
+        await this.initDUID();
+    }
+
+    async initDeviceInfo() {
+        return new Promise<void>((resolve) => {
+            webOS.deviceInfo((deviceInfo: DeviceInfo) => {
+                this.deviceInfo = deviceInfo || {};
+                if (this.deviceInfo.uhd8K) {
+                    this.screenSize = '8k';
+                } else if (this.deviceInfo.uhd) {
+                    this.screenSize = '4k';
+                } else {
+                    this.screenSize = 'full_hd';
+                }
+                resolve();
+            });
+        });
+    }
+
+    async initConnectionManager() {
+        const apiUrl = this.isPalmPlatform()
+            ? ApiUrls.CONNECTION_MANAGER_PALM
+            : ApiUrls.CONNECTION_MANAGER_WEBOS;
+        return new Promise<void>((resolve) => {
+            webOS.service.request(apiUrl, {
+                method: 'getStatus',
+                parameters: { subscribe: true },
+                onSuccess: (response) => {
+                    if (response.returnValue) {
+                        this.connectionManager = response;
+                    }
+                    resolve();
+                },
+                onFailure: (error) => {
+                    const { errorCode, errorText } = error || {};
+                    console.error(`[DeviceWebos] getStatus onFailure: [${errorCode}] ${errorText}`);
+                    resolve();
+                },
+            });
+        });
+    }
+
+    initVisibilityChangeListener() {
+        const isWebkitPrefixNeeded = typeof document.hidden === 'undefined';
+        const hiddenKeyName = isWebkitPrefixNeeded ? 'webkitHidden' : 'hidden';
+        const eventName = isWebkitPrefixNeeded ? 'webkitvisibilitychange' : 'visibilitychange';
+        document.addEventListener(eventName, () => {
+            this.triggerEvent('visibilitychange', ({
+                isVisible: !document[hiddenKeyName as 'hidden'],
+            }));
+        }, true);
+    }
+
+    initMouseActiveListener() {
+        document.addEventListener('cursorStateChange', (event) => {
+            // @ts-ignore - the LG event has this structure.
+            this.isMouseActive = event.detail.visibility;
+            this.triggerEvent('mouseactive', {
+                isMouseActive: this.isMouseActive,
+            });
+        });
+    }
+
+    /**
+     * Initializes Device Unique ID.
+     */
+    async initDUID() {
+        const storedUuid = await Storage.getItem(STORAGE_UUID_KEY);
+        if (storedUuid) {
+            this.duid = storedUuid;
+        } else {
+            const duid = await this.getLgDeviceId();
+            if (duid) {
+                await Storage.setItem(STORAGE_UUID_KEY, duid);
+                this.duid = duid;
+            } else {
+                this.duid = await super.getBaseUuid();
+            }
+        }
+    }
+
+    /**
+     * Returns the device ID provided by the webOS TV. Currently, LGUDID
+     * (LG Unique Device ID) is supported.
+     * @returns LG Unique Device ID (From webOS 3.0 or later) or undefined.
+     */
+    async getLgDeviceId() {
+        return new Promise<string | void>((resolve) => {
+            webOS.service.request(ApiUrls.SM, {
+                method: 'deviceid/getIDs',
+                parameters: {
+                    idType: ['LGUDID'],
+                },
+                onSuccess: (response) => {
+                    let duid = '';
+                    if (response.returnValue) {
+                        duid = response?.idList[0]?.idValue;
+                    }
+                    resolve(duid);
+                },
+                onFailure: (error) => {
+                    // ex. returns error for webOS 1.0, 2.0 as not supported
+                    const { errorCode, errorText } = error || {};
+                    console.error(`[DeviceWebos] getIDs onFailure: [${errorCode}] ${errorText}`);
+                    resolve();
+                },
+            });
+        });
+    }
+
+    checkEnvironment() {
+        if (!webOS) throw new Error(Errors.WEBOS);
+        if (!webOS.service) throw new Error(Errors.WEBOS_SERVICE);
+        if (!webOS.deviceInfo) throw new Error(Errors.WEBOS_DEVICE);
+        if (!PalmSystem) throw new Error(Errors.PALMSYSTEM);
+        if (!isMinVersion(webOS.libVersion, '1.2.3')) {
+            const outdatedWebosLibMsg = Errors.OUTDATED_WEBOS_LIB
+                .replace('{version}', webOS.libVersion)
+                .replace('{requiredVersion}', '1.2.3');
+            throw new Error(outdatedWebosLibMsg);
+        }
+    }
+
+    // MARK: Platform
+
+    getBasePlatform(): BasePlatform {
+        if (this.platformBase) return this.platformBase;
+        const webOS1Regex = /(Web0S|537.41).+(Web0S|537.41)/;
+        const webOS2Regex = /(Web0S|538.2).+(Web0S|538.2)/;
+        const { userAgent } = window.navigator;
+        if (userAgent.match(webOS1Regex) || userAgent.match(webOS2Regex)) {
+            this.platformBase = 'palm';
+        } else {
+            this.platformBase = 'webos';
+        }
+        return this.platformBase;
+    }
+
+    isWebOSPlatform(): boolean {
+        return this.getBasePlatform() === 'webos';
+    }
+
+    isPalmPlatform(): boolean {
+        return this.getBasePlatform() === 'palm';
+    }
+
+    exit({ forceExit }: ExitOptions = { forceExit: false }) {
+        if (forceExit) {
+            window.open('', '_self')?.close();
+        } else {
+            PalmSystem.deactivate();
+        }
+    }
+
+    reboot() {
+        // Not supported on LG webOS platform
+    }
+
+    async getManufacturerName() {
+        return 'LG';
+    }
+
+    async getPlatformName() {
+        return 'webOS';
+    }
+
+    async getPlatformVersion() {
+        return this.deviceInfo?.sdkVersion || '';
+    }
+
+    async getDeviceName() {
+        const modelName = this.deviceInfo?.modelName || '';
+        const firmware = this.deviceInfo?.version || '';
+        return `LG webOS ${modelName}, ${firmware}`;
+    }
+
+    async getModelName() {
+        return this.deviceInfo?.modelName || '';
+    }
+
+    async getFirmware() {
+        return this.deviceInfo?.version || '';
+    }
+
+    async is4KSupported() {
+        return ['4k', '8k'].indexOf(this.screenSize) !== -1;
+    }
+
+    async is8KSupported() {
+        return this.screenSize === '8k';
+    }
+
+    async getUuid() {
+        return this.duid!;
+    }
+
+    async getVolume() {
+        // TODO: not yet implemented
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setVolume(volumePercentage: number) {
+        // TODO: not yet implemented
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async mute(mute: boolean) {
+        // TODO: not yet implemented
+    }
+
+    async isMute() {
+        // TODO: not yet implemented
+        return false;
+    }
+
+    async getScreenSaver() {
+        // not supported on LG webOS platform
+        return { enabled: false };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setScreenSaver(status: ScreenSaverStatus) {
+        // not supported on LG webOS platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string) {
+        // TODO: not yet implemented
+        return false;
+    }
+
+    async isNetworkConnected() {
+        if (this.connectionManager) {
+            return this.connectionManager.isInternetConnectionAvailable;
+        }
+        return true;
+    }
+
+    async getConnectionType() {
+        if (this.connectionManager) {
+            const { wired, wifi } = this.connectionManager;
+            if (isConnected(wired)) return 'cable';
+            if (isConnected(wifi)) return 'wifi';
+        }
+        return 'none';
+    }
+
+    async getLocalIP() {
+        if (this.connectionManager) {
+            const { wired, wifi } = this.connectionManager;
+            if (isConnected(wired)) return wired.ipAddress || '';
+            if (isConnected(wifi)) return wifi.ipAddress || '';
+        }
+        return '';
+    }
+
+    async getMacAddress() {
+        // Not supported on LG webOS platform (for date 12.4.2021, latest webOS TV 5.x)
+        return '';
+    }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Errors messages
+ */
+export const Errors = {
+    WEBOS: 'You are probably trying to launch driver outside webos environment.',
+    WEBOS_SERVICE: 'WebOS service API could not be loaded.',
+    WEBOS_DEVICE: 'WebOS device API could not be loaded.',
+    PALMSYSTEM: 'PalmSystem was not loaded.',
+    OUTDATED_WEBOS_LIB:
+        'Ooops, you are using outdated webOSTV.js {version}, required at least {requiredVersion}',
+} as const;
+
+export type BasePlatform = 'palm' | 'webos';
+
+export const ApiUrls = {
+    CONNECTION_MANAGER_PALM: 'luna://com.palm.connectionmanager',
+    CONNECTION_MANAGER_WEBOS: 'luna://com.webos.service.connectionmanager',
+    SYSTEM_PROPERTY: 'luna://com.webos.service.tv.systemproperty',
+    SM: 'luna://com.webos.service.sm',
+} as const;

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

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

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

@@ -0,0 +1,9 @@
+import { generateKeyCodeKeyMap, overrideValues } from '@24i/bigscreen-sdk/driver-base/keymap';
+
+export const getKeyMap = () => {
+    overrideValues({
+        BACK: { keyCode: 461 },
+        TXT: { keyCode: 110 },
+    });
+    return generateKeyCodeKeyMap();
+};

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

@@ -0,0 +1,344 @@
+import { ApiUrls } from './constants';
+
+export interface IWebOS {
+    /**
+     * A member representing the build version of the webOSTV.js library
+     */
+    readonly libVersion: '1.2.3',
+    /**
+     * A member representing the platform identification of webOS variants
+     */
+    readonly platform: {
+        /**
+         * Indicate whether the platform identification is webOS TV.
+         * If the platform identification is not webOS TV, undefined is returned.
+         */
+        tv?: true;
+    },
+    readonly keyboard: {
+        /**
+         * Checks whether the virtual keyboard is visible.
+         *
+         * @returns Indicates whether the virtual keyboard is displayed or hidden
+         * - true: the virtual keyboard is displayed
+         * - false: the virtual keyboard is hidden
+         */
+        isShowing(): boolean;
+    },
+    readonly service: {
+        /**
+         * Creates and sends a service request to the system of the webOS TV.
+         */
+        request<K extends keyof RequestTypeMap>(url: K, options: RequestTypeMap[K]): RequestObject,
+    },
+    /**
+     * Returns the device-specific information regarding the TV model,
+     * OS version, SDK version, screen size, and resolution
+     *
+     * @returns JSON object containing the device information details
+     */
+    deviceInfo(callback: (deviceInfo: DeviceInfo) => void): void,
+    /**
+     * Returns an app ID of an app calling this method
+     */
+    fetchAppId(): string,
+    /**
+     * Returns the full URI path of the caller app
+     *
+     * @returns The app's URI path where the app is located
+     */
+    fetchAppRootPath(): string,
+    /**
+     * Emulates the back key of the remote controller to move backward 1 level
+     */
+    platformBack(): void,
+    /**
+     * Returns the system-specific information regarding country, service country,
+     * and timezone
+     */
+    systemInfo(): SystemInfo,
+}
+
+/**
+ * The system-specific information regarding country, service country, and timezone.
+ */
+export type SystemInfo = Partial<{
+    /**
+     * The country that TV broadcasts.
+     * If the value does not exist, undefined is returned.
+     */
+    country?: string;
+    /**
+     * The country where the Smart service is provided.
+     * If the value does not exist, undefined is returned.
+     */
+    smartServiceCountry?: string;
+    /**
+     * The time zone that TV broadcasts.
+     * If the value does not exist, undefined is returned.
+     */
+    timezone?: string;
+}>;
+
+/**
+ * The device-specific information regarding the TV model, OS version, SDK version,
+ * screen size, and resolution.
+ */
+export type DeviceInfo = Partial<{
+    /**
+     * The model name of the device in UTF-8 format.
+     */
+    modelName: string,
+    /**
+     * The model name of the device in ASCII format.
+     */
+    modelNameAscii: string,
+    /**
+     * The full name of OS firmware version.
+     */
+    version: string,
+    /**
+     * The webOS SDK version.
+     */
+    sdkVersion: string;
+    /**
+     * The screen width in pixels.
+     */
+    screenWidth: number,
+    /**
+     * The screen Height in pixels.
+     */
+    screenHeight: number,
+    /**
+     * Indicates whether the device supports Ultra HD resolution.
+     * - true: The device supports Ultra HD resolution.
+     * - false: The device does not support Ultra HD resolution.
+     */
+    uhd: boolean,
+    /**
+     * Indicates whether the device supports 8K UHD resolution.
+     * - true: The device supports 8K UHD resolution.
+     * - false: The device does not support 8K UHD resolution.
+     */
+    uhd8K: boolean,
+}>;
+
+export type ConnectionManager = {
+    /**
+     * Indicates whether the internet connection is available.
+     * - true: The internet connection is available.
+     * - false: The internet connection is unavailable.
+     */
+    isInternetConnectionAvailable: boolean;
+    /**
+     * The object that contains information about the state of the wired connection.
+     */
+    wired: WiredStatus;
+    /**
+     * The object that contains information about the state of the WiFi connection.
+     */
+    wifi: WifiStatus;
+    /**
+     * The object that contains information about the state of the WiFi direct connection.
+     */
+    wifiDirect: WifiDirectStatus;
+};
+
+export type CommonInterfaceStatus = {
+    /**
+     * If the interface connection is available it will be set to 'connected'.
+     * If the interface connection is not available, it will be set to 'disconnected'.
+     */
+    state: ConnectionState;
+    /**
+     * Name of the Interface name in use. For example, ppp0.
+     */
+    interfaceName?: string;
+    /**
+     * The IP address associated with the interface connection.
+     */
+    ipAddress?: string;
+    /**
+     * The netmask value for the interface connection.
+     */
+    netmask?: string;
+    /**
+     * The IP address of the gateway.
+     */
+    gateway?: string;
+    /**
+     * Primary DNS address for the interface connection.
+     */
+    dns1?: string;
+    /**
+     * Secondary DNS address for the interface connection.
+     */
+    dns2?: string;
+    /**
+     * Tertiary DNS address for the interface connection.
+     */
+    dns3?: string;
+    /**
+     * If the IP address was assigned using the manual mode, method will contain 'Manual'.
+     * If the IP Address was assigned through DHCP, method will contain 'dhcp'.
+     */
+    method?: 'Manual' | 'dhcp';
+    /**
+     * The captive portal technique forces an HTTP client on a network to see a special web page
+     * (usually for authentication purposes) before using the Internet normally.
+     * Captive portals are used at most Wi-Fi hotspots.
+     * The onInternet will contain one of the following values:
+     * - 'yes' - indicating the WiFi connection is connected to the Internet.
+     * - 'no' - indicating the WiFi connection is not connected to the Internet.
+     */
+    onInternet?: 'yes' | 'no';
+};
+
+/**
+ * The wired object provides details on the status of the wired connections.
+ * Only if the wired connection is available will all the fields of this object
+ * contain the relevant information.
+ * If the wired connection is not available, the state field of this object will
+ * be set to disconnected and is the only value that is returned to the calling app.
+ */
+export type WiredStatus = CommonInterfaceStatus;
+
+/**
+ * The wifi object provides details on the status of the WiFi connection.
+ * Only if the WiFi connection is available all the fields of this object will
+ * contain the relevant information.
+ * If the WiFi connection is not available, only the state field of this object
+ * will be set to disconnected, and is the only value that is returned to the calling app.
+ */
+export type WifiStatus = CommonInterfaceStatus & {
+    /**
+     * The SSID of the connected service (if known).
+     */
+    ssid?: string;
+    /**
+     * If the Wi-Fi interface was set to stay up even when suspended,
+     * isWakeOnWiFiEnabled will contain true.
+     * If the Wi-Fi interface was not set to stay up when suspended,
+     * isWakeOnWiFiEnabled will contain false.
+     */
+    isWakeOnWiFiEnabled?: boolean;
+};
+
+/**
+ * The wifidirect object provides details on the status of the Wi-Fi direct connection.
+ * Only if the Wi-Fi direct connection is available all the fields of this object
+ * will contain the relevant information.
+ * If the Wi-Fi direct connection is not available, only the state field of this
+ * object will be set to disconnected,
+ * and is the only value that is returned to the calling app.
+ */
+export type WifiDirectStatus = {
+    /**
+     * If the Wi-Fi connection is available it will be set to 'connected'.
+     * If the Wi-Fi connection is not available, it will be set to 'disconnected'.
+     */
+    state: ConnectionState;
+    /**
+     * The IP address of the local connection endpoint.
+     */
+    localIp?: string;
+    /**
+     * A list of objects that provides information about connected peers.
+     */
+    connectedPeers?: any[];
+};
+
+type ConnectionState = 'connected' | 'disconnected';
+
+/**
+ * Resulting request object. This object can be used to cancel subscriptions.
+ */
+export type RequestObject = {
+    /**
+     * Sends the request. It is automatically called on creation. No argument
+     * is required.
+     */
+    send: Function,
+    /**
+     * Sends the request. It is automatically called on creation. No argument
+     * is required.
+     */
+    cancel: Function,
+};
+
+export type NegativeResponse = {
+    /**
+     * The flag that indicates the success/failure of the request.
+     */
+    returnValue: false,
+    /**
+     * errorCode contains the error code
+     */
+    errorCode: number | string,
+    /**
+     * errorText contains the error text
+     */
+    errorText: string,
+};
+
+export type PositiveResponse = {
+    /**
+     * The flag that indicates the success/failure of the request.
+     */
+    returnValue: true,
+};
+
+// MARK: ConnectionManager
+export type ConnectionManagerResponse = PositiveResponse & ConnectionManager;
+export type ConnectionManagerOptions = {
+    method: 'getStatus',
+    parameters: { subscribe: true },
+    onSuccess?: (response: NegativeResponse | ConnectionManagerResponse) => any,
+    onFailure?: (response: NegativeResponse) => any,
+    onComplete?: (response: NegativeResponse | ConnectionManagerResponse) => any,
+};
+
+// MARK: System property
+export type SystemPropertyResponse = PositiveResponse & {
+    modelName: string,
+    firmwareVersion: string,
+    UHD: 'true' | 'false',
+};
+export type SystemPropertyOptions = {
+    method: 'getSystemInfo',
+    parameters: {
+        keys: ['modelName', 'firmwareVersion', 'UHD'],
+    },
+    onSuccess?: (response: NegativeResponse | SystemPropertyResponse) => any,
+    onFailure?: (response: NegativeResponse) => any,
+    onComplete?: (response: NegativeResponse | SystemPropertyResponse) => any,
+};
+
+// MARK: DUID
+type Duid = {
+    idList: [
+        { idValue: string, idType: string },
+    ],
+};
+export type DuidResponse = PositiveResponse & Duid;
+export type DuidOptions = {
+    method: 'deviceid/getIDs',
+    parameters: {
+        idType: ['LGUDID'],
+    },
+    onSuccess?: (response: NegativeResponse | DuidResponse) => any,
+    onFailure?: (response: NegativeResponse) => any,
+    onComplete?: (response: NegativeResponse | DuidResponse) => any,
+};
+
+interface RequestTypeMap {
+    [ApiUrls.CONNECTION_MANAGER_PALM]: ConnectionManagerOptions,
+    [ApiUrls.CONNECTION_MANAGER_WEBOS]: ConnectionManagerOptions,
+    [ApiUrls.SYSTEM_PROPERTY]: SystemPropertyOptions,
+    [ApiUrls.SM]: DuidOptions,
+}
+
+// MARK: IPalmSystem
+export interface IPalmSystem {
+    deactivate: () => void,
+}