@robdobsn/raftjs 1.8.5 → 1.10.7

package/dist/react-native/RaftSysTypeManager.d.ts

@@ -0,0 +1,16 @@
+import { RaftSystemType } from "./RaftSystemType";
+type RaftSystemTypeCreator = () => RaftSystemType;
+export default class RaftSysTypeManager {
+    private static _instance;
+    private _sysTypes;
+    private _defaultSysTypeFactory;
+    static getInstance(): RaftSysTypeManager;
+    addSystemType(sysType: string, factory: RaftSystemTypeCreator): void;
+    addDefaultSystemType(factory: RaftSystemTypeCreator): void;
+    createSystemType(sysType: string): RaftSystemType | null;
+    createDefaultSystemType(): RaftSystemType | null;
+    getAllServiceUUIDs(): string[];
+    getAllNamePrefixes(): string[];
+    getSystemTypeByBLENamePrefix(name: string): RaftSystemType | null;
+}
+export {};

package/dist/react-native/RaftSysTypeManager.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RaftSysTypeManager {
+    constructor() {
+        // System type map
+        this._sysTypes = new Map();
+        this._defaultSysTypeFactory = null;
+    }
+    // Get instance (Singleton)
+    static getInstance() {
+        if (!RaftSysTypeManager._instance) {
+            RaftSysTypeManager._instance = new RaftSysTypeManager();
+        }
+        return RaftSysTypeManager._instance;
+    }
+    // Add a system type by name with its factory
+    addSystemType(sysType, factory) {
+        if (this._sysTypes.has(sysType)) {
+            throw new Error(`System type '${sysType}' is already registered.`);
+        }
+        this._sysTypes.set(sysType, factory);
+    }
+    // Set the default system type factory
+    addDefaultSystemType(factory) {
+        this._defaultSysTypeFactory = factory;
+    }
+    // Create a system type by name
+    createSystemType(sysType) {
+        const factory = this._sysTypes.get(sysType);
+        if (!factory) {
+            return null;
+        }
+        return factory();
+    }
+    // Create the default system type
+    createDefaultSystemType() {
+        if (!this._defaultSysTypeFactory) {
+            return null;
+        }
+        return this._defaultSysTypeFactory();
+    }
+    // Get a list of all unique BLE service UUIDs
+    getAllServiceUUIDs() {
+        const serviceUUIDs = new Set();
+        this._sysTypes.forEach((factory) => {
+            const sysType = factory();
+            if (!sysType.BLEServiceUUIDs) {
+                return;
+            }
+            sysType.BLEServiceUUIDs.forEach((uuid) => serviceUUIDs.add(uuid));
+        });
+        return Array.from(serviceUUIDs);
+    }
+    // Get a list of all device name prefixes to filter on
+    getAllNamePrefixes() {
+        const deviceNames = new Set();
+        this._sysTypes.forEach((factory) => {
+            const sysType = factory();
+            if (!sysType.BLEDeviceNames) {
+                return;
+            }
+            sysType.BLEDeviceNames.forEach((name) => deviceNames.add(name));
+        });
+        return Array.from(deviceNames);
+    }
+    // Find the system type for a given BLE device name prefix
+    getSystemTypeByBLENamePrefix(name) {
+        for (const factory of this._sysTypes.values()) {
+            const sysType = factory();
+            if (sysType.BLEDeviceNames && sysType.BLEDeviceNames.some((prefix) => name.startsWith(prefix))) {
+                return sysType;
+            }
+        }
+        return null;
+    }
+}
+exports.default = RaftSysTypeManager;
+//# sourceMappingURL=RaftSysTypeManager.js.map

package/dist/react-native/RaftSysTypeManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RaftSysTypeManager.js","sourceRoot":"","sources":["../../src/RaftSysTypeManager.ts"],"names":[],"mappings":"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"}

package/dist/react-native/RaftSystemType.d.ts

