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

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

@@ -0,0 +1,366 @@
+export type KeyMap = {
+    [keyName: string]: number,
+};
+
+export type HbbTVKeys = {
+    readonly VK_UP: number,
+    readonly VK_DOWN: number,
+    readonly VK_LEFT: number,
+    readonly VK_RIGHT: number,
+    readonly VK_ENTER: number,
+    readonly VK_BACK: number,
+    readonly VK_PLAY: number,
+    readonly VK_PAUSE: number,
+    readonly VK_STOP: number,
+    readonly VK_FAST_FWD: number,
+    readonly VK_REWIND: number,
+    readonly VK_PLAY_PAUSE: number,
+    readonly VK_RED: number,
+    readonly VK_GREEN: number,
+    readonly VK_YELLOW: number,
+    readonly VK_BLUE: 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_CHANNEL_UP: number,
+    readonly VK_CHANNEL_DOWN: number,
+};
+
+export type ApplicationObject = {
+    show: () => void,
+    activate: () => void,
+    destroyApplication: () => void,
+    privateData: {
+        keyset: {
+            setValue: (mask: number) => void,
+        },
+    },
+};
+
+export type OIPFDeviceInfo = {
+    capabilities: string,
+    manufacturer: string,
+    modelName: string,
+    softwareVersion: string,
+    hardwareVersion: string,
+};
+
+export interface Channel {
+    /**
+     * Used in the channelType property to indicate a TV channel.
+     */
+    readonly TYPE_TV: number;
+
+    /**
+     * Used in the channelType property to indicate a radio channel.
+     */
+    readonly TYPE_RADIO: number;
+
+    /**
+     * Reserved for data services defined by [TS 102 796].
+     */
+    readonly TYPE_HBBTV_DATA: number;
+
+    /**
+     * Used in the idType property to indicate an analogue channel identified by
+     * the property: ‘freq’ and optionally ‘cni’ or ‘name’.
+     */
+    readonly ID_ANALOG: number;
+
+    /**
+     * Used in the idType property to indicate a DVB-C channel identified by the
+     * three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_DVB_C: number;
+
+    /**
+     * Used in the idType property to indicate a DVB-S channel identified by the
+     * three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_DVB_S: number;
+
+    /**
+     * Used in the idType property to indicate a DVB-T channel identified by the
+     * three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_DVB_T: number;
+
+    /**
+     * Used in the idType property to indicate a channel that is identified through
+     * its delivery system descriptor as defined by DVB-SI [EN300468] section
+     * 6.2.13.
+     */
+    readonly ID_DVB_SI_DIRECT: number;
+
+    /**
+     * Used in the idType property to indicate a DVB-C or DVB-C2 channel
+     * identified by the three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_DVB_C2: number;
+
+    /**
+     * Used in the idType property to indicate a DVB-S or DVB-S2 channel
+     * identified by the three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_DVB_S2: number;
+
+    /**
+     * Used in the idType property to indicate a DVB-T or DVB-T2 channel
+     * identified by the three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_DVB_T2: number;
+
+    /**
+     * Used in the idType property to indicate an ISDB-C channel identified by
+     * the three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_ISDB_C: number;
+
+    /**
+     * Used in the idType property to indicate an ISDB-S channel identified by
+     * the three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_ISDB_S: number;
+
+    /**
+     * Used in the idType property to indicate an ISDB-T channel identified by
+     * the three properties: ‘onid’, ‘tsid’, ‘sid’.
+     */
+    readonly ID_ISDB_T: number;
+
+    /**
+     * Used in the idType property to indicate a terrestrial ATSC channel
+     * identified by the property ‘sourceID’.
+     */
+    readonly ID_ATSC_T: number;
+
+    /**
+     * Used in the idType property to indicate an IP broadcast channel identified
+     * through SD&S by a DVB textual service identifier specified in the format
+     * “ServiceName.DomainName” as value for property ‘ipBroadcastID’, with
+     * ServiceName and DomainName as defined in [DVB-IPTV]. This idType
+     * SHALL be used to indicate Scheduled content service defined by [PROT]
+     */
+    readonly ID_IPTV_SDS: number;
+
+    /**
+     * Used in the idType property to indicate an IP broadcast channel identified
+     * by a DVB MCAST URI (e.g. i.e. dvb-mcast://), as value for property
+     * ‘ipBroadcastID’.
+     */
+    readonly ID_IPTV_URI: number;
+
+    /**
+     * The type of channel. The value MAY be indicated by one of the TYPE_*
+     * constants defined above. If the type of the channel is unknown then
+     * the value SHALL be “undefined”.
+     * NOTE: Values of this type between 256 and 511 are reserved for use by
+     * related specifications on request by liaison.
+     */
+    readonly channelType: number;
+
+    /**
+     * The type of identification for the channel, as indicated by one
+     * of the ID_* constants defined above
+     */
+    readonly idType: number;
+
+    /**
+     * Unique identifier of a channel within the scope of the OITF.
+     * The ccid is defined by the OITF and SHALL
+     * have prefix ‘ccid: e.g. ‘ccid:{tunerID.}majorChannel{.minorChannel}’.
+     * NOTE: the format of this string is platform-dependent.
+     */
+    readonly ccid: string;
+
+    /**
+     * Optional unique identifier of the tuner within the scope of the OITF
+     * that is able to receive the given channel.
+     */
+    readonly tunerID?: string;
+
+    /**
+     * DVB or ISDB original network ID.
+     */
+    readonly onid: number;
+
+    /**
+     * The DVB or ISDB network ID.
+     */
+    readonly nid: number;
+
+    /**
+     * DVB or ISDB transport stream ID.
+     */
+    readonly tsid: number;
+
+    /**
+     * DVB or ISDB service ID.
+     */
+    readonly sid: number;
+
+    /**
+     * ATSC source_ID value.
+     */
+    readonly sourceID: number;
+
+    /**
+     * For analogue channels, the frequency of the video carrier in kHz.
+     */
+    readonly freq: number;
+
+    /**
+     * For analogue channels, the VPS/PDC confirmed network identifier.
+     */
+    readonly cni: number;
+
+    /**
+     * The name of the channel. Can be used for linking analog channels
+     * without CNI. Typically, it will contain the call sign of the station (e.g. 'HBO').
+     */
+    readonly name: string;
+
+    /**
+     * The major channel number, if assigned. Value undefined otherwise. Typically
+     * used for channels of type ID_ATSC_* or for channels of type ID_DVB_* or
+     * ID_IPTV_SDS in markets where logical channel numbers are used.
+     */
+    readonly majorChannel: number;
+
+    /**
+     * The minor channel number, if assigned. Value undefined otherwise.
+     * Typically used for channels of type ID_ATSC_*.
+     */
+    readonly minorChannel: number;
+
+    /**
+     * For channels of type ID_DVB_SI_DIRECT created through createChannelObject,
+     * this property defines the delivery system descriptor (tuning parameters)
+     * as defined by DVB-SI [EN300468] section 6.2.13. The dsd property provides
+     * a string whose characters shall be restricted to the ISO Latin-1 character set.
+     * Each character in the dsd represents a byte of a delivery system descriptor as
+     * defined by DVB-SI [EN300468] section 6.2.13, such that a byte at position "i"
+     * in the delivery system descriptor is equal the Latin-1 character code of
+     * the character at position "i" in the dsd. Described in the syntax of JavaScript:
+     * let sdd[] be the byte array of a system delivery descriptor, in which
+     * sdd[0] is the descriptor_tag, then, dsd is its equivalent string, if :
+     * dsd.length==sdd.length and
+     * for each integer i : 0<=i<dsd.length holds: sdd[i] == dsd.charCodeAt(i).
+     */
+    readonly dsd: string;
+
+    /**
+     * Flag indicating whether the channel is marked as a favourite channel
+     * or not in one of the favourite lists as defined by property favouritelists.
+     */
+    readonly favourite: boolean;
+
+    /**
+     * The names of the favourite lists to which this channel belongs (see
+     * property favLists on object ChannelConfig).
+     */
+    readonly favIDs: string[];
+
+    /**
+     * Flag indicating whether the current state of the parental control system
+     * prevents the channel from being viewed (e.g. a correct parental control
+     * pin has not been entered). Note that this property supports the option of
+     * client-based management of parental control without excluding server-side
+     * implementation of parental control.
+     */
+    readonly locked: boolean;
+
+    /**
+     * Flag indicating whether the user has manually blocked viewing of this
+     * channel. Manual blocking of a channel will treat the channel as if its
+     * parental rating value always exceeded the system threshold.
+     * Note that this property supports the option of client-based management of manual
+     * blocking without excluding server-side management of blocked channels.
+     */
+    readonly manualBlock: boolean;
+
+    /**
+     * If the Channel has idType ID_IPTV_SDS, this element denotes the DVB textual
+     * service identifier of the IP broadcast service, specified in the format
+     * “ServiceName.DomainName” with the ServiceName and DomainName as defined in [DVB-IPTV].
+     * If the Channel has idType ID_IPTV_URI, this element denotes a URI of the
+     * IP broadcast service.
+     */
+    readonly ipBroadcastID: string;
+
+    /**
+     * If the channel has id Type ID_IPTV_SDS, this element denotes the maximum
+     * bitrate associated to the channel.
+     */
+    readonly channelMaxBitRate: number;
+
+    /**
+     * If the channel has idType ID_IPTV_SDS, this element denotes
+     * the TimeToRenegotiate associated to the channel.
+     */
+    readonly channelTTR: number;
+
+    /**
+     * Flag indicating whether the channel is available to the recording
+     * functionality of the OITF. If the value of the pvrEnabled property
+     * on the application/oipfConfiguration object as defined in section 7.3.2.1
+     * is false, this property SHALL also be false for all Channel objects.
+     */
+    readonly recordable: boolean;
+}
+
+export type ApplicationManagerObject = {
+    getOwnerApplication: (value: Document) => ApplicationObject;
+};
+
+export type OIPFConfigurationObject = {
+    keyset: {
+        value: number,
+        setValue: (value: number) => void,
+    }
+};
+
+export type ApplicationManager = ApplicationManagerObject & HTMLObjectElement;
+
+export type OIPFConfiguration = OIPFConfigurationObject & HTMLObjectElement;
+
+export interface ChannelConfig {
+    channelList: Channel[] | undefined;
+}
+
+export interface VideoBroadcastObject extends HTMLObjectElement {
+    type: 'video/broadcast';
+    width: string;
+    height: string;
+    readonly fullScreen: boolean;
+    onChannelChangeError(channel: any, errorState: number): void;
+    playState: number;
+    onPlayStateChange(state: number, error: number): void;
+    onChannelChangeSucceeded: (channel: any) => void;
+    onFullScreenChange: () => void | null;
+    onfocus(): void;
+    onblur(): void;
+    data: string;
+    getChannelConfig(): ChannelConfig;
+    bindToCurrentChannel(): void;
+    createChannelObject(idType: number, dsd: string, sid: number): any;
+    createChannelObject(idType: number, onid?: number, tsid?: number,
+        sid?: number, sourceID?: number, ipBroadcastID?: string): any;
+    setChannel(channel: any, trickplay?: boolean, contentAccessDescriptorURL?: string): void;
+    prevChannel(): void;
+    nextChannel(): void;
+    setFullScreen(fullscreen: boolean): void;
+    setVolume(volume: number): boolean;
+    getVolume(): number;
+    release(): void;
+    stop(): void;
+    readonly currentChannel: any;
+    createChannelList(bdr: string): any;
+}

