senza-sdk 4.4.3 → 4.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.4.3",
+    "version": "4.4.4",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",

package/src/api.js

@@ -1,6 +1,6 @@
 import { sdkLogger, noop } from "./interface/utils.js";
 
-import { Lifecycle, RemotePlayer, DeviceManager, PlatformManager, AlarmManager, MessageManager, ShakaPlayer, shaka, showSequence, initSequence } from "./interface/api.js";
+import { Lifecycle, RemotePlayer, DeviceManager, PlatformManager, AlarmManager, MessageManager, ShakaPlayer, shaka, showSequence, initSequence, DisplayManager } from "./interface/api.js";
 
 import { version } from "./interface/version.js";
 
@@ -252,6 +252,18 @@ let alarmManager;
  */
 let deviceManager;
 
+/**
+ * @module
+ * @private
+ * @type {DisplayManager}
+ * @example
+ * import { displayManager } from "senza-sdk";
+ * const connection = await displayManager.connection;
+ * console.info(connection);
+ *
+ * @return {DisplayManager} pointer to the DisplayManager singleton
+ */
+let displayManager;
 
 /**
  * @module
@@ -317,6 +329,7 @@ if (!isRunningE2E()) {
     remotePlayer = new RemotePlayer();
     alarmManager = new AlarmManager();
     deviceManager = new DeviceManager();
+    displayManager = new DisplayManager();
     platformManager = new PlatformManager();
     messageManager = new MessageManager();
     ShakaPlayerImplementation = ShakaPlayer;
@@ -327,6 +340,7 @@ if (!isRunningE2E()) {
     remotePlayer = window.senzaSDKImplementation.remotePlayer;
     alarmManager = window.senzaSDKImplementation.alarmManager;
     deviceManager = window.senzaSDKImplementation.deviceManager;
+    displayManager = window.senzaSDKImplementation.displayManager;
     platformManager = window.senzaSDKImplementation.platformManager;
     messageManager = window.senzaSDKImplementation.messageManager;
     ShakaPlayerImplementation = window.senzaSDKImplementation.ShakaPlayer;
@@ -373,7 +387,7 @@ export function setTimezone(timezone) {
     }
 }
 
-export { lifecycle, remotePlayer, alarmManager, deviceManager, platformManager, messageManager, ShakaPlayerImplementation as ShakaPlayer, shakaImplementation as shaka, showSequence, initSequence };
+export { lifecycle, remotePlayer, alarmManager, deviceManager, displayManager, platformManager, messageManager, ShakaPlayerImplementation as ShakaPlayer, shakaImplementation as shaka, showSequence, initSequence };
 
 // Assign the senza library to the old name (hs) for backward compatibility
 import * as senzaSDK from "./api.js";

package/src/implementation/api.js

@@ -4,11 +4,13 @@ import { lifecycle } from "./lifecycle.js";
 import { alarmManager } from "./alarmManager.js";
 import { remotePlayer } from "./remotePlayer.js";
 import { deviceManager } from "./deviceManager.js";
+import { displayManager } from "./displayManager.js";
 import { messageManager } from "./messageManager.js";
 
 export { remotePlayer };
-export { lifecycle } from "./lifecycle.js";
+export { lifecycle };
 export { deviceManager };
+export { displayManager };
 export { platformManager } from "./platformManager.js";
 export { alarmManager };
 export { messageManager };
@@ -101,9 +103,9 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         }
 
         // Set default device manager event timeout using UI-Streamer settings
-        const deviceManagerEventTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.deviceManagerEventTimeout;
-        if (deviceManagerEventTimeout) {
-            deviceManager._setDefaultTimeout(deviceManagerEventTimeout);
+        const displayManagerEventTimeout = sessionInfoObj?.settings?.["ui-streamer"]?.displayManagerEventTimeout;
+        if (displayManagerEventTimeout) {
+            displayManager._setDefaultTimeout(displayManagerEventTimeout);
         }
 
         // Get trigger event
@@ -139,7 +141,7 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         await remotePlayer._init(sessionInfoObj, triggerEvent);
         alarmManager._init();
         messageManager._init();
-        deviceManager._init();
+        await displayManager._init();
         sdkLogger.log("All submodules initialized");
 
 

package/src/implementation/deviceManager.js

@@ -1,9 +1,6 @@
 import { DeviceManager as DeviceManagerInterface } from "../interface/deviceManager";
 import { getFCID, sdkLogger, getRestResponse } from "./utils";
 import { sessionInfo } from "./SessionInfo";
-import { EventListenersManager } from "./eventListenersManager";
-import { bus, Events } from "./eventBus";
-import { lifecycle } from "./lifecycle";
 
 let wifi_ap_data;
 let wifi_status;
@@ -41,134 +38,6 @@ class DeviceManager extends DeviceManagerInterface {
 
     constructor() {
         super();
-
-        /**
-         * Mapping of CEC active source status to HdmiStatus.
-         * @type {Object}
-         * @private
-         */
-        this._cecActiveSourceStatusMap = Object.freeze({
-            active: this.HdmiStatus.ACTIVE,
-            inactive: this.HdmiStatus.INACTIVE,
-            unknown: this.HdmiStatus.UNKNOWN
-        });
-
-        /**
-         * Event listeners manager for the deviceManager events
-         * @type {EventListenersManager}
-         * @private
-         */
-        this._eventManager = new EventListenersManager({
-            timeoutMs: 10000 // Default timeout of 10 seconds, can be overridden by _setDefaultTimeout
-        });
-
-        /**
-         * @type {boolean}
-         * @private
-         */
-        this._isInitialized = false;
-    }
-
-    /**
-     * @private
-     */
-    _init() {
-        sdkLogger.log("Initializing DeviceManager");
-        if (!this._isInitialized) {
-            this._isInitialized = true;
-            this._addSenzaEventListeners();
-        }
-    }
-
-    /**
-     * Translate the HdmiStatus information to a single HdmiStatus for the application
-     * 1) cecStatus is a configuration setting from the client. If false, we always return UNKNOWN to the application
-     * 2) If cecStatus is true, we check the hdmiStatus. If not "connected", the HDMI status is definitely INACTIVE.
-     * 3) If hdmiStatus is "connected" and cecStatus is true, we rely on the cecActiveSourceStatus to determine the HdmiStatus
-     * @private
-     */
-    _translateHdmiStatus(hdmiStatusStr) {
-        const hdmiStatusObj = JSON.parse(hdmiStatusStr ?? "{}"); // Object containing the 3 statuses
-        let hdmiStatus = this.HdmiStatus.UNKNOWN;
-        if (hdmiStatusObj?.cecStatus) {
-            if (hdmiStatusObj.hdmiStatus !== "connected") {
-                hdmiStatus = this.HdmiStatus.INACTIVE;
-            } else {
-                const cecActive = this._cecActiveSourceStatusMap[hdmiStatusObj.cecActiveSourceStatus];
-                hdmiStatus = cecActive ?? this.HdmiStatus.UNKNOWN;
-                if (!cecActive) {
-                    sdkLogger.warn(`Unknown CEC active source status: ${hdmiStatusObj.cecActiveSourceStatus}`);
-                }
-            }
-        } else {
-            sdkLogger.warn("cec is disabled or no hdmiStatus");
-        }
-        sdkLogger.log("HDMI status is:", hdmiStatus);
-        return hdmiStatus;
-    }
-
-    /**
-     * @private Add event listeners for system events
-     */
-    _addSenzaEventListeners() {
-        bus.addEventListener(Events.LifecycleForeground, () => {
-            this._moveToForegroundHasBeenCalled = true;
-        });
-
-        typeof document !== "undefined" && document.addEventListener("hs/hdmiStatusChanged", async (event) => {
-            sdkLogger.info("Got hs/hdmiStatusChanged event with detail", JSON.stringify(event?.detail));
-
-            const hdmiStatus = this._translateHdmiStatus(event?.detail?.hdmiStatus);
-
-            const timeBeforeCallbacks = Date.now();
-
-            // Dispatch event to application and allow a chance to move to foreground.
-            // If there are no callbacks or the application doesn't move to foreground, the UI will be disconnected.
-            await this._eventManager.dispatch("hdmistatuschanged", {hdmiStatus});
-
-            const callbackDuration = Date.now() - timeBeforeCallbacks;
-            sdkLogger.log(`All callbacks for hdmiStatusChanged are finished within ${callbackDuration}ms`);
-            const isTriggering = lifecycle.triggerEvent.type === "hdmiStatusChanged" && lifecycle._triggerEventFcid && lifecycle._triggerEventFcid === event.detail.fcid;
-            if (isTriggering) {
-                if (!this._moveToForegroundHasBeenCalled && window.cefQuery) {
-                    sdkLogger.log("Application is about to be disconnected since didn't move to foreground");
-                    const message = { type: "disconnect" };
-                    const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
-                    window.cefQuery({
-                        request: JSON.stringify(request),
-                        persistent: false,
-                        onSuccess: () => {
-                            sdkLogger.log("disconnect request successfully sent");
-                        },
-                        onFailure: (code, msg) => {
-                            sdkLogger.error(`disconnect request failed: ${code} ${msg}`);
-                        }
-                    });
-                }
-            }
-        });
-    }
-
-    /**
-     * Set the default timeout for device manager event listeners
-     * @param {number} timeout - Timeout in milliseconds for device manager event listeners
-     * @private
-     */
-    _setDefaultTimeout(timeout) {
-        if (typeof timeout === "number" && timeout > 0) {
-            this._eventManager.timeoutMs = timeout;
-            sdkLogger.log(`DeviceManager event listener timeout set to ${timeout}ms`);
-        } else {
-            sdkLogger.warn(`Invalid timeout value: ${timeout}. Must be a positive number.`);
-        }
-    }
-
-    addEventListener(type, callback) {
-        this._eventManager.addEventListener(type, callback);
-    }
-
-    removeEventListener(type, callback) {
-        this._eventManager.removeEventListener(type, callback);
     }
 
     get deviceInfo() {
@@ -188,16 +57,6 @@ class DeviceManager extends DeviceManagerInterface {
         return super.deviceInfo;
     }
 
-    async getHdmiStatus() {
-        try {
-            const response = await getRestResponse("hdmi-status");
-            return this._translateHdmiStatus(response);
-        } catch (e) {
-            sdkLogger.error(e);
-            return this.HdmiStatus.UNKNOWN;
-        }
-    }
-
     reboot() {
         return new Promise((resolve, reject) => {
             if (window.cefQuery) {

package/src/implementation/displayManager.js

@@ -0,0 +1,181 @@
+import { DisplayManager as DisplayManagerInterface } from "../interface/displayManager";
+import { sdkLogger, getRestResponse } from "./utils";
+import { parseEdid } from "./edidParser";
+import { EventListenersManager } from "./eventListenersManager";
+import { bus, Events } from "./eventBus";
+import { lifecycle } from "./lifecycle";
+
+
+export class DisplayManager extends DisplayManagerInterface {
+
+    constructor() {
+        super();
+        /**
+        * Event listeners manager for the displayManager events
+        * @type {EventListenersManager}
+        * @private
+        */
+        this._eventManager = new EventListenersManager({
+            timeoutMs: 10000 // Default timeout of 10 seconds, can be overridden by _setDefaultTimeout
+        });
+
+        /**
+        * @type {boolean}
+        * @private
+        */
+        this._isInitialized = false;
+    }
+
+    async _updateDisplayInfo() {
+        try {
+            const displayInfoResponse = await getRestResponse("display-info");
+            const displayInfo = this._parseDisplayInfo(displayInfoResponse);
+            this._setDisplayProperties(displayInfo);
+        } catch (e) {
+            sdkLogger.error(e);
+            this._setDisplayProperties({ connection: this.DisplayConnectionStatus.UNKNOWN });
+        }
+    }
+
+    async _init() {
+        sdkLogger.log("Initializing DisplayManager");
+        await this._updateDisplayInfo();
+        if (!this._isInitialized) {
+            this._isInitialized = true;
+            this._addSenzaEventListeners();
+        }
+    }
+
+    /**
+     * @private Add event listeners for system events
+     */
+    _addSenzaEventListeners() {
+        bus.addEventListener(Events.LifecycleForeground, () => {
+            this._moveToForegroundHasBeenCalled = true;
+        });
+
+        typeof document !== "undefined" && document.addEventListener("hs/displayInfoChanged", async (event) => {
+            sdkLogger.info("Got hs/displayInfoChanged event with detail", JSON.stringify(event?.detail));
+
+            try {
+                const displayInfo = this._parseDisplayInfo(event.detail.displayInfo);
+                this._setDisplayProperties(displayInfo);
+
+                const timeBeforeCallbacks = Date.now();
+
+                // Dispatch event to application and allow a chance to move to foreground.
+                // If there are no callbacks or the application doesn't move to foreground, the UI will be disconnected.
+                await this._eventManager.dispatch("displayinfochanged", { displayInfo });
+
+                const callbackDuration = Date.now() - timeBeforeCallbacks;
+                sdkLogger.log(`All callbacks for displayInfoChanged are finished within ${callbackDuration}ms`);
+            } catch (error) {
+                sdkLogger.error("Failed to handle displayInfo update", error);
+            }
+
+            const isTriggering = lifecycle.triggerEvent.type === "displayInfoChanged" && lifecycle._triggerEventFcid && lifecycle._triggerEventFcid === event.detail.fcid;
+            if (isTriggering) {
+                if (!this._moveToForegroundHasBeenCalled && window.cefQuery) {
+                    sdkLogger.log("Application is about to be disconnected since didn't move to foreground");
+                    const message = { type: "disconnect" };
+                    const request = { target: "TC", waitForResponse: false, message: JSON.stringify(message) };
+                    window.cefQuery({
+                        request: JSON.stringify(request),
+                        persistent: false,
+                        onSuccess: () => {
+                            sdkLogger.log("disconnect request successfully sent");
+                        },
+                        onFailure: (code, msg) => {
+                            sdkLogger.error(`disconnect request failed: ${code} ${msg}`);
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    /**
+    * Set the default timeout for display manager event listeners
+    * @param {number} timeout - Timeout in milliseconds for display manager event listeners
+    * @private
+    */
+    _setDefaultTimeout(timeout) {
+        if (typeof timeout === "number" && timeout > 0) {
+            this._eventManager.timeoutMs = timeout;
+            sdkLogger.log(`displayManager event listener timeout set to ${timeout}ms`);
+        } else {
+            sdkLogger.warn(`Invalid timeout value: ${timeout}. Must be a positive number.`);
+        }
+    }
+
+    _setDisplayProperties(displayInfo) {
+
+        if (displayInfo.connection !== undefined) {
+            this.connection = displayInfo.connection;
+        }
+
+        // If the connection is disconnected/unknown, reset all the display properties
+        if (this.connection !== this.DisplayConnectionStatus.CONNECTED) {
+            this.selected = undefined;
+            this.resolution = undefined;
+            this.framerate = undefined;
+            this.security = undefined;
+            this.make = undefined;
+            this.model = undefined;
+            return;
+        }
+
+        for (const [key, value] of Object.entries(displayInfo)) {
+            if (value !== undefined) {
+                this[key] = value;
+            }
+        }
+    }
+
+    _parseDisplayInfo(displayInfoResponseStr) {
+        const displayInfoResponse = JSON.parse(displayInfoResponseStr);
+
+        const displayInfo = {
+            connection: displayInfoResponse?.connection,
+            selected: displayInfoResponse?.connectedDisplayInfo?.selected,
+            resolution: displayInfoResponse?.connectedDisplayInfo?.resolution,
+            framerate: displayInfoResponse?.connectedDisplayInfo?.framerate,
+            security: displayInfoResponse?.connectedDisplayInfo?.hdcpVersion
+        };
+
+
+        if (displayInfoResponse?.connectedDisplayInfo?.edid) {
+            try {
+                const { manufacturerName, modelName } = parseEdid(displayInfoResponse.connectedDisplayInfo.edid);
+                displayInfo.make = manufacturerName ? manufacturerName : "unknown";
+                displayInfo.model = modelName ? modelName : "unknown";
+            } catch (error) {
+                sdkLogger.error("Failed to parse EDID", error);
+                displayInfo.make = "unknown";
+                displayInfo.model = "unknown";
+            }
+        }
+        return displayInfo;
+    }
+
+    addEventListener(type, callback) {
+        this._eventManager.addEventListener(type, callback);
+    }
+
+    removeEventListener(type, callback) {
+        this._eventManager.removeEventListener(type, callback);
+    }
+}
+
+
+/**
+ * @module
+ * @type {DisplayManager}
+ * @example
+ * import { displayManager } from "senza-sdk";
+ * const connection = await displayManager.connection;
+ * console.info(connection);
+ *
+ * @return {DisplayManager} pointer to the DisplayManager singleton
+ */
+export const displayManager = new DisplayManager();

package/src/implementation/edidParser.js

@@ -0,0 +1,125 @@
+const MANUFACTURER_MAP = {
+    // Major PC & Display Brands
+    ACR: "Acer",
+    APP: "Apple",
+    AOC: "AOC",
+    AUO: "AU Optronics",
+    BNQ: "BenQ",
+    BOE: "BOE Technology",
+    CMN: "Innolux (Chimei Innolux)",
+    CMO: "Chi Mei Optoelectronics",
+    CPQ: "Compaq",
+    DELL: "Dell", // some EDIDs use DEL
+    DEL: "Dell",
+    EIZ: "EIZO",
+    FUS: "Fujitsu",
+    HPN: "HP",
+    HWP: "HP",
+    IVM: "Iiyama",
+    LEN: "Lenovo",
+    LPL: "LG Philips LCD",
+    LGE: "LG Electronics",
+    GSM: "LG Electronics (GoldStar)",
+    MEI: "Panasonic (Matsushita)",
+    NEC: "NEC",
+    NVD: "Nvidia",
+    PHL: "Philips",
+    PHI: "Philips",
+    SAM: "Samsung",
+    SNY: "Sony",
+    TOS: "Toshiba",
+    VSC: "ViewSonic",
+    VIZ: "Vizio",
+
+    // Panel Makers / ODMs
+    CPT: "Chunghwa Picture Tubes",
+    HSD: "HannStar Display",
+    QDS: "Quanta Display",
+    SEC: "Samsung Electronics Display",
+    SHP: "Sharp",
+    TMX: "Tianma",
+    CMI: "Chi Mei Innolux",
+
+    // Other common consumer brands
+    JVC: "JVC (Victor Company of Japan)",
+    PIO: "Pioneer",
+    FUN: "Funai",
+    GRN: "Grundig",
+    MAG: "MAG Innovision",
+    TCL: "TCL",
+    HAI: "Haier",
+    HIT: "Hitachi",
+    SMC: "Sumitomo",
+    WAC: "Wacom",
+    ASUS: "ASUSTek", // often ASU
+    ASU: "ASUS",
+    GIG: "Gigabyte",
+    MSI: "Micro-Star International",
+
+    // Catch-alls / misc seen in monitors
+    ENC: "Energizer",
+    ZOW: "Zowie",
+    TTX: "Tatung",
+    KDS: "KDS",
+    HIS: "HIS",
+    XXX: "TCL",
+    XMD: "Xiaomi"
+};
+
+// --- helpers ---
+function hexToBytes(hex) {
+    const clean = hex.replace(/[^0-9a-fA-F]/g, "");
+    if (clean.length % 2 !== 0) throw new Error("Hex length must be even");
+    const out = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < clean.length; i += 2) {
+        out[i / 2] = parseInt(clean.slice(i, i + 2), 16);
+    }
+    return out;
+}
+
+function decodeEisaId(word) {
+    const a = (word >> 10 & 0x1f) + 64;
+    const b = (word >> 5 & 0x1f) + 64;
+    const c = (word & 0x1f) + 64;
+    return [a, b, c].map(n => n >= 65 && n <= 90 ? String.fromCharCode(n) : "?").join("");
+}
+
+function sanitizeEdidString(bytes) {
+    let out = "";
+    for (const b of bytes) {
+        if (b === 0x00 || b === 0x0a) break;
+        if (b >= 0x20 && b <= 0x7e) out += String.fromCharCode(b);
+    }
+    return out.trim();
+}
+
+
+export function parseEdid(input) {
+    const edid = input instanceof Uint8Array ? input : hexToBytes(input);
+
+    // Manufacturer ID (bytes 8–9)
+    const mfgWord = edid[8] << 8 | edid[9];
+    const manufacturerId = decodeEisaId(mfgWord);
+    const manufacturerName = MANUFACTURER_MAP[manufacturerId] || manufacturerId;
+
+    // Product code (bytes 10–11)
+    const productCode = (edid[10] | edid[11] << 8) >>> 0;
+    const modelNumber = String(productCode);
+
+    // Monitor name descriptor (0xFC) and serial number descriptor (0xFF) in base block
+    let modelName;
+    let serialNumber;
+    for (let off = 0x36; off <= 0x7e - 18; off += 18) {
+        const d = edid.slice(off, off + 18);
+        if (d[0] === 0x00 && d[1] === 0x00 && d[2] === 0x00) {
+            if (d[3] === 0xFC) {
+                modelName = sanitizeEdidString(d.slice(5, 18));
+            } else if (d[3] === 0xFF) {
+                serialNumber = sanitizeEdidString(d.slice(5, 18));
+            }
+        }
+    }
+
+    return { manufacturerName, modelName, modelNumber, serialNumber };
+}
+

package/src/implementation/remotePlayer.js

@@ -246,6 +246,7 @@ class RemotePlayer extends RemotePlayerInterface {
 
         typeof document !== "undefined" && document.addEventListener("hs/EOS", () => {
             sdkLogger.info("Got hs/EOS event");
+            this._changePlayMode(false);
             this.dispatchEvent(new Event("ended"));
         });
 
@@ -790,10 +791,12 @@ class RemotePlayer extends RemotePlayerInterface {
                     fcid: FCID
                 };
                 if (this._uiAvSyncIntervalMs !== undefined) {
-                    message.uiAvSyncIntervalMs = this._uiAvSyncIntervalMs;
+                    message.connectorSettings = message.connectorSettings || {};
+                    message.connectorSettings.uiAvSyncIntervalMs = this._uiAvSyncIntervalMs;
                 }
                 if (this._abrAvSyncIntervalMs !== undefined) {
-                    message.abrAvSyncIntervalMs = this._abrAvSyncIntervalMs;
+                    message.connectorSettings = message.connectorSettings || {};
+                    message.connectorSettings.abrAvSyncIntervalMs = this._abrAvSyncIntervalMs;
                 }
                 if (this._remotePlayerApiVersion >= 2) {
                     message.type = "remotePlayer.load";

package/src/interface/api.js

@@ -1,5 +1,6 @@
 export { Lifecycle } from "./lifecycle.js";
 export { DeviceManager } from "./deviceManager.js";
+export { DisplayManager } from "./displayManager.js";
 export { PlatformManager } from "./platformManager.js";
 export { AlarmManager } from "./alarmManager.js";
 export { MessageManager } from "./messageManager.js";

package/src/interface/deviceManager.js

@@ -1,32 +1,9 @@
 import { sdkLogger, noop } from "./utils.js";
 
-/**
- * @event DeviceManager#hdmistatuschanged
- * @description Fired when the HDMI connection status changes.<br>
- * @property {HdmiStatus} hdmiStatus - the status of the HDMI connection.
- * @example
- * deviceManager.addEventListener("hdmistatuschanged", (e) => {
- *     console.info("HDMI status changed:", e.detail.hdmiStatus);
- * });
- * @private
- */
-
 /**
  * DeviceManager is a singleton class that manages the device.<br>
- * @fires hdmistatuschanged
  */
 export class DeviceManager extends EventTarget {
-    /**
-     * @typedef {Object} HdmiStatus - The HDMI status of the device
-     * @property {string} ACTIVE - The device is connected to the active HDMI source.
-     * @property {string} INACTIVE - The active HDMI source is different than the one connected to the device or the TV is in standby.
-     * @property {string} UNKNOWN - The status is unknown. This can happen if the TV does not support HDMI status detection.
-     */
-    HdmiStatus = Object.freeze({
-        ACTIVE: "active",
-        INACTIVE: "inactive",
-        UNKNOWN: "unknown"
-    });
 
     /**
      * @property {object} DeviceInfo
@@ -54,16 +31,6 @@ export class DeviceManager extends EventTarget {
 
     }
 
-    /**
-     * Get the current HDMI status from the connector
-     * @return {Promise<HdmiStatus>} Promise which is resolved when getHdmiStatus has been successfully performed
-     * Failure to getHdmiStatus for any reason, results in the promise being rejected.
-     * @private
-     */
-    getHdmiStatus() {
-        return noop("DeviceManager.getHdmiStatus");
-    }
-
     /**
      * Reboot the device
      * @return {Promise} Promise which is resolved when the reboot command has been successfully processed.