@@ -0,0 +1,30 @@
+import RaftDeviceMgrIF from "./RaftDeviceMgrIF";
+import RaftSystemUtils from "./RaftSystemUtils";
+import { RaftEventFn } from "./RaftTypes";
+export type RaftSubscribeForUpdatesCBType = (systemUtils: RaftSystemUtils, enable: boolean) => Promise<void>;
+export type RaftStateIsInvalidCBType = () => void;
+export type RaftRxOtherMsgType = (payload: Uint8Array, _frameTimeMs: number) => void;
+export interface ConnectorOptions {
+    wsSuffix?: string;
+    connTimeoutMs?: number;
+    bleConnItvlMs?: number;
+    bleUuid?: string;
+}
+export interface RaftSystemType {
+    nameForDialogs: string;
+    defaultWiFiHostname?: string;
+    BLEServiceUUIDs?: string[];
+    BLECmdUUID?: string;
+    BLERespUUID?: string;
+    BLEDeviceNames?: string[];
+    firmwareDestName?: string;
+    normalFileDestName?: string;
+    connectorOptions: ConnectorOptions;
+    setup: (systemUtils: RaftSystemUtils, onEvent: RaftEventFn | null) => void;
+    subscribeForUpdates: RaftSubscribeForUpdatesCBType | null;
+    stateIsInvalid: RaftStateIsInvalidCBType | null;
+    rxOtherMsgType: RaftRxOtherMsgType | null;
+    deviceMgrIF?: RaftDeviceMgrIF;
+    nonRaftTypeCode?: string;
+}
+export type RaftGetSystemTypeCBType = (systemUtils: RaftSystemUtils) => Promise<RaftSystemType | null>;

package/dist/react-native/RaftSystemType.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=RaftSystemType.js.map

package/dist/react-native/RaftSystemType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RaftSystemType.js","sourceRoot":"","sources":["../../src/RaftSystemType.ts"],"names":[],"mappings":""}

package/dist/react-native/RaftSystemUtils.d.ts

@@ -0,0 +1,136 @@
+import { RaftWifiConnStatus } from "./RaftWifiTypes";
+import RaftMsgHandler from "./RaftMsgHandler";
+import { RaftFileList, RaftFriendlyName, RaftOKFail, RaftSysModInfoBLEMan, RaftSystemInfo, RaftWifiScanResults } from "./RaftTypes";
+export default class RaftSystemUtils {
+    private _msgHandler;
+    private _systemInfo;
+    private _friendlyName;
+    private _wifiConnStatus;
+    private _defaultWiFiHostname;
+    private _maxSecsToWaitForWiFiConn;
+    /**
+     * constructor
+     * @param raftMsgHandler
+     */
+    constructor(raftMsgHandler: RaftMsgHandler);
+    /**
+     * getMsgHandler
+     * @returns RaftMsgHandler
+     */
+    getMsgHandler(): RaftMsgHandler;
+    /**
+     * setDefaultWiFiHostname
+     * @param defaultWiFiHostname
+     */
+    setDefaultWiFiHostname(defaultWiFiHostname: string): void;
+    /**
+     * getFriendlyName
+     *
+     * @returns friendly name
+     */
+    getFriendlyName(): RaftFriendlyName | null;
+    /**
+     * invalidate
+     */
+    invalidate(): void;
+    /**
+     * retrieveInfo - get system info
+     * @returns Promise<RaftSystemInfo>
+     *
+     */
+    retrieveInfo(): Promise<boolean>;
+    /**
+     *
+     * getSystemInfo
+     * @param forceGet - true to force a get from the raft app
+     * @returns Promise<RaftSystemInfo>
+     *
+     */
+    getSystemInfo(forceGet?: boolean): Promise<RaftSystemInfo>;
+    /**
+     *
+     * setRaftName
+     * @param newName name to refer to Raft - used for BLE advertising
+     * @returns Promise<boolean> true if successful
+     *
+     */
+    setRaftName(newName: string): Promise<boolean>;
+    /**
+     *
+     * getRaftName
+     * @param forceGet - true to force a get from the raft app
+     * @returns Promise<RaftNameResponse> (object containing rslt)
+     *
+     */
+    getRaftName(forceGet?: boolean): Promise<RaftFriendlyName>;
+    /**
+     *
+     * getFileList - get list of files on file system
+     * @returns Promise<RaftFileList>
+     *
+     */
+    getFileList(): Promise<RaftFileList>;
+    /**
+     *
+     * Get BLEMan sysmod info
+     *
+     * @returns RaftSysModInfoBLEMan
+     *
+     */
+    getSysModInfoBLEMan(): Promise<RaftSysModInfoBLEMan | null>;
+    /**
+     * Get hostname of connected WiFi
+     *
+     *  @return string - hostname of connected WiFi
+     *
+     */
+    _getHostnameFromFriendlyName(): string;
+    /**
+     * Get Wifi connection status
+     *
+     *  @return boolean - true if connected
+     *
+     */
+    getWiFiConnStatus(): Promise<boolean | null>;
+    /**
+     * pause Wifi connection
+     *
+     *  @param boolean - true to pause, false to resume
+     *  @return boolean - true if successful
+     *
+     */
+    pauseWifiConnection(pause: boolean): Promise<boolean>;
+    /**
+     * Connect to WiFi
+     *
+     *  @param string - WiFi SSID
+     *  @param string - WiFi password
+     *  @return boolean - true if successful
+     *
+     */
+    wifiConnect(ssid: string, password: string): Promise<boolean>;
+    /**
+     * Disconnect WiFi
+     *
+     *  @return boolean - true if successful
+     *
+     */
+    wifiDisconnect(): Promise<boolean>;
+    /**
+     *  WiFiScan start
+     *
+     *  @return boolean - true if successful
+     *
+     */
+    wifiScanStart(): Promise<boolean>;
+    /**
+     *  WiFiScan get results
+     *
+     *  @return boolean - false if unsuccessful, otherwise the results of the promise
+     *
+     */
+    wifiScanResults(): Promise<boolean | RaftOKFail | RaftWifiScanResults>;
+    getCachedSystemInfo(): RaftSystemInfo | null;
+    getCachedRaftName(): RaftFriendlyName | null;
+    getCachedWifiStatus(): RaftWifiConnStatus;
+}

