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

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

@@ -0,0 +1,379 @@
+/* eslint-disable no-magic-numbers */
+interface ToiInstanceBase {
+    /**
+     * ToiAudioOutputService is used for controlling audio outputs. It allows the client to control
+     * how to decode and mix audio content and route the modified/unmodified content to the outputs.
+     */
+    audioOutputService: ToiAudioOutputService;
+    /**
+     * The Information Service is a responsible for collecting and storing information objects, i.e.
+     * simple string key/value pairs. The data is retrieved from different adapters, e.g. infocast,
+     * flash file system and firmware. Each adapter is a source and possibly a destination where the
+     * information object can be set.
+     */
+    informationService: ToiInformationService;
+    /**
+     * The Platform Service contains functions for rebooting, standby and factory reset.
+     */
+    platformService: ToiPlatformService;
+}
+
+export interface Toi2Instance extends ToiInstanceBase {
+    /**
+     * Consts property are used to access constants for objects otherwise only accessible through
+     * instantiating functions.
+     */
+    consts: Toi2Consts;
+    /**
+     * ToiNetService is used to configure and retrieving information about logical networks.
+     * A logical network (aka network) is a collection of everything in the system required to
+     * allow network access. This includes network interfaces, DNS, routing and Wi-Fi management.
+     */
+    netService: Toi2NetService;
+}
+
+export interface Toi3Instance extends ToiInstanceBase {
+    /**
+     * Consts property are used to access constants for objects otherwise only accessible through
+     * instantiating functions.
+     */
+    consts: Toi3Consts;
+    /**
+     * Version of TOI JavaScript API.
+     */
+    version: string;
+    /**
+     * ToiNetService is used to configure and retrieving information about logical networks.
+     * A logical network (aka network) is a collection of everything in the system required to
+     * allow network access. This includes network interfaces, DNS, routing and Wi-Fi management.
+     */
+    netService: Toi3NetService;
+}
+
+interface ToiConstsBase {
+    ToiAudioOutputService: {
+        AUDIO_CONNECTION_TYPE_ANALOG: 0;
+        AUDIO_CONNECTION_TYPE_SPDIF: 1;
+        AUDIO_CONNECTION_TYPE_HDMI: 2;
+        AUDIO_CONNECTION_TYPE_DECODER: 3;
+        AUDIO_CONNECTION_TYPE_BUFFER: 4;
+        AUDIO_CONNECTION_TYPE_I2S: 5;
+    },
+    ToiInformationService: {
+        CONST_FW_VERSION: 'const._fw.version';
+        CONST_HW_PRODUCTNAME: 'const.hw.productname';
+        CONST_HW_SERIALNUMBER: 'const.hw.serialnumber';
+        CONST_IP_ETH0_MAC: 'const.ip.eth0.mac';
+        VAR_IP_ETH0_ADDR: 'var.ip.eth0.addr';
+    },
+    ToiPlatformService: {
+        REBOOT_TYPE_NOW: 0;
+    },
+    ToiPowerControl: {
+        ACCESS_REPORT_ONLY: 0;
+        ON_POWER_PROFILE_REQUESTED: 4400;
+        ON_POWER_PROFILE_SELECTED: 4401;
+        PROFILE_ACTIVE: 0;
+    }
+}
+
+interface Toi2Consts extends ToiConstsBase {
+    ToiNetConfiguration: {
+        NET_DEVICE_TYPE_ALL: 255;
+        NET_DEVICE_TYPE_ETHERNET: 1;
+        NET_DEVICE_TYPE_WIFI: 16;
+    },
+    ToiNetService: {
+        ON_DEVICE_INTERFACE_READINESS_CHANGED: 4406;
+    },
+}
+
+interface Toi3Consts extends ToiConstsBase {
+    ToiNetService: {
+        BOOT_NETWORK: '_boot_network_';
+    },
+    ToiNetwork: {
+        ON_NETWORK_INFO_CHANGED: 4500;
+        INTERFACE_TYPE_ETHERNET: 0;
+        INTERFACE_TYPE_WIFI: 1;
+        STATE_DISABLED: 0;
+        STATE_WAITING: 1;
+        STATE_FAILED: 2;
+        STATE_READY: 3;
+    },
+}
+
+type Toi3NetworkStates = (
+    | Toi3Consts['ToiNetwork']['STATE_DISABLED']
+    | Toi3Consts['ToiNetwork']['STATE_WAITING']
+    | Toi3Consts['ToiNetwork']['STATE_FAILED']
+    | Toi3Consts['ToiNetwork']['STATE_READY']
+);
+
+export interface ToiAudioOutputService {
+    /**
+     * Returns available audio connections.
+     * @return The list available audio connections
+     */
+    getConnections: () => ToiAudioConnectionDescriptor[];
+    /**
+     * Returns the mutes state of a connection.
+     * @param connectionId The identifier of the connection to query
+     * @return The mute state
+     */
+    getMuteState: (connectionId: ToiAudioConnectionDescriptor['id']) => boolean;
+    /**
+     * Returns the audio volume level of a connection. Possible level range from 0 and 100 where
+     * 0 is the lowest volume and 100 the highest volume.
+     * @param connectionId The identifier of the connection to query
+     * @return The volume level
+     */
+    getVolume: (connectionId: ToiAudioConnectionDescriptor['id']) => number;
+    /**
+     * Sets the mute state of a connection.
+     * @param connectionId The identifier of the connection to query
+     */
+    setMuteState: (connectionId: ToiAudioConnectionDescriptor['id'], state: boolean) => void;
+    /**
+     * Set an audio connection volume level. The level can be adjusted between 0 and 100 where
+     * 0 is the lowest volume and 100 the highest volume. The volume is only affected if the
+     * content is decoded or non compressed.
+     * @param connectionId The identifier of the connection to query
+     */
+    setVolume: (connectionId: ToiAudioConnectionDescriptor['id'], level: number) => void;
+}
+
+export interface ToiAudioConnectionDescriptor {
+    /**
+     * A unique identifier among all connections.
+     */
+    id: number;
+    /**
+     * The connection type.
+     */
+    type: (
+        | ToiConstsBase['ToiAudioOutputService']['AUDIO_CONNECTION_TYPE_ANALOG']
+        | ToiConstsBase['ToiAudioOutputService']['AUDIO_CONNECTION_TYPE_HDMI']
+    );
+}
+
+export interface ToiInformationService {
+    /**
+     * This method is used to get a value of an object. If the object does not exist in
+     * any adapter, an exception is thrown.
+     * @param objectName The name of the object
+     * @returns The value of the object
+     */
+    getObject: (objectName: string) => string;
+}
+
+export interface Toi2NetService {
+    /**
+     * This method registers an event listener for a specific event. Multiple listeners
+     * can be added for the same event. Events are broadcast to all registered listeners.
+     * @param type The event type of the event to subscribe to
+     * @param listener The JavaScript function that will receive events
+     */
+    addEventListener: (type: number, listener: Function) => void;
+    /**
+     * Returns the network configuration.
+     * @returns The ToiNetConfiguration address
+     */
+    getConfiguration: () => ToiNetConfiguration;
+}
+
+/**
+ * Bit mask values indicating the type of the network device.
+ */
+export type ToiNetDeviceType = (
+    | Toi2Consts['ToiNetConfiguration']['NET_DEVICE_TYPE_ALL']
+    | Toi2Consts['ToiNetConfiguration']['NET_DEVICE_TYPE_ETHERNET']
+    | Toi2Consts['ToiNetConfiguration']['NET_DEVICE_TYPE_WIFI']
+);
+
+export interface ToiNetConfiguration {
+    /**
+     * Returns available network devices of specified types.
+     * @param typeMask The bit mask of types of the network devices
+     * @returns Identifiers of the available network devices
+     */
+    getNetworkDevices: (typeMask: ToiNetDeviceType) => number[];
+    /**
+     * Returns the generic network device info.
+     * @param deviceId network device identifier
+     * @returns The network device info
+     */
+    getGenericDeviceInfo: (deviceId: number) => ToiNetConfigurationNetDeviceInfo;
+}
+
+/**
+ * Called when network interface has changed. In case the interface readiness changes.
+ */
+export interface ToiNetDeviceInterfaceChangedEvent {
+    /**
+     * The network device info.
+     */
+    deviceInfo: ToiNetConfigurationNetDeviceInfo;
+}
+
+/**
+ * The network device info.
+ */
+export interface ToiNetConfigurationNetDeviceInfo {
+    /**
+     * The network device type.
+     */
+    type: ToiNetDeviceType;
+    /**
+     * Indicates whether the network device has link or not.
+     */
+    hasLink: boolean;
+    /**
+     * Indicates whether the network device is enabled or not.
+     */
+    isEnabled: boolean;
+    /**
+     * Indicates whether the network device is ready or not. When device is ready it
+     * means it is enabled, has link and at least one configured interface, i.e. one
+     * interface with successfully acquired IP address.
+     */
+    isReady: boolean;
+}
+
+export interface Toi3NetService {
+    /**
+     * Returns the network with the specified name.
+     * @param networkName The name of the network
+     * @returns The ToiNetwork address
+     */
+    getNetwork: (networkName: string) => ToiNetwork;
+    /**
+     * Returns information about the available network interfaces.
+     * @returns Information about the available network interfaces
+     */
+    getNetworkInterfaces: () => ToiInterfaceInfo[];
+}
+
+/**
+ * This interface represents a logical network. A logical network encapsulates
+ * a network interface and settings used to configure the network interface
+ * and the system's network-related properties such as DNS and routes.
+ */
+export interface ToiNetwork {
+    /**
+     * This method registers an event listener for a specific event. Multiple
+     * listeners can be added for the same event. Events are broadcast to all
+     * registered listeners.
+     * @param type The event type of the event to subscribe to
+     * @param listener The JavaScript function that will receive events
+     */
+    addEventListener: (type: number, listener: Function) => void;
+    /**
+     * This method returns the current status of the network.
+     * @returns The current network info
+     */
+    getNetworkInfo: () => ToiInformation;
+}
+
+/**
+ * Describes the current status of the network.
+ */
+export interface ToiInformation {
+    /**
+     * The current interface info, such as IP address, statistics and more.
+     */
+    interfaceInfo: ToiInterfaceInfo;
+    /**
+     * The current network state indicating whether the network is ready to be used.
+     */
+    state: Toi3NetworkStates;
+}
+
+export interface ToiInterfaceInfo {
+    /**
+     * Indicates whether the interface has link.
+     */
+    hasLink: boolean;
+    /**
+     * The hardware address (MAC).
+     */
+    mac: string;
+    /**
+     * IP addresses associated with this interface.
+     */
+    ipAddresses: Array<{ ipAddress: string, netmask: string }>;
+    /**
+     * The interface type (Ethernet or Wi-Fi).
+     */
+    type: (
+        | Toi3Consts['ToiNetwork']['INTERFACE_TYPE_ETHERNET']
+        | Toi3Consts['ToiNetwork']['INTERFACE_TYPE_WIFI']
+    );
+}
+
+/**
+ * The Platform Service contains functions for rebooting, standby and factory reset.
+ */
+export interface ToiPlatformService {
+    /**
+     * This method creates a power control instance that allows an application
+     * to do power management.
+     * @param access Determines if the registering application wants to be able to
+     * have access to initiate power profile switches
+     * @returns Address to an ToiPowerControl interface
+     */
+    createPowerControlInstance: (
+        access: ToiConstsBase['ToiPowerControl']['ACCESS_REPORT_ONLY']
+    ) => ToiPowerControl;
+    /**
+     * Reboot the platform.
+     * @param rebootType What type of reboot that should take place
+     */
+    reboot: (rebootType: number) => void;
+}
+
+/**
+ * ToiPowerControl is used for power management.
+ */
+export interface ToiPowerControl {
+    /**
+     * This method registers an event listener for a specific event. Multiple
+     * listeners can be added for the same event. Events are broadcast to
+     * all registered listeners.
+     * @param type The event type of the event to subscribe to
+     * @param listener The JavaScript function that will receive events
+     */
+    addEventListener: (type: number, listener: Function) => void;
+    /**
+     * When a profile switch has been initiated this call is used to report
+     * the currently lowest possible power profile.
+     * @param profile Denotes the lowest power profile currently possible for
+     * the responding application/service.
+     */
+    reportPowerProfile: (profile: number) => void;
+    /**
+     * This call is used to acknowledge that the selected power profile can now be executed.
+     */
+    reportPowerProfileActionsComplete: () => void;
+}
+
+/**
+ * This call is used by the power control to initiate a switch in the power profile.
+ */
+export interface ToiPowerControlPowerProfileRequestedEvent {
+    profile: ToiPowerProfile['PROFILE_ACTIVE'];
+}
+
+/**
+ * This call is used by the power control to communicate the selected profile.
+ */
+export interface ToiPowerControlPowerProfileSelectedEvent {
+    profile: ToiPowerProfile['PROFILE_ACTIVE'];
+}
+
+/**
+ * These power profiles are a mix of European Power Code of Conduct, Energy Star and IEC.
+ */
+export interface ToiPowerProfile {
+    PROFILE_ACTIVE: 0;
+}

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

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

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

