@24i/bigscreen-sdk 1.0.54-alpha.2844 → 1.0.54-alpha.2845

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@24i/bigscreen-sdk",
-    "version": "1.0.54-alpha.2844",
+    "version": "1.0.54-alpha.2845",
     "description": "SmartApps BIGscreen SDK monorepo",
     "main": "index.js",
     "scripts": {
@@ -128,6 +128,7 @@
         "./driver-saphi": "./packages/driver-saphi/src/index.ts",
         "./driver-smartcast": "./packages/driver-smartcast/src/index.ts",
         "./driver-tizen": "./packages/driver-tizen/src/index.ts",
+        "./driver-vegaos": "./packages/driver-vegaos/src/index.ts",
         "./driver-vidaa": "./packages/driver-vidaa/src/index.ts",
         "./driver-webos/scripts/template": "./packages/driver-webos/scripts/template.ts",
         "./driver-webos/scripts/exportWebOSTVjs": "./packages/driver-webos/scripts/exportWebOSTVjs.ts",

package/packages/device/src/driver/index.vegaos.tv.ts

@@ -0,0 +1 @@
+export { DeviceVegaOS as Device } from '@24i/bigscreen-sdk/driver-vegaos';

package/packages/device/src/resolver/resolver.ts

@@ -7,6 +7,7 @@ import { DeviceHbbTV } from '@24i/bigscreen-sdk/driver-hbbtv';
 import { DeviceKreaTV } from '@24i/bigscreen-sdk/driver-kreatv';
 import { DeviceSaphi } from '@24i/bigscreen-sdk/driver-saphi';
 import { DeviceTizen } from '@24i/bigscreen-sdk/driver-tizen';
+import { DeviceVegaOS } from '@24i/bigscreen-sdk/driver-vegaos';
 import { DeviceVidaa } from '@24i/bigscreen-sdk/driver-vidaa';
 import { DeviceSmartCast } from '@24i/bigscreen-sdk/driver-smartcast';
 import { DeviceWebos } from '@24i/bigscreen-sdk/driver-webos';
@@ -34,6 +35,10 @@ const getDevice = () => {
         info('AndroidTV');
         return new DeviceAndroidTV();
     }
+    if (userAgent.match(/Kepler/)) {
+        info('VegaOS');
+        return new DeviceVegaOS();
+    }
     if (userAgent.match(/Tizen/)) {
         info('Tizen');
         return new DeviceTizen();

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

@@ -5,6 +5,7 @@ export { VolumeRange } from './VolumeRange';
 export type { ScreenSize } from './ScreenSize';
 export type { KeycodeKeyMap } from './types/KeycodeKeyMap';
 export type { DeviceEventMap } from './types/DeviceEvent';
+export type { AdInfo } from './types/AdInfo';
 export type {
     IAPSuccessPayload, IAPErrorPayload, IAPPromiseResolve, IAPPromiseReject, IAPPurchaseProductData,
 } from './types/InAppPurchase';

package/packages/driver-vegaos/src/DeviceVegaOS.ts

@@ -0,0 +1,223 @@
+import {
+    DeviceBase,
+    ConnectionType,
+    ScreenSaverStatus,
+    VolumeRange,
+    IAPSuccessPayload,
+    IAPPromiseReject,
+    IAPPromiseResolve,
+    IAPPurchaseProductData,
+    AdInfo,
+} from '@24i/bigscreen-sdk/driver-base';
+import { generateUuid } from '@24i/bigscreen-sdk/utils';
+import { VendorType } from '@24i/smartapps-datalayer/api';
+import { getKeyMap } from './keymap';
+import {
+    DeviceInfo,
+    IVegaOSBridge,
+    IAPErrorEventDetail,
+    IAPSuccessEventDetail,
+    Receipt,
+} from './types';
+
+declare global {
+    interface Window extends IVegaOSBridge {}
+}
+
+export class DeviceVegaOS extends DeviceBase {
+    keyMap = getKeyMap();
+
+    deviceInfo: DeviceInfo | null = null;
+
+    subscriptionFeaturesConfiguration = {
+        purchase: true,
+        management: false,
+    };
+
+    async initDevice(): Promise<void> {
+        this.initNetworkChangeListener();
+        this.hideCastButton();
+    }
+
+    hideCastButton(): void {
+        const style = document.createElement('style');
+        style.textContent = 'video::-internal-media-controls-overlay-cast-button{display:none}';
+        document.head.appendChild(style);
+    }
+
+    getDeviceInfo(): DeviceInfo | null {
+        if (this.deviceInfo) return this.deviceInfo;
+        try {
+            const deviceInfo = window.VegaOSBridge.getDeviceInfo();
+            if (deviceInfo) this.deviceInfo = deviceInfo;
+            return this.deviceInfo;
+        } catch {}
+        return this.deviceInfo;
+    }
+
+    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.VegaOSBridge.exit();
+    }
+
+    async getManufacturerName(): Promise<string> {
+        return this.getDeviceInfo()?.manufacturer || '';
+    }
+
+    async getPlatformName(): Promise<string> {
+        return 'VegaOS';
+    }
+
+    async getPlatformVersion(): Promise<string> {
+        return this.getDeviceInfo()?.platformVersion || '';
+    }
+
+    async getDeviceName(): Promise<string> {
+        const modelName = await this.getModelName();
+        const manufacturerName = await this.getManufacturerName();
+        return `VegaOS ${manufacturerName} ${modelName}`.trim();
+    }
+
+    async getModelName(): Promise<string> {
+        return this.getDeviceInfo()?.modelName || '';
+    }
+
+    async getFirmware(): Promise<string> {
+        return this.getDeviceInfo()?.firmwareVersion || '';
+    }
+
+    async is4KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async is8KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async getUuid(): Promise<string> {
+        return this.getBaseUuid();
+    }
+
+    async getAdInfo(): Promise<AdInfo> {
+        try {
+            const { adId, latEnabled } = window.VegaOSBridge.getAdInfo();
+            if (adId) return { adId, type: 'afai', latEnabled };
+        } catch {}
+        return { adId: generateUuid(), type: 'sessionid', latEnabled: null };
+    }
+
+    async getOsLanguage(): Promise<string> {
+        return this.getDeviceInfo()?.osLanguage || '';
+    }
+
+    async getVolume(): Promise<number> {
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    async getWrapperVersion(): Promise<string> {
+        return this.getDeviceInfo()?.wrapperVersion || '';
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setVolume(volumePercentage: number): Promise<void> {
+        // not supported on VegaOS platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async mute(mute: boolean): Promise<void> {
+        // not supported on VegaOS platform
+    }
+
+    async isMute(): Promise<boolean> {
+        return false;
+    }
+
+    async getScreenSaver(): Promise<ScreenSaverStatus> {
+        return { enabled: false };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setScreenSaver(status: ScreenSaverStatus): Promise<void> {
+        // not supported on VegaOS platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string): Promise<boolean> {
+        return false;
+    }
+
+    async isNetworkConnected(): Promise<boolean> {
+        return window.navigator.onLine;
+    }
+
+    async getConnectionType(): Promise<ConnectionType> {
+        // only wifi connection is supported on VegaOS platform
+        return 'wifi';
+    }
+
+    async getLocalIP(): Promise<string> {
+        return '';
+    }
+
+    async getMacAddress(): Promise<string> {
+        return '';
+    }
+
+    onIAPSuccess = (resolve: IAPPromiseResolve, reject: IAPPromiseReject) => (event: Event) => {
+        this.removeIAPListeners(resolve, reject);
+        try {
+            const { userId, receipt: receiptToParse } = (
+                event as CustomEvent<IAPSuccessEventDetail>
+            ).detail;
+            const receipt: Receipt = JSON.parse(receiptToParse);
+            window.VegaOSBridge.notifyFulfillment(receipt.receiptId);
+            resolve({
+                platform: VendorType.AMAZON,
+                receiptPayload: {
+                    userId,
+                    receiptId: receipt.receiptId,
+                },
+            });
+        } catch (e) {
+            reject(e);
+        }
+    };
+
+    onIAPError = (resolve: IAPPromiseResolve, reject: IAPPromiseReject) => (event: Event) => {
+        this.removeIAPListeners(resolve, reject);
+        reject(new Error((event as CustomEvent<IAPErrorEventDetail>).detail.message));
+    };
+
+    removeIAPListeners(resolve: IAPPromiseResolve, reject: IAPPromiseReject) {
+        document.removeEventListener('iapSuccess', this.onIAPSuccess(resolve, reject));
+        document.removeEventListener('iapError', this.onIAPError(resolve, reject));
+    }
+
+    async purchaseProduct(data: IAPPurchaseProductData): Promise<IAPSuccessPayload> {
+        return new Promise((resolve, reject) => {
+            document.addEventListener('iapSuccess', this.onIAPSuccess(resolve, reject));
+            document.addEventListener('iapError', this.onIAPError(resolve, reject));
+            window.VegaOSBridge.purchase(data.sku!);
+        });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async cancelSubscription(data: IAPPurchaseProductData): Promise<void> {
+        throw new Error('Not supported');
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+/* eslint-disable no-magic-numbers */
+import { KeyMap } from '@24i/bigscreen-sdk/driver-base';
+
+export const getKeyMap = () => {
+    KeyMap.overrideValues({
+        BACK: { keyCode: 8, alternativeKeyCodes: [27] },
+        FF: { keyCode: 228 },
+        REW: { keyCode: 227 },
+        PLAYPAUSE: { keyCode: 179 },
+    });
+    return KeyMap.generateKeyCodeKeyMap();
+};

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

@@ -0,0 +1,53 @@
+interface VegaOSBridge {
+    /**
+     * It returns a JSON string with device info.
+     */
+    getDeviceInfo: () => DeviceInfo,
+    /**
+     * It returns the advertising info of the device.
+     */
+    getAdInfo: () => VegaOSAdInfo,
+    /**
+     * It initiates the purchase-flow for the given SKU. The result is delivered
+     * asynchronously via the `iapSuccess` / `iapError` document events.
+     */
+    purchase: (sku: string) => void,
+    /**
+     * It notifies the Amazon Appstore that the purchase identified by the
+     * given receipt ID has been fulfilled.
+     */
+    notifyFulfillment: (receiptId: string) => void,
+    /**
+     * It exists the application.
+     */
+    exit: () => void,
+}
+
+export type DeviceInfo = {
+    manufacturer: string;
+    platformVersion: string;
+    firmwareVersion: string;
+    modelName: string;
+    osLanguage: string;
+    wrapperVersion: string;
+};
+
+export type VegaOSAdInfo = {
+    adId: string;
+    latEnabled: boolean;
+};
+
+export type Receipt = object & { receiptId: string };
+
+export type IAPSuccessEventDetail = {
+    userId: string;
+    receipt: string;
+};
+
+export type IAPErrorEventDetail = {
+    message: string;
+};
+
+export interface IVegaOSBridge {
+    VegaOSBridge: VegaOSBridge,
+}