package/dist/react-native/RaftSystemUtils.js

@@ -0,0 +1,412 @@
+"use strict";
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RaftSystem
+// Part of RaftJS
+//
+// Rob Dobson & Chris Greening 2020-2024
+// (C) 2020-2024 All rights reserved
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const RaftWifiTypes_1 = require("./RaftWifiTypes");
+const RaftLog_1 = tslib_1.__importDefault(require("./RaftLog"));
+const RaftTypes_1 = require("./RaftTypes");
+class RaftSystemUtils {
+    /**
+     * constructor
+     * @param raftMsgHandler
+     */
+    constructor(raftMsgHandler) {
+        // System info
+        this._systemInfo = null;
+        // Raft naming
+        this._friendlyName = null;
+        // WiFi connection info
+        this._wifiConnStatus = new RaftWifiTypes_1.RaftWifiConnStatus();
+        this._defaultWiFiHostname = "Raft";
+        this._maxSecsToWaitForWiFiConn = 20;
+        this._msgHandler = raftMsgHandler;
+    }
+    /**
+     * getMsgHandler
+     * @returns RaftMsgHandler
+     */
+    getMsgHandler() {
+        return this._msgHandler;
+    }
+    /**
+     * setDefaultWiFiHostname
+     * @param defaultWiFiHostname
+     */
+    setDefaultWiFiHostname(defaultWiFiHostname) {
+        if (defaultWiFiHostname) {
+            this._defaultWiFiHostname = defaultWiFiHostname;
+        }
+    }
+    /**
+     * getFriendlyName
+     *
+     * @returns friendly name
+     */
+    getFriendlyName() {
+        return this._friendlyName;
+    }
+    /**
+     * invalidate
+     */
+    invalidate() {
+        // Invalidate system info
+        this._systemInfo = null;
+        this._friendlyName = null;
+        RaftLog_1.default.debug("RaftSystemUtils information invalidated");
+    }
+    /**
+     * retrieveInfo - get system info
+     * @returns Promise<RaftSystemInfo>
+     *
+     */
+    async retrieveInfo() {
+        var _a;
+        // Get system info
+        RaftLog_1.default.debug(`RaftSystemUtils retrieveInfo getting system info`);
+        try {
+            await this.getSystemInfo(true);
+            RaftLog_1.default.debug(`retrieveInfo - Raft Version ${(_a = this._systemInfo) === null || _a === void 0 ? void 0 : _a.SystemVersion}`);
+        }
+        catch (error) {
+            RaftLog_1.default.warn("RaftSystemUtils retrieveInfo - frailed to get version " + error);
+            return false;
+        }
+        // Get app name
+        try {
+            await this.getRaftName();
+        }
+        catch (error) {
+            RaftLog_1.default.warn("retrieveInfo - failed to get Raft name " + error);
+            return false;
+        }
+        // Get WiFi connected info
+        try {
+            await this.getWiFiConnStatus();
+        }
+        catch (error) {
+            RaftLog_1.default.warn("RaftSystemUtils retrieveInfo - failed to get WiFi Status " + error);
+            return false;
+        }
+        return true;
+    }
+    /**
+     *
+     * getSystemInfo
+     * @param forceGet - true to force a get from the raft app
+     * @returns Promise<RaftSystemInfo>
+     *
+     */
+    async getSystemInfo(forceGet = false) {
+        if (!forceGet && this._systemInfo) {
+            return this._systemInfo;
+        }
+        try {
+            this._systemInfo = await this._msgHandler.sendRICRESTURL("v");
+            RaftLog_1.default.debug("getRaftSystemInfo returned " + JSON.stringify(this._systemInfo));
+            this._systemInfo.validMs = Date.now();
+            // Check if friendly name is included in system info
+            if (this._systemInfo.Friendly && (this._systemInfo.Friendly.length > 0)) {
+                this._friendlyName = { "friendlyName": this._systemInfo.Friendly, "friendlyNameIsSet": true, "rslt": "ok", "validMs": Date.now() };
+            }
+            // Handle alternatives in system info
+            if ((this._systemInfo.RicHwRevNo !== undefined) && (this._systemInfo.HwRev === undefined)) {
+                this._systemInfo.HwRev = this._systemInfo.RicHwRevNo;
+            }
+            else if ((this._systemInfo.HwRev !== undefined) && (this._systemInfo.RicHwRevNo === undefined)) {
+                this._systemInfo.RicHwRevNo = this._systemInfo.HwRev;
+            }
+            // Return system info
+            return this._systemInfo;
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils getRaftSystemInfo Failed to get version ${error}`);
+            return new RaftTypes_1.RaftSystemInfo();
+        }
+    }
+    /**
+     *
+     * setRaftName
+     * @param newName name to refer to Raft - used for BLE advertising
+     * @returns Promise<boolean> true if successful
+     *
+     */
+    async setRaftName(newName) {
+        try {
+            this._friendlyName = await this._msgHandler.sendRICRESTURL(`friendlyname/${newName}`);
+            if (this._friendlyName) {
+                this._friendlyName.friendlyNameIsSet = false;
+                this._friendlyName.validMs = Date.now();
+                if (this._friendlyName &&
+                    this._friendlyName.rslt &&
+                    this._friendlyName.rslt.toLowerCase() === "ok") {
+                    this._friendlyName.friendlyNameIsSet = true;
+                }
+                RaftLog_1.default.debug("RaftSystemUtils setRaftName returned " + JSON.stringify(this._friendlyName));
+                return true;
+            }
+            return true;
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils setRaftName Failed to set name ${error}`);
+            this._friendlyName = null;
+            return false;
+        }
+    }
+    /**
+     *
+     * getRaftName
+     * @param forceGet - true to force a get from the raft app
+     * @returns Promise<RaftNameResponse> (object containing rslt)
+     *
+     */
+    async getRaftName(forceGet = false) {
+        // Check if we have a cached value
+        if (!forceGet && this._friendlyName && this._friendlyName.validMs) {
+            return this._friendlyName;
+        }
+        try {
+            this._friendlyName = await this._msgHandler.sendRICRESTURL("friendlyname");
+            if (this._friendlyName &&
+                this._friendlyName.rslt &&
+                this._friendlyName.rslt === "ok") {
+                this._friendlyName.friendlyNameIsSet = this._friendlyName
+                    .friendlyNameIsSet
+                    ? true
+                    : false;
+            }
+            else {
+                this._friendlyName.friendlyNameIsSet = false;
+            }
+            this._friendlyName.validMs = Date.now();
+            RaftLog_1.default.debug("RaftSystemUtils Friendly name set is: " + JSON.stringify(this._friendlyName));
+            return this._friendlyName;
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils getRaftName Failed to get name ${error}`);
+            return new RaftTypes_1.RaftFriendlyName();
+        }
+    }
+    /**
+     *
+     * getFileList - get list of files on file system
+     * @returns Promise<RaftFileList>
+     *
+     */
+    async getFileList() {
+        try {
+            const ricFileList = await this._msgHandler.sendRICRESTURL("filelist");
+            RaftLog_1.default.debug("RaftSystemUtils getFileList returned " + ricFileList);
+            return ricFileList;
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils getFileList Failed to get file list ${error}`);
+            return new RaftTypes_1.RaftFileList();
+        }
+    }
+    /**
+     *
+     * Get BLEMan sysmod info
+     *
+     * @returns RaftSysModInfoBLEMan
+     *
+     */
+    async getSysModInfoBLEMan() {
+        try {
+            // Get SysMod Info
+            const bleInfo = await this._msgHandler.sendRICRESTURL("sysmodinfo/BLEMan");
+            // Debug
+            RaftLog_1.default.debug(`getSysModInfoBLEMan rslt ${bleInfo.rslt} isConn ${bleInfo.isConn} paused ${bleInfo.isAdv} txBPS ${bleInfo.txBPS} rxBPS ${bleInfo.rxBPS}`);
+            // Check for test rate
+            if ("tBPS" in bleInfo) {
+                RaftLog_1.default.debug(`getSysModInfoBLEMan testMsgs ${bleInfo.tM} testBytes ${bleInfo.tB} testRateBytesPS ${bleInfo.tBPS}`);
+            }
+            return bleInfo;
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`getSysModInfoBLEMan sysmodinfo/BLEMan failed ${error}`);
+        }
+        return null;
+    }
+    /**
+     * Get hostname of connected WiFi
+     *
+     *  @return string - hostname of connected WiFi
+     *
+     */
+    _getHostnameFromFriendlyName() {
+        const friendlyName = this.getFriendlyName();
+        if (!friendlyName) {
+            return this._defaultWiFiHostname;
+        }
+        let hostname = friendlyName.friendlyName;
+        hostname = hostname === null || hostname === void 0 ? void 0 : hostname.replace(/ /g, "-");
+        hostname = hostname.replace(/\W+/g, "");
+        return hostname;
+    }
+    /**
+     * Get Wifi connection status
+     *
+     *  @return boolean - true if connected
+     *
+     */
+    async getWiFiConnStatus() {
+        try {
+            // Get status
+            const ricSysModInfoWiFi = await this._msgHandler.sendRICRESTURL("sysmodinfo/NetMan");
+            RaftLog_1.default.debug(`wifiConnStatus rslt ${ricSysModInfoWiFi.rslt} isConn ${ricSysModInfoWiFi.isConn} paused ${ricSysModInfoWiFi.isPaused}`);
+            // Check status indicates WiFi connected
+            if (ricSysModInfoWiFi.rslt === "ok") {
+                this._wifiConnStatus.connState =
+                    ricSysModInfoWiFi.isConn !== 0
+                        ? RaftWifiTypes_1.RaftWifiConnState.WIFI_CONN_CONNECTED
+                        : RaftWifiTypes_1.RaftWifiConnState.WIFI_CONN_NONE;
+                this._wifiConnStatus.isPaused = ricSysModInfoWiFi.isPaused !== 0;
+                this._wifiConnStatus.ipAddress = ricSysModInfoWiFi.IP;
+                this._wifiConnStatus.hostname = ricSysModInfoWiFi.Hostname;
+                this._wifiConnStatus.ssid = ricSysModInfoWiFi.SSID;
+                this._wifiConnStatus.bssid = ricSysModInfoWiFi.WiFiMAC;
+                this._wifiConnStatus.validMs = Date.now();
+                return (ricSysModInfoWiFi.isConn !== 0 || ricSysModInfoWiFi.isPaused !== 0);
+            }
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`[DEBUG]: wifiConnStatus sysmodinfo failed ${error}`);
+            this._wifiConnStatus.validMs = 0;
+        }
+        this._wifiConnStatus.connState = RaftWifiTypes_1.RaftWifiConnState.WIFI_CONN_NONE;
+        this._wifiConnStatus.isPaused = false;
+        return null;
+    }
+    // Mark: WiFi Connection ------------------------------------------------------------------------------------
+    /**
+     * pause Wifi connection
+     *
+     *  @param boolean - true to pause, false to resume
+     *  @return boolean - true if successful
+     *
+     */
+    async pauseWifiConnection(pause) {
+        try {
+            if (pause) {
+                await this._msgHandler.sendRICRESTURL("wifipause/pause");
+            }
+            else {
+                await this._msgHandler.sendRICRESTURL("wifipause/resume");
+            }
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiConnect wifi pause ${error}`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Connect to WiFi
+     *
+     *  @param string - WiFi SSID
+     *  @param string - WiFi password
+     *  @return boolean - true if successful
+     *
+     */
+    async wifiConnect(ssid, password) {
+        RaftLog_1.default.debug(`RaftSystemUtils Connect to WiFi ${ssid} password ${password}`);
+        // Issue the command to connect WiFi
+        try {
+            const RaftRESTURL_wifiCredentials = "w/" +
+                ssid +
+                "/" +
+                password +
+                "/" +
+                this._getHostnameFromFriendlyName();
+            RaftLog_1.default.debug(`wifiConnect attempting to connect to wifi ${RaftRESTURL_wifiCredentials}`);
+            await this._msgHandler.sendRICRESTURL(RaftRESTURL_wifiCredentials);
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiConnect failed ${error}`);
+            return false;
+        }
+        // Wait until connected, timed-out or failed
+        for (let timeoutCount = 0; timeoutCount < this._maxSecsToWaitForWiFiConn; timeoutCount++) {
+            // Wait a little before checking
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            // Get status info
+            const connStat = await this.getWiFiConnStatus();
+            RaftLog_1.default.debug(`RaftSystemUtils wifiConnect connStat ${connStat}`);
+            if (connStat) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Disconnect WiFi
+     *
+     *  @return boolean - true if successful
+     *
+     */
+    async wifiDisconnect() {
+        try {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiDisconnect clearing wifi info`);
+            await this._msgHandler.sendRICRESTURL("wc");
+            this.getWiFiConnStatus();
+            return true;
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiDisconnect clearing unsuccessful ${error}`);
+        }
+        return false;
+    }
+    // Mark: WiFi Scan ------------------------------------------------------------------------------------
+    /**
+     *  WiFiScan start
+     *
+     *  @return boolean - true if successful
+     *
+     */
+    async wifiScanStart() {
+        try {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiScanStart`);
+            await this._msgHandler.sendRICRESTURL("wifiscan/start");
+            return true;
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiScanStart unsuccessful ${error}`);
+        }
+        return false;
+    }
+    /**
+     *  WiFiScan get results
+     *
+     *  @return boolean - false if unsuccessful, otherwise the results of the promise
+     *
+     */
+    async wifiScanResults() {
+        try {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiScanResults`);
+            return this._msgHandler.sendRICRESTURL("wifiscan/results");
+        }
+        catch (error) {
+            RaftLog_1.default.debug(`RaftSystemUtils wifiScanResults unsuccessful ${error}`);
+        }
+        return false;
+    }
+    getCachedSystemInfo() {
+        return this._systemInfo;
+    }
+    getCachedRaftName() {
+        return this._friendlyName;
+    }
+    getCachedWifiStatus() {
+        return this._wifiConnStatus;
+    }
+}
+exports.default = RaftSystemUtils;
+//# sourceMappingURL=RaftSystemUtils.js.map