package/packages/driver-kreatv/src/DeviceKreaTV.ts

@@ -0,0 +1,271 @@
+import {
+    DeviceBase,
+    ConnectionType,
+    ScreenSaverStatus,
+    VolumeRange,
+} from '@24i/bigscreen-sdk/driver-base';
+import { getKeyMap } from './keymap';
+import { toi2 } from './toi2';
+import { toi3 } from './toi3';
+import { ToiResolver } from './types';
+import {
+    Toi2Instance,
+    Toi3Instance,
+    ToiPowerControl,
+    ToiAudioConnectionDescriptor,
+    ToiNetDeviceInterfaceChangedEvent,
+    ToiPowerControlPowerProfileSelectedEvent,
+    ToiPowerControlPowerProfileRequestedEvent,
+} from './IToi';
+
+export class DeviceKreaTV extends DeviceBase {
+    keyMap = getKeyMap();
+
+    toiResolver: ToiResolver<Toi2Instance | Toi3Instance>;
+
+    toiInstance!: Toi2Instance | Toi3Instance;
+
+    audioConnectionsIds!: ToiAudioConnectionDescriptor['id'][];
+
+    powerControl!: ToiPowerControl;
+
+    constructor() {
+        super();
+        this.toiResolver = window.navigator.userAgent.match(/Ekioh\/3.4/) ? toi2 : toi3;
+    }
+
+    async initDevice(): Promise<void> {
+        this.toiInstance = await this.toiResolver.init();
+        this.initPowerControlListener();
+        this.initNetworkChangeListener();
+        this.audioConnectionsIds = this.getSupportedAudioConnections();
+    }
+
+    initPowerControlListener() {
+        const { consts, platformService } = this.toiInstance;
+        const {
+            ACCESS_REPORT_ONLY, ON_POWER_PROFILE_REQUESTED, ON_POWER_PROFILE_SELECTED,
+        } = consts.ToiPowerControl;
+        try {
+            this.powerControl = platformService.createPowerControlInstance(ACCESS_REPORT_ONLY);
+            this.powerControl.addEventListener(
+                ON_POWER_PROFILE_REQUESTED, this.onPowerProfileRequested,
+            );
+            this.powerControl.addEventListener(
+                ON_POWER_PROFILE_SELECTED, this.onPowerProfileSelected,
+            );
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed initPowerControlListener', e);
+        }
+    }
+
+    onPowerProfileRequested = (powerControlEvent: ToiPowerControlPowerProfileRequestedEvent) => {
+        const { profile } = powerControlEvent;
+        try {
+            this.powerControl.reportPowerProfile(profile);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed onPowerProfileRequested', e);
+        }
+    };
+
+    onPowerProfileSelected = (powerControlEvent: ToiPowerControlPowerProfileSelectedEvent) => {
+        const { profile } = powerControlEvent;
+        const { PROFILE_ACTIVE } = this.toiInstance.consts.ToiPowerControl;
+        const isVisible = profile === PROFILE_ACTIVE;
+        this.triggerEvent('visibilitychange', { isVisible });
+        try {
+            this.powerControl.reportPowerProfileActionsComplete();
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed onPowerProfileSelected', e);
+        }
+    };
+
+    initNetworkChangeListener() {
+        this.toiResolver.initNetworkChangeListener(this.networkChangeHandler);
+    }
+
+    networkChangeHandler = (network?: ToiNetDeviceInterfaceChangedEvent) => {
+        const isConnected = this.toiResolver.isNetworkConnected(network);
+        this.triggerEvent('networkchange', { isConnected });
+    };
+
+    reboot(): void {
+        const { consts, platformService } = this.toiInstance;
+        const { REBOOT_TYPE_NOW } = consts.ToiPlatformService;
+        platformService.reboot(REBOOT_TYPE_NOW);
+    }
+
+    exit(): void {
+        // not supported on KreaTV platform
+    }
+
+    async getManufacturerName(): Promise<string> {
+        return 'Arris';
+    }
+
+    async getPlatformName(): Promise<string> {
+        return 'KreaTV';
+    }
+
+    async getPlatformVersion(): Promise<string> {
+        const toiVersion = this.toiResolver.getToiVersion();
+        return `TOI ${toiVersion}`;
+    }
+
+    async getDeviceName(): Promise<string> {
+        const modelName = await this.getModelName();
+        const firmware = await this.getFirmware();
+        return `Arris ${modelName}, ${firmware}`;
+    }
+
+    async getModelName(): Promise<string> {
+        const { consts, informationService } = this.toiInstance;
+        const { CONST_HW_PRODUCTNAME } = consts.ToiInformationService;
+        try {
+            return informationService.getObject(CONST_HW_PRODUCTNAME);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed getModelName', e);
+        }
+        return '';
+    }
+
+    async getFirmware(): Promise<string> {
+        const { consts, informationService } = this.toiInstance;
+        const { CONST_FW_VERSION } = consts.ToiInformationService;
+        try {
+            return informationService.getObject(CONST_FW_VERSION);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed getFirmware', e);
+        }
+        return '';
+    }
+
+    async is4KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async is8KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async getUuid(): Promise<string> {
+        const { consts, informationService } = this.toiInstance;
+        const { CONST_HW_SERIALNUMBER } = consts.ToiInformationService;
+        try {
+            return informationService.getObject(CONST_HW_SERIALNUMBER);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed getUuid', e);
+        }
+        return '';
+    }
+
+    getSupportedAudioConnections() {
+        const { audioOutputService } = this.toiInstance;
+        const { ToiAudioOutputService } = this.toiInstance.consts;
+        const supportedAudioConnectionsType = [
+            ToiAudioOutputService.AUDIO_CONNECTION_TYPE_ANALOG,
+            ToiAudioOutputService.AUDIO_CONNECTION_TYPE_SPDIF,
+            ToiAudioOutputService.AUDIO_CONNECTION_TYPE_HDMI,
+        ];
+        const audioConnections = audioOutputService.getConnections() || [];
+        return audioConnections.reduce(
+            (
+                supportedAudioConnections: ToiAudioConnectionDescriptor['id'][],
+                audioConnection,
+            ) => {
+                const { id, type } = audioConnection;
+                if (supportedAudioConnectionsType.includes(type)) {
+                    supportedAudioConnections.push(id);
+                }
+                return supportedAudioConnections;
+            }, [],
+        );
+
+    }
+
+    async getVolume(): Promise<number> {
+        const { audioOutputService } = this.toiInstance;
+        for (let i = 0; i < this.audioConnectionsIds.length; i++) {
+            const connection = this.audioConnectionsIds[i];
+            try {
+                // Return first available audio connection volume
+                return audioOutputService.getVolume(connection);
+            } catch (e) {
+                console.error(`[DeviceKreaTV] Failed getVolume for connection: ${connection}`, e);
+            }
+        }
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    async setVolume(volumePercentage: number): Promise<void> {
+        const errorMsg = this.validateVolumeValue(volumePercentage);
+        if (errorMsg) throw new Error(errorMsg);
+
+        const { audioOutputService } = this.toiInstance;
+        this.audioConnectionsIds.forEach((connection) => {
+            try {
+                // Set volume for all connections
+                audioOutputService.setVolume(connection, volumePercentage);
+            } catch (e) {
+                console.error(`[DeviceKreaTV] Failed setVolume for connection: ${connection}`, e);
+            }
+        });
+    }
+
+    async mute(mute: boolean): Promise<void> {
+        const { audioOutputService } = this.toiInstance;
+        this.audioConnectionsIds.forEach((connection) => {
+            try {
+                // Set mute for all connections
+                audioOutputService.setMuteState(connection, mute);
+            } catch (e) {
+                console.error(`[DeviceKreaTV] Failed mute for connection: ${connection}`, e);
+            }
+        });
+    }
+
+    async isMute(): Promise<boolean> {
+        const { audioOutputService } = this.toiInstance;
+        for (let i = 0; i < this.audioConnectionsIds.length; i++) {
+            const connection = this.audioConnectionsIds[i];
+            try {
+                // Return first available audio connection mute state
+                return audioOutputService.getMuteState(connection);
+            } catch (e) {
+                console.error(`[DeviceKreaTV] Failed isMute for connection: ${connection}`, e);
+            }
+        }
+        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 KreaTV platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string): Promise<boolean> {
+        // not supported on KreaTV platform
+        return false;
+    }
+
+    async isNetworkConnected(): Promise<boolean> {
+        return this.toiResolver.isNetworkConnected();
+    }
+
+    async getConnectionType(): Promise<ConnectionType> {
+        return this.toiResolver.getConnectionType();
+    }
+
+    async getLocalIP(): Promise<string> {
+        return this.toiResolver.getLocalIP();
+    }
+
+    async getMacAddress(): Promise<string> {
+        return this.toiResolver.getMacAddress();
+    }
+}