senza-sdk 4.2.65-90c49ac.0 → 4.3.1-4a01fcf.0

package/src/{remotePlayer.js → implementation/remotePlayer.js}

@@ -1,3 +1,4 @@
+import { RemotePlayer as RemotePlayerInterface } from "../interface/remotePlayer";
 import {
     getFCID,
     isAudioSyncConfigured,
@@ -68,6 +69,7 @@ function setPlaybackInfo(playbackInfo) {
 * @typedef {Object} Config
 * @property {string} preferredAudioLanguage
 * @property {string} preferredSubtitlesLanguage
+* @property {number} minSuggestedPresentationDelay - minimal delay allowed for live playback in seconds
 * @property {boolean} autoPlay - (Not implemented yet) upon loading start playing automatically
 */
 
@@ -78,11 +80,11 @@ function setPlaybackInfo(playbackInfo) {
  * @fires ended
  * @fires error
  * @fires onloadmodechange
+ * @fires playing
  * @fires seeking (Not implemented yet)
  * @fires seeked (Not implemented yet)
- * @fires loadedmetadata (Not implemented yet)
  */
-class RemotePlayer extends EventTarget {
+class RemotePlayer extends RemotePlayerInterface {
     constructor() {
         super();
         /**
@@ -91,7 +93,8 @@ class RemotePlayer extends EventTarget {
          */
         this._config = {
             preferredAudioLanguage: "",
-            preferredSubtitlesLanguage: ""
+            preferredSubtitlesLanguage: "",
+            minSuggestedPresentationDelay: 0
         };
         /**
          * @type {string}
@@ -524,10 +527,10 @@ class RemotePlayer extends EventTarget {
 
     /** setting values for properties in the player configuration using an object.
      * If the config does not support a property this is a no-op.
-     * @param {Object} props the object with all the different properties to change
+     * @param {Config} props the object with all the different properties to change.
      * @example
      * remotePlayer.configure({ preferredAudioLanguage: 'en-US' })
-     *
+     * remotePlayer.configure({ minSuggestedPresentationDelay: 6 })
      * */
     configure(props) {
         Object.entries(props).forEach(([key, value]) => {
@@ -896,6 +899,9 @@ class RemotePlayer extends EventTarget {
                 this._updateSeekListeners(video);
             }
             this._videoElement = video;
+
+            // Emit a custom event to notify about the attachment of the video element
+            this.dispatchEvent(new Event("videoelementattached"));
         }
     }
 
@@ -911,7 +917,7 @@ class RemotePlayer extends EventTarget {
     /** Tell the remote player to load the given URL.
      * @param {string} url url to load
      * @param {number} [position] start position in seconds (if not provided, start from beginning (VOD) or current time (LTV))
-     * @returns {Promise}
+    * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg
      *
      * */
@@ -976,6 +982,11 @@ class RemotePlayer extends EventTarget {
                     message.action = "load";
                     message.audioLanguage = audioLanguage;
                     message.subtitlesLanguage = subtitlesLanguage;
+                    if (this.getConfiguration().minSuggestedPresentationDelay > 0) {
+                        message.cloudPlayerParams = {
+                            "mspd": this.getConfiguration().minSuggestedPresentationDelay
+                        };
+                    }
                 } else {
                     message.type = "setPlayableUri";
                 }
@@ -1133,13 +1144,8 @@ class RemotePlayer extends EventTarget {
 
         // If seeking in progress, wait for seek to complete before playing
         if (this._isSeekingByApplication) {
-            if (lifecycle.state === lifecycle.UiState.FOREGROUND) {
-                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_UI");
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-            } else {
-                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_ABR");
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-            }
+            sdkLogger.info("application requesting play during seek");
+            this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
             return Promise.resolve(true);
         }
         /*
@@ -1661,7 +1667,9 @@ class RemotePlayer extends EventTarget {
             }
         }
 
-        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication) {
+        // Only allow seeking in foreground. Still ignore the initialized local player seeking event above
+        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication &&
+            (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND)) {
             this._atomicSeek();
         } else {
             sdkLogger.info(`Seeking: skipping seeking event to currentTime: ${playbackPosition}, internalSeek: ${this._isSeekingByPlatform}, localPlayerSeek: ${this._isSeekingByApplication}, state: ${lifecycle.state}`);
@@ -1680,16 +1688,16 @@ class RemotePlayer extends EventTarget {
      * */
     async _atomicSeek() {
         sdkLogger.info("Seeking: local video element seeking start while isPlaying: ", this._isPlaying);
-        if (this._isPlaying) {
-            if (!lifecycle._inTransitionToForeground && (lifecycle._inTransitionToBackground || lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
-                sdkLogger.info("seek in background", this._isPlaying);
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-            } else {
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-            }
-        } else {
-            this._targetSeekPlayingState = TargetPlayingState.PAUSED;
-        }
+
+        // Initialize the target playing state unless changed during the seek process
+        // In the future, we should allow for seeking in background. Currently, there's no
+        // way to know when the web application will call moveToForeground (i.e Before/After seek)
+        // Therefore, for now, we will assume the target is either paused or playing in ui unless
+        // specifically receiving a moveToBackground during the process.
+        // if (this._isPlaying && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+        //     this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
+        // }
+        this._targetSeekPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
 
         // The platform could be currently syncing audio/video using playback rate. Reset when performing seek.
         if (this._videoElement) {
@@ -1756,7 +1764,7 @@ class RemotePlayer extends EventTarget {
 
         // If in TargetPlayingState.PAUSE, no need to resume.
         // Resume without awaiting to avoid blocking the seek process anymore
-        // In case where we aborted (new load or unload called), we don't want to resume playback.
+        // In case where we aborted, we don't want to resume playback.
         if (!this._abortSeeking) {
             if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_UI) {
                 if (!this._isAudioSyncEnabled()) {
@@ -1765,8 +1773,6 @@ class RemotePlayer extends EventTarget {
                 // resume audio play only if _isAudioSyncEnabled
                 this._play(StreamType.AUDIO);
             } else if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
-                // When moving back to background, we need to put the remote player back into play mode
-                this._changePlayMode(true);
                 lifecycle._moveToBackground();
             }
         }

package/src/{senzaShakaPlayer.js → implementation/senzaShakaPlayer.js}

@@ -1,6 +1,9 @@
-import * as shaka from "shaka-player";
+import { shaka } from "../interface/senzaShakaPlayer";
+
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
 import { sdkLogger, iso6393to1 } from "./utils";
+import moment from "moment";
+
 
 //  Define custom error category
 shaka.util.Error.Category.SENZA_PLAYER_ERROR = 50;
@@ -30,11 +33,6 @@ class SenzaError extends shaka.util.Error {
 }
 
 
-// Copy the shaka module and replace the Player class with SenzaShakaPlayer
-// if we don't Copy the shaka module, the Player class will be replaced for all the other modules that import shaka
-const senzaShaka = { ...shaka };
-
-
 /**
  * SenzaShakaPlayer subclass of Shaka that handles both local and remote playback.
  *
@@ -76,7 +74,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @private
      * @type {number}
      * @description Timeout in milliseconds to wait for playing event
-     * @default 3000
+     * @default 4000
      */
     _playingTimeout = 4000;
 
@@ -185,7 +183,7 @@ export class SenzaShakaPlayer extends shaka.Player {
                 originatesFromRemotePlayer: true
             };
 
-            const response = await this.getNetworkingEngine().request(senzaShaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
 
             let responseBody = response.data;
             if (response.status < 200 || response.status >= 300) {
@@ -305,6 +303,45 @@ export class SenzaShakaPlayer extends shaka.Player {
 
     }
 
+    /**
+     * @private
+     * @type {number}
+     * @description Minimum suggested presentation delay in seconds
+     * @default 15
+     */
+    _minSuggestedPresentationDelay = 15;
+
+    /**
+     * Modifies the suggestedPresentationDelay in the manifest text
+     * @private
+     * @param {string} manifestText - The MPD manifest text
+     * @returns {string} - Modified manifest text , or undefined if no modification was done
+     */
+    _updateManifestDelayIfBelowMinimum(manifestText) {
+        // Look for suggestedPresentationDelay attribute
+        const match = manifestText.match(/suggestedPresentationDelay="([^"]+)"/);
+        if (match) {
+            const durationString = match[1];
+            const duration = moment.duration(durationString);
+            const currentDelay = duration.asSeconds();
+
+            sdkLogger.info(`Found suggestedPresentationDelay in manifest: ${currentDelay.toFixed(3)}s`);
+
+            if (currentDelay < this._minSuggestedPresentationDelay) {
+                // Replace the value in the manifest text with 3 decimal places
+                manifestText = manifestText.replace(
+                    /suggestedPresentationDelay="[^"]+"/,
+                    `suggestedPresentationDelay="PT${this._minSuggestedPresentationDelay.toFixed(3)}S"`
+                );
+                sdkLogger.info(`Updated manifest suggestedPresentationDelay to ${this._minSuggestedPresentationDelay.toFixed(3)}s`);
+                return manifestText;
+            }
+        } else {
+            sdkLogger.info("suggestedPresentationDelay is not defined at the manifest");
+        }
+        return undefined;
+    }
+
     /**
      * Creates an instance of SenzaShakaPlayer, which is a subclass of shaka.Player.
      *
@@ -332,14 +369,38 @@ export class SenzaShakaPlayer extends shaka.Player {
         const playTimeout = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"]?.playingEventTimeout;
         this._playingTimeout = (playTimeout >= 0) ? playTimeout*1000 : this._playingTimeout;
 
+        // Initialize minSuggestedPresentationDelay from UI settings or use default
+        const uiSettings = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"];
+        if (uiSettings?.minSuggestedPresentationDelay !== undefined) {
+            this._minSuggestedPresentationDelay = uiSettings.minSuggestedPresentationDelay;
+            sdkLogger.info(`Using configured minSuggestedPresentationDelay: ${this._minSuggestedPresentationDelay}s`);
+        }
+
         // if video element is provided, add the listeres here. In this case ,there is no need to call attach.
         if (videoElement) {
             this._attach(videoElement);
             sdkLogger.warn("SenzaShakaPlayer constructor Adding videoElement in the constructor is going to be deprecated in the future. Please use attach method instead.");
         }
 
+        this.configure({
+            manifest: {
+                defaultPresentationDelay: this._minSuggestedPresentationDelay // in seconds
+            }
+        });
+
+        remotePlayer.configure({
+            minSuggestedPresentationDelay: this._minSuggestedPresentationDelay
+        });
+
+        this.addEventListener("buffering", () => {
+            if (this.videoElement) {
+                sdkLogger.info("Buffering at time:", this.videoElement.currentTime);
+            }
+        });
+
     }
 
+
     _attach(videoElement) {
         this.videoElement = videoElement;
 
@@ -618,16 +679,30 @@ export class SenzaShakaPlayer extends shaka.Player {
 
         // This callbakc will be activated when the manifest is loaded. It will trigger load of the remote player.
         // This will ensure that the remote player is loaded only after the manifest is loaded by local player.
-        const responseFilterCallback = async (type) => {
-            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST && !manifestLoadHandled) {
-                manifestLoadHandled = true;
+        const responseFilterCallback = async (type, response) => {
+            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST) {
                 try {
-                    await this._remotePlayerLoad(url, startTime);
-                    remoteLoadResolver();
+                    if (response.data && this._minSuggestedPresentationDelay > 0) {
+                        const manifestText = new TextDecoder().decode(response.data);
+                        const modifiedText = this._updateManifestDelayIfBelowMinimum(manifestText);
+                        if (modifiedText) {
+                            const responseData = new TextEncoder().encode(modifiedText).buffer;
+                            response.data = responseData;
+                        }
+                    }
                 } catch (error) {
-                    remoteLoadRejecter(error);
+                    sdkLogger.error("Error processing manifest:", error);
                 }
 
+                if (!manifestLoadHandled) {
+                    manifestLoadHandled = true;
+                    try {
+                        await this._remotePlayerLoad(url, startTime);
+                        remoteLoadResolver();
+                    } catch (error) {
+                        remoteLoadRejecter(error);
+                    }
+                }
             }
         };
 
@@ -810,5 +885,5 @@ export class SenzaShakaPlayer extends shaka.Player {
 
 }
 
-senzaShaka.Player = SenzaShakaPlayer;
-export { senzaShaka as shaka };
+shaka.Player = SenzaShakaPlayer;
+export { shaka };

package/src/{utils.js → implementation/utils.js}

@@ -1,10 +1,15 @@
 import { getPlatformInfo } from "./api";
-import pack from "../package.json";
 import { sessionInfo } from "./SessionInfo";
-const { version } = pack;
 
 const REST_RESPONSE_TIMEOUT_SECONDS = 5;
 
+export function getVersion() {
+    return typeof IMPLEMENTATION_VERSION !== "undefined"
+        // eslint-disable-next-line no-undef
+        ? IMPLEMENTATION_VERSION
+        : "unknown";
+};
+
 export function getFCID() {
     return Math.round(Math.random() * 100000) + "-" + getPlatformInfo().sessionInfo?.connectionId;
 }
@@ -42,7 +47,7 @@ class SdkLogger {
         console.info(`[hs-sdk] [metrics] ${JSON.stringify(metricObj)}`);
     }
     withFields(logFields) {
-        return new SdkLogger({...this.logFields, ...logFields});
+        return new SdkLogger({ ...this.logFields, ...logFields });
     }
     formatLogString(data) {
         let logString = "[hs-sdk] " + data.join(" ");
@@ -51,9 +56,13 @@ class SdkLogger {
         }
         return logString;
     }
+    addfields(fields) {
+        this.logFields = { ...this.logFields, ...fields };
+        return this;
+    }
 }
 
-export const sdkLogger = new SdkLogger({sdkVersion: version, url: window?.location?.href ?? ""});
+export const sdkLogger = new SdkLogger({ sdkVersion: getVersion(), url: window?.location?.href ?? "" });
 
 export async function getRestResponse(messageName) {
 
@@ -64,14 +73,14 @@ export async function getRestResponse(messageName) {
 
     return new Promise((resolve, reject) => {
         const FCID = getFCID();
-        const logger = sdkLogger.withFields({FCID});
+        const logger = sdkLogger.withFields({ FCID });
         const message = {
             type: "restRequest",
             name: messageName,
             method: "GET",
             fcid: FCID
         };
-        const request = {target: "TC", waitForResponse: true, message: JSON.stringify(message)};
+        const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
         let timeoutHandler = 0;
         const queryId = window.cefQuery({
             request: JSON.stringify(request),

package/src/interface/alarmManager.js

@@ -0,0 +1,69 @@
+import { noop } from "./utils";
+/**
+ * @class AlarmManager
+ * AlarmManager is a singleton class that manages the alarms in the application. It fires events whose types are the names of the alarms.
+ * @fires MyAlarm
+ */
+export class AlarmManager extends EventTarget {
+
+    /**
+     * alarm event
+     *
+     * @event AlarmManager#MyAlarm
+     * @description Fired when time of 'MyAlarm' arrives. If this alarm triggers the application load and the application doesn't call
+     * lifecycle.moveToForeground() in the alarm callback (i.e. the application remains in the background after the callback is completed),
+     * the application will be unloaded.
+     * NOTE: If you perform async operations in the callback (without moving to foreground), you must wait for the async
+     * operation to finish before returning from the callback, otherwise the application will be unloaded before the async operation is finished.<br>
+     * @example
+     * alarmManager.addEventListener("MyAlarm", async (e) => {
+     *     console.log("alarm MyAlarm arrived with data", e.detail);
+     *     await fetch("http://www.example.com");
+     * });
+     * alarmManager.addAlarm("MyAlarm", Date.now() + 60*60*1000, "MyData");
+     */
+    constructor() {
+        super();
+    }
+
+    addEventListener(type, callback) {
+        noop("AlarmManager.addEventListener", type, callback);
+    }
+
+    removeEventListener(type, callback) {
+        noop("AlarmManager.removeEventListener", type, callback);
+    }
+
+    /** Set alarm to be fired at the specified time, event when ui is released
+     * @param {string} alarmName unique name for the alarm
+     * @param {number} alarmTime target time for the alarm to be fired, represented by the number of milliseconds elapsed since the epoch
+     * @param {string} [data] data to be passed back when the alarm is fired
+     * */
+    addAlarm(alarmName, alarmTime, data = "", toleranceBefore = 0, toleranceAfter = 0) {
+        noop("AlarmManager.addAlarm", alarmName, alarmTime, data, toleranceBefore, toleranceAfter);
+    }
+
+    /** Delete the specified alarm
+     * @param {string} alarmName name of alarm to be deleted
+     *
+     * */
+    deleteAlarm(alarmName) {
+        noop("AlarmManager.deleteAlarm", alarmName);
+    }
+
+    /** Delete all alarms
+     *
+     * */
+    deleteAllAlarms() {
+        noop("AlarmManager.deleteAllAlarms");
+    }
+
+    /** Async function that asks for all active alarms
+     * @returns {Promise} when resolved, returns an array of objects containing alarmName and alarmTime fields
+     * @throws {string} error string in case of an error
+     *
+     * */
+    getActiveAlarms() {
+        return noop("AlarmManager.getActiveAlarms");
+    }
+}

package/src/interface/api.js

@@ -0,0 +1,8 @@
+export { Lifecycle } from "./lifecycle.js";
+export { DeviceManager } from "./deviceManager.js";
+export { PlatformManager } from "./platformManager.js";
+export { AlarmManager } from "./alarmManager.js";
+export { MessageManager } from "./messageManager.js";
+export { RemotePlayer } from "./remotePlayer.js";
+export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
+export { showSequence, initSequence } from "./devSequence.js";

package/src/{devSequence.js → interface/devSequence.js}

@@ -204,6 +204,7 @@ const setupSequence = (components, items) => {
     };
     methodInject(components, inject, (name) => name.startsWith("_") || name.startsWith("get"));
     handleKeys(items);
+    playersEvents(components, items);
     sdkLogger.log("Sequence initialized.");
 };
 
@@ -257,3 +258,37 @@ export const showSequence = (visible = true) => {
     }
     container.style.visibility = visible ? "visible" : "hidden";
 };
+function playersEvents(components, items) {
+    components.remotePlayer.addEventListener("videoelementattached", () => {
+        const video = components.remotePlayer._videoElement;
+        if (video && !video._devSequenceRateChangeHandler) {
+            video._devSequenceRateChangeHandler = () => {
+                items.push({
+                    component: "localPlayer",
+                    id: "ratechange=" + video.playbackRate,
+                    time: performance.now() - currentTime
+                });
+            };
+            video.addEventListener("ratechange", video._devSequenceRateChangeHandler);
+        }
+
+        if (video && !video._devSequencePlayingHandler) {
+            video._devSequencePlayingHandler = () => {
+                items.push({
+                    component: "localPlayer",
+                    id: "playing event",
+                    time: performance.now() - currentTime
+                });
+            };
+            video.addEventListener("playing", video._devSequencePlayingHandler);
+        }
+    });
+    components.remotePlayer.addEventListener("playing", () => {
+        items.push({
+            component: "remotePlayer",
+            id: "playing event",
+            time: performance.now() - currentTime
+        });
+    });
+}
+

package/src/interface/deviceManager.js

@@ -0,0 +1,133 @@
+import { sdkLogger, noop } from "./utils.js";
+
+const wifiInfo = {};
+
+/**
+ * @class DeviceManager
+ * DeviceManager is a singleton class that manages the device
+ */
+export class DeviceManager extends EventTarget {
+
+    constructor() {
+        super();
+        wifiInfo.level = 0;
+        wifiInfo.quality = 0;
+        wifiInfo.ssid = "unknown";
+        wifiInfo.bssid = "unknown";
+        /**
+         * @deprecated Instead, call deviceManager.getWifiInfo() periodically
+         * @event DeviceManager#wifiInfoUpdated
+         * @example
+         * deviceManager.addEventListener("wifiInfoUpdated", () => {
+         *   console.info("Wifi info has been updated to", deviceManager.wifiInfo);
+         * });
+         *
+         */
+    }
+
+    /**
+     * @property {object} DeviceInfo
+     * @property {string} DeviceInfo.deviceId
+     * @property {string} DeviceInfo.modelNumber
+     * @property {string} DeviceInfo.connectionId
+     * @property {string} DeviceInfo.community
+     * @property {string} DeviceInfo.tenant
+     * @property {string} DeviceInfo.clientIp
+     * @property {string} DeviceInfo.countryCode A 2-letter code as defined in ISO_3166-1
+     * @property {string} DeviceInfo.connectionType The type of device used during the current connection. Possible values are "device" which mean real device, "simulator" - simulated device - that used during development.
+     */
+    get deviceInfo() {
+        sdkLogger.log("getDeviceInfo running locally, returning dummy info");
+        return {
+            deviceId: "123456789",
+            modelNumber: "ABC",
+            connectionId: "dummy",
+            community: "LocalDev",
+            tenant: "XXXXXX",
+            clientIp: "0.0.0.0",
+            countryCode: "XX",
+            connectionType: "simulator"
+        };
+
+    }
+
+    /**
+     * @deprecated use deviceManager.getWifiInfo() instead
+     * @property {object} WifiInfo
+     * @property {number} WifiInfo.level
+     * @property {number} WifiInfo.quality
+     * @property {string} WifiInfo.ssid
+     * @property {string} WifiInfo.bssid
+     */
+    get wifiInfo() {
+        return wifiInfo;
+    }
+
+    /**
+     * Reboot the device
+     * @return {Promise} Promise which is resolved when the reboot command has been successfully processed.
+     * Failure to process the reboot command will result in the promise being rejected.
+     */
+    reboot() {
+        return noop("DeviceManager.reboot");
+    }
+
+    /**
+     * Delete current wifi configuration and forget network
+     * @return {Promise} Promise which is resolved when the clearWifi command has been successfully processed.
+     * Failure to process the clearWifi command will result in the promise being rejected.
+     */
+    clearWifi() {
+        return noop("DeviceManager.clearWifi");
+    }
+
+    /**
+     * Send raw data directly to a customer's device via the USB serial connection of a Senza device.
+     * This function is specifically designed for customers who have their devices connected to a Senza device.
+     * Using this API, these customers can transmit messages or data directly to their connected devices.
+     * The transmission occurs through the Senza device's USB serial interface, facilitating direct communication
+     * between the customer's web application and their device.
+     * @param {String} data raw data to be passed to the device
+     * @return {Promise} Promise which is resolved when the command has been successfully processed.
+     * Failure to process the command will result in the promise being rejected.
+     */
+    sendDataToDevice(data) {
+        return noop("DeviceManager.sendDataToDevice", data);
+    }
+
+    /**
+     * Perform device factory reset.
+     * @param {Boolean} [reboot=true] a flag that is passed to the device to indicate whether it should reboot after the factory reset. defaults to true.
+     * @return {Promise} Promise which is resolved when factoryReset has been successfully performed
+     * Failure to factoryReset for any reason, result in the promise being rejected.
+     */
+    async factoryReset(reboot = true) {
+        return noop("DeviceManager.factoryReset", reboot);
+    }
+
+    /**
+     * @typedef {Object} WiFiInfo
+     * @property {string}   ssid the name of the Wi-Fi network that the device is connected to
+     * @property {string}   bssid the unique identifier of the Wi-Fi access point
+     * @property {string}   standard the Wi-Fi standard in use, such as 802.11a/b/g/n/ac/ax
+     * @property {string}   security the type of security protocol used by the Wi-Fi network, such as WEP, WPA, WPA2, or WPA3
+     * @property {string}   device-mac the MAC address of the device
+     * @property {string}   device-ip4 the IPv4 address assigned to the device on the Wi-Fi network
+     * @property {string}   dhcp-server the IP address of the DHCP server that assigned the device's network configuration
+     * @property {string[]} dns-server array of IP addresses of the DNS servers the device uses to resolve domain names
+     * @property {number}   channel the number of the Wi-Fi channel currently being used
+     * @property {number}   width width of the Wi-Fi channel in megahertz, e.g. 20MHz or 40 MHz channel
+     * @property {number}   level a measure of the received signal strength, in the range 0 to 100 (the higher, the better). The level value is 100+RSSI (RSSI is the signal strength, measured in decibels)
+     * @property {number}   quality a measure of the signal quality, in the range 0 to 100 (the higher, the better). The quality value is derived from the signal EVM.
+     * */
+
+    /**
+     * Get Wi-Fi info - access point data and status (the status is cached for 5 seconds)
+     * @returns {WiFiInfo} An object containing the Wi-Fi info
+     * @alpha API has not yet been released
+     * */
+    // This api is part of epic HSDEV-4185
+    async getWifiInfo() {
+        return Promise.resolve({});
+    }
+}