@@ -0,0 +1,31 @@
+/* eslint-disable no-magic-numbers */
+import { KeyMap } from '@24i/bigscreen-sdk/driver-base';
+
+export const getKeyMap = () => {
+    KeyMap.overrideValues({
+        BACK: { keyCode: 917536 },
+
+        RED: { keyCode: 917504 },
+        GREEN: { keyCode: 917505 },
+        YELLOW: { keyCode: 917506 },
+        BLUE: { keyCode: 917507 },
+
+        PLAYPAUSE: { keyCode: 917528 },
+        STOP: { keyCode: 917522 },
+        FF: { keyCode: 917524 },
+        REW: { keyCode: 917523 },
+        REC: { keyCode: 917527 },
+
+        HOME: { keyCode: 917783 },
+        CHANNEL_UP: { keyCode: 917552 },
+        CHANNEL_DOWN: { keyCode: 917553 },
+        VOL_UP: { keyCode: 917747 },
+        VOL_DOWN: { keyCode: 917748 },
+        MUTE: { keyCode: 917744 },
+        TXT: { keyCode: 917777 },
+        TOOLS: { keyCode: 917555 },
+        INFO: { keyCode: 917556 },
+        GUIDE: { keyCode: 917776 },
+    });
+    return KeyMap.generateKeyCodeKeyMap();
+};

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

