senza-sdk 4.4.4-86e7d7a.0 → 4.4.5

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/lifecycle.js

@@ -62,6 +62,12 @@ class Lifecycle extends LifecycleInterface {
         this._autoBackgroundOnUIDelay = DEFAULT_AUTO_BACKGROUND_UI_DELAY;
     }
 
+    // List of event types that should use the _eventManager
+    static _waitForListenersEvents = [
+        "userdisconnected","beforestatechange"
+        // Add more event types here if needed in the future
+    ];
+
     /**
      * @private Initialize the lifecycle
      * @param {Object} uiStreamerSettings - UI-streamer portion of the settings taken from session info
@@ -177,7 +183,7 @@ class Lifecycle extends LifecycleInterface {
             const event = new Event("onstatechange");
             event.state = e.detail;
             this._state = event.state;
-            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
+            if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
                 this._startCountdown();
             }
             this.dispatchEvent(event);
@@ -213,7 +219,7 @@ class Lifecycle extends LifecycleInterface {
 
         // Add playModeChange listener
         remotePlayer.addEventListener("playModeChange", (event) => {
-            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
+            if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
                 sdkLogger.log("Resetting auto background timer due to play mode change", event.detail.isPlaying);
                 this._startCountdown(event.detail.isPlaying);
             }
@@ -221,6 +227,14 @@ class Lifecycle extends LifecycleInterface {
         sdkLogger.log("[Lifecycle] Added event listeners for system events");
     }
 
+    /**
+     * @private Checks if the UI is in foreground or transitioning to foreground.
+     * @returns {boolean}
+     */
+    _isForegroundOrTransitioning() {
+        return this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND;
+    }
+
     /**
      * @private Checks if auto background is enabled including overrides.
      * @returns {boolean}
@@ -284,7 +298,7 @@ class Lifecycle extends LifecycleInterface {
             }
 
             // Start or stop countdown based on new configuration
-            if (this._isAutoBackgroundEnabled()) {
+            if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
                 this._startCountdown();
             } else {
                 this._stopCountdown();
@@ -364,7 +378,7 @@ class Lifecycle extends LifecycleInterface {
 
     set autoBackground(enabled) {
         this._autoBackground = enabled;
-        if (this._isAutoBackgroundEnabled()) {
+        if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning()) {
             this._startCountdown();
         } else {
             this._stopCountdown();
@@ -377,7 +391,7 @@ class Lifecycle extends LifecycleInterface {
 
     set autoBackgroundDelay(delay) {
         this._autoBackgroundOnVideoDelay = delay;
-        if (this._isAutoBackgroundEnabled() && remotePlayer._isPlaying) {
+        if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning() && remotePlayer._isPlaying) {
             this._startCountdown();
         }
     }
@@ -388,7 +402,7 @@ class Lifecycle extends LifecycleInterface {
 
     set autoBackgroundOnUIDelay(delay) {
         this._autoBackgroundOnUIDelay = delay;
-        if (this._isAutoBackgroundEnabled() && !remotePlayer._isPlaying) {
+        if (this._isAutoBackgroundEnabled() && this._isForegroundOrTransitioning() && !remotePlayer._isPlaying) {
             this._startCountdown();
         }
     }
@@ -408,9 +422,24 @@ class Lifecycle extends LifecycleInterface {
         // Only start countdown if delay is positive
         if (timeoutDelay > 0) {
             sdkLogger.debug("Starting countdown timeout", timeoutDelay, isPlaying ? "(video)" : "(UI)");
-            this._countdown = setTimeout(() => {
+            this._countdown = setTimeout(async () => {
                 sdkLogger.debug("Countdown timeout reached, moving to background");
-                this.moveToBackground();
+
+                // Create the event with cancelable: true
+                const event = new Event("beforestatechange", { cancelable: true });
+                event.state = this.UiState.BACKGROUND;
+                // Use the event manager to dispatch the event and wait for all listeners
+                await this._eventManager.dispatch("beforestatechange", event);
+                // Check if any listener called preventDefault()
+                if (event.defaultPrevented) {
+                    sdkLogger.info("moveToBackground was prevented by a listener");
+                    // Restart the countdown since the move was cancelled
+                    if (this._isForegroundOrTransitioning()) {
+                        this._startCountdown();
+                    }
+                } else {
+                    this.moveToBackground();
+                }
             }, timeoutDelay * 1000);
         } else {
             sdkLogger.debug("Countdown not started - delay is negative or zero");
@@ -424,8 +453,8 @@ class Lifecycle extends LifecycleInterface {
         if (this._countdown) {
             sdkLogger.debug("Stopping countdown timer");
             clearTimeout(this._countdown);
+            this._countdown = null;
         }
-        this._countdown = null;
     }
 
     /**
@@ -459,7 +488,7 @@ class Lifecycle extends LifecycleInterface {
     moveToForeground() {
         if (window.cefQuery) {
             const inTransition = this._isInTransition();
-            if (inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
+            if (inTransition || this._isForegroundOrTransitioning()) {
                 sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${inTransition}`);
                 return Promise.resolve(false);
             }
@@ -771,23 +800,19 @@ class Lifecycle extends LifecycleInterface {
         return Promise.reject("disconnect is not supported if NOT running e2e");
     }
 
+
     addEventListener(type, listener, options) {
-        if (type === "userdisconnected") {
-            // Use the event manager for userdisconnected events
+        if (Lifecycle._waitForListenersEvents.includes(type)) {
             this._eventManager.addEventListener(type, listener);
         } else {
-            // For all other event types, use the parent class implementation
             super.addEventListener(type, listener, options);
         }
     }
 
-
     removeEventListener(type, listener, options) {
-        if (type === "userdisconnected") {
-            // Use the event manager for userdisconnected events
+        if (Lifecycle._waitForListenersEvents.includes(type)) {
             this._eventManager.removeEventListener(type, listener);
         } else {
-            // For all other event types, use the parent class implementation
             super.removeEventListener(type, listener, options);
         }
     }

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.

package/src/interface/displayManager.js

@@ -0,0 +1,126 @@
+/**
+ * @event DisplayManager#displayinfochanged
+ * @description Fired when the display information changes.
+ * @property {DisplayInfoChanged} [detail.displayInfo] - the updated display information.
+ * @example
+ * @private
+ * displayManager.addEventListener("displayinfochanged", (e) => {
+ *     console.info("Display information changed:", e.detail.displayInfo);
+ * });
+ */
+
+/**
+ * @typedef {Object} DisplayInfoChanged
+ * @property {DisplayConnectionStatus | undefined} connection   Display connection status.
+ * @property {DisplaySelectedStatus | undefined} selected     Display selected status.
+ * @property {DisplayResolution | undefined} resolution   Display resolution information.
+ * @property {number | undefined} framerate    Display frame rate.
+ * @property {string | undefined} security     Display HDCP / security level.
+ * @property {string | undefined} make         Display vendor (make) information.
+ * @property {string | undefined} model       Display model information.
+ * @private
+ */
+
+/**
+ * DisplayManager exposes information about the connected display / sink device.
+ * It allows querying several negotiated HDMI parameters and (for a subset) receiving change notifications.
+ * @private
+ * @fires displayinfochanged
+ */
+export class DisplayManager extends EventTarget {
+    /**
+     * @typedef {Object} DisplayConnectionStatus
+     * @property {string} CONNECTED   Display is connected and communication established.
+     * @property {string} DISCONNECTED Display cable removed / not detected.
+     * @property {string} UNKNOWN      The platform cannot determine (e.g. unsupported).
+     * @private
+     */
+    DisplayConnectionStatus = Object.freeze({
+        CONNECTED: "connected",
+        DISCONNECTED: "disconnected",
+        UNKNOWN: "unknown"
+    });
+
+    /**
+     * @typedef {Object} DisplaySelectedStatus
+     * @property {string} ACTIVE     The display input where the device is connected is currently active.
+     * @property {string} INACTIVE   The device is connected but another source is active / TV in standby.
+     * @property {string} UNKNOWN  The platform cannot determine (e.g. unsupported).
+     * @private
+     */
+    DisplaySelectedStatus = Object.freeze({
+        ACTIVE: "active",
+        INACTIVE: "inactive",
+        UNKNOWN: "unknown"
+    });
+
+    /**
+     * @typedef {Object} DisplayResolution
+     * @property {number} width   Negotiated active horizontal pixels
+     * @property {number} height  Negotiated active vertical pixels
+     * @property {boolean} interlace True if the negotiated mode is interlaced
+     * @private
+     */
+
+    /**
+     * Display connection status.
+     * @property {DisplayConnectionStatus} connection
+     */
+    connection = this.DisplayConnectionStatus.DISCONNECTED;
+
+    /**
+     * Whether the display input this device is connected to is currently active.
+     * undefined when the display is not connected.
+     * @property {DisplaySelectedStatus} selected
+     */
+    selected;
+
+    /**
+     * Negotiated resolution information.
+     * undefined when the display is not connected.
+     * @property {DisplayResolution} resolution
+     */
+    resolution;
+
+    /**
+     * Negotiated frame rate (frames per second).
+     * undefined when the display is not connected.
+     * @property {number} framerate
+     */
+    framerate;
+
+    /**
+     * Negotiated HDCP / security level.
+     * undefined when the display is not connected.
+     * @property {string} security
+     */
+    security;
+
+    /**
+     * Vendor (make) information parsed from EDID.
+     * undefined when the display is not connected.
+     * @property {string} make
+     */
+    make;
+
+    /**
+     * Model information parsed from EDID.
+     * undefined when the display is not connected.
+     * @property {string} model
+     */
+    model;
+}
+
+
+/**
+ * @module
+ * @type {DisplayManager}
+ * @private
+ * @example
+ * import { displayManager } from "senza-sdk";
+ * const connection = await displayManager.connection;
+ * console.info(connection);
+ *
+ * @return {DisplayManager} pointer to the DisplayManager singleton
+ */
+"needed for the module doc comment to be recognized";