@@ -0,0 +1,107 @@
+import { Toi2Resolver, Toi2Window, ToiHTMLEmbedElement, ToiResolver } from './types';
+import { Toi2Instance, ToiNetDeviceInterfaceChangedEvent } from './IToi';
+
+declare const window: Toi2Window;
+
+const TOI_EMBED_ELEMENT_ID = 'toiplugin';
+const TOI_EMBED_ELEMENT_TYPE = 'application/x-kreatv-toi';
+
+export const toi2: ToiResolver<Toi2Instance, Toi2Resolver> = {
+    toiHtmlEmbedElement: null!,
+    toiInstance: null!,
+    init: async () => {
+        const toiHtmlEmbedElement = document.getElementById(TOI_EMBED_ELEMENT_ID);
+        if (toiHtmlEmbedElement) {
+            toi2.toiHtmlEmbedElement = toiHtmlEmbedElement as ToiHTMLEmbedElement;
+        } else {
+            const embedElement = document.createElement('embed');
+            embedElement.id = TOI_EMBED_ELEMENT_ID;
+            embedElement.type = TOI_EMBED_ELEMENT_TYPE;
+            embedElement.setAttribute('hidden', 'true');
+            document.body.appendChild(embedElement);
+            toi2.toiHtmlEmbedElement = embedElement as ToiHTMLEmbedElement;
+        }
+        const toiInstance = window.toi;
+        toi2.toiInstance = toiInstance;
+        return toiInstance;
+    },
+    getToiVersion: () => {
+        const { version } = toi2.toiHtmlEmbedElement;
+        return version || '';
+    },
+    initNetworkChangeListener: (
+        networkChangeHandler: (network: ToiNetDeviceInterfaceChangedEvent) => void,
+    ) => {
+        const { consts, netService } = toi2.toiInstance;
+        const { ON_DEVICE_INTERFACE_READINESS_CHANGED } = consts.ToiNetService;
+        try {
+            netService.addEventListener(
+                ON_DEVICE_INTERFACE_READINESS_CHANGED, networkChangeHandler,
+            );
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed initNetworkChangeListener', e);
+        }
+    },
+    isNetworkConnected: (networkEvent: ToiNetDeviceInterfaceChangedEvent) => {
+        let network;
+        if (!networkEvent) {
+            const { consts, netService } = toi2.toiInstance;
+            const { NET_DEVICE_TYPE_ALL } = consts.ToiNetConfiguration;
+            try {
+                const netServiceConfiguration = netService.getConfiguration();
+                const networkDevices = netServiceConfiguration.getNetworkDevices(
+                    NET_DEVICE_TYPE_ALL,
+                );
+                network = netServiceConfiguration.getGenericDeviceInfo(networkDevices[0]);
+            } catch (e) {
+                console.error('[DeviceKreaTV] Failed isNetworkConnected', e);
+            }
+        } else {
+            network = networkEvent.deviceInfo;
+        }
+        // All three parameters need to be true hasLink, isEnabled, isReady
+        return !!network?.hasLink && !!network?.isEnabled && !!network?.isReady;
+    },
+    getConnectionType: () => {
+        const { consts, netService } = toi2.toiInstance;
+        const {
+            NET_DEVICE_TYPE_ALL, NET_DEVICE_TYPE_ETHERNET, NET_DEVICE_TYPE_WIFI,
+        } = consts.ToiNetConfiguration;
+        const netServiceConfiguration = netService.getConfiguration();
+        try {
+            const networkDevices = netServiceConfiguration.getNetworkDevices(NET_DEVICE_TYPE_ALL);
+            const { type } = netServiceConfiguration.getGenericDeviceInfo(networkDevices[0]);
+            switch (type) {
+                case NET_DEVICE_TYPE_ETHERNET:
+                    return 'cable';
+                case NET_DEVICE_TYPE_WIFI:
+                    return 'wifi';
+                default:
+                    return 'unknown';
+            }
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed getConnectionType', e);
+        }
+        return 'unknown';
+    },
+    getLocalIP: () => {
+        const { consts, informationService } = toi2.toiInstance;
+        const { VAR_IP_ETH0_ADDR } = consts.ToiInformationService;
+        try {
+            return informationService.getObject(VAR_IP_ETH0_ADDR);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed getLocalIP', e);
+        }
+        return '';
+    },
+    getMacAddress: () => {
+        const { consts, informationService } = toi2.toiInstance;
+        const { CONST_IP_ETH0_MAC } = consts.ToiInformationService;
+        try {
+            return informationService.getObject(CONST_IP_ETH0_MAC);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed getMacAddress', e);
+        }
+        return '';
+    },
+};

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

@@ -0,0 +1,102 @@
+import { Toi3Resolver, Toi3Window, ToiResolver } from './types';
+import { Toi3Instance, ToiInterfaceInfo, ToiNetDeviceInterfaceChangedEvent } from './IToi';
+
+declare const window: Toi3Window;
+
+const TOI_URL = 'http://localhost:8000/toi/toi.js';
+const READY_STATE_DONE = 4;
+const STATUS_CODE_OK = 200;
+
+export const toi3: ToiResolver<Toi3Instance, Toi3Resolver> = {
+    toiInstance: null!,
+    init: async () => {
+        const bootstrapUrl = TOI_URL;
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', bootstrapUrl, false);
+        let retrievalFailed = false;
+        try {
+            xhr.send();
+            if (xhr.readyState !== READY_STATE_DONE || xhr.status !== STATUS_CODE_OK) {
+                retrievalFailed = true;
+            }
+        } catch (e) {
+            retrievalFailed = true;
+        }
+        if (retrievalFailed) {
+            throw new Error(`Unable to retrieve ${bootstrapUrl}`);
+        }
+        // eslint-disable-next-line no-eval
+        eval.call(window, xhr.responseText);
+
+        const toiInstance = new window.Toi();
+        toi3.toiInstance = toiInstance;
+        return toiInstance;
+    },
+    getBootNetwork: () => {
+        const { consts, netService } = toi3.toiInstance;
+        const { BOOT_NETWORK } = consts.ToiNetService;
+        try {
+            return netService.getNetwork(BOOT_NETWORK);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed getNetwork', e);
+        }
+        return null;
+    },
+    getToiVersion: () => {
+        const { version } = toi3.toiInstance;
+        return version || '';
+    },
+    initNetworkChangeListener: (
+        networkChangeHandler: (network: ToiNetDeviceInterfaceChangedEvent) => void,
+    ) => {
+        const bootNetwork = toi3.getBootNetwork();
+        if (!bootNetwork) return;
+        const { ON_NETWORK_INFO_CHANGED } = toi3.toiInstance.consts.ToiNetwork;
+        try {
+            bootNetwork.addEventListener(ON_NETWORK_INFO_CHANGED, networkChangeHandler);
+        } catch (e) {
+            console.error('[DeviceKreaTV] Failed initNetworkChangeListener', e);
+        }
+    },
+    isNetworkConnected: () => {
+        const bootNetwork = toi3.getBootNetwork();
+        if (!bootNetwork) return false;
+        const { STATE_READY } = toi3.toiInstance.consts.ToiNetwork;
+        const { state } = bootNetwork.getNetworkInfo();
+        return state === STATE_READY;
+    },
+    getConnectionType: () => {
+        const bootNetwork = toi3.getBootNetwork();
+        if (!bootNetwork) return 'unknown';
+        const { INTERFACE_TYPE_ETHERNET, INTERFACE_TYPE_WIFI } = toi3.toiInstance.consts.ToiNetwork;
+        const { interfaceInfo } = bootNetwork.getNetworkInfo();
+        switch (interfaceInfo.type) {
+            case INTERFACE_TYPE_ETHERNET:
+                return 'cable';
+            case INTERFACE_TYPE_WIFI:
+                return 'wifi';
+            default:
+                return 'unknown';
+        }
+    },
+    getLocalIP: () => {
+        const { netService } = toi3.toiInstance;
+        const networks = netService.getNetworkInterfaces();
+        let ip = '';
+        networks.forEach(({ hasLink, ipAddresses }: ToiInterfaceInfo) => {
+            // last ip address with link is used
+            if (hasLink && ipAddresses) ip = ipAddresses[0].ipAddress;
+        });
+        return ip;
+    },
+    getMacAddress: () => {
+        const { netService } = toi3.toiInstance;
+        const networks = netService.getNetworkInterfaces();
+        let macAddress = '';
+        networks.forEach(({ hasLink, mac }: ToiInterfaceInfo) => {
+            // last mac address with link is used
+            if (hasLink && mac) macAddress = mac;
+        });
+        return macAddress;
+    },
+};

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

@@ -0,0 +1,35 @@
+import { ConnectionType } from '@24i/bigscreen-sdk/driver-base';
+import { Toi2Instance, Toi3Instance, ToiNetDeviceInterfaceChangedEvent, ToiNetwork } from './IToi';
+
+export type ToiResolver<T, U = {}> = {
+    toiInstance: T;
+    init: () => Promise<T>;
+    getToiVersion: () => string;
+    initNetworkChangeListener: (
+        networkChangeHandler: (network: ToiNetDeviceInterfaceChangedEvent) => void
+    ) => void;
+    isNetworkConnected: (network?: any) => boolean;
+    getConnectionType: () => ConnectionType;
+    getLocalIP: () => string;
+    getMacAddress: () => string;
+} & U;
+
+export interface Toi2Window extends Window {
+    toi: Toi2Instance;
+}
+
+export interface Toi3Window extends Window {
+    Toi: { new (): Toi3Instance; }
+}
+
+export interface ToiHTMLEmbedElement extends HTMLEmbedElement {
+    version: string;
+}
+
+export interface Toi2Resolver {
+    toiHtmlEmbedElement: ToiHTMLEmbedElement;
+}
+
+export interface Toi3Resolver {
+    getBootNetwork: () => ToiNetwork | null;
+}