@robotical/webapp-types 1.0.0

package/application-manager.ts

@@ -0,0 +1,20 @@
+/**
+ * This file is needed so we can build and publish the ApplicationManager interface to the children projects
+ */
+import ApplicationManager from "../src/application/ApplicationManager/ApplicationManager";
+import WrapperCommunicator from "../src/application/communicators/WrapperCommunicator";
+import Logger from "../src/services/logger/Logger";
+import WebAppCommunicator from "../src/wrapper-app/communicators/WebAppCommunicator";
+
+export { ApplicationManager }
+
+declare global {
+    interface Window {
+        ReactNativeWebView: any;
+        // marty: Marty;
+        WebAppCommunicator: WebAppCommunicator;
+        wrapperCommunicator: WrapperCommunicator;
+        applicationManager: ApplicationManager;
+        Logger: Logger;
+    }
+}

package/dist-types/src/application/ApplicationManager/ApplicationManager.d.ts

@@ -0,0 +1,91 @@
+import { RaftConnectionMethod } from "../../types/raft";
+import WebAppCommunicator from "../../wrapper-app/communicators/WebAppCommunicator";
+import RAFT from "../RAFTs/RAFT";
+import Marty from "../RAFTs/Marty/Marty";
+import Cog from "../RAFTs/Cog/Cog";
+import { FOUND_RAFT_ON_DISCOVERY_RESPONSE } from "../../types/phone-app-communicator";
+import { RaftObserver } from "../RAFTs/RaftObserver";
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robdobsn/raftjs";
+import { ConnectedRaftItem } from "../../store/SelectedRaftContext";
+import Toaster from "../../utils/Toaster";
+export default class ApplicationManager {
+    private _observers;
+    static wrapperAppCommunicator: WebAppCommunicator;
+    connectedRafts: {
+        [key: string]: RAFT;
+    };
+    ricSelectedCb: ((raft: RAFT) => void) | null;
+    toaster: typeof Toaster;
+    connectedRaftContextMethods: {
+        addConnectedRaft: (connectedRaft: ConnectedRaftItem) => void;
+        removeConnectedRaft: (connectedRaftId: string) => void;
+        setSelectedRaft: (connectedRaftId: string) => void;
+    };
+    isPhoneApp: () => boolean;
+    constructor();
+    createNewCog(id: string): Cog;
+    createNewMarty(id: string): Marty;
+    /**
+     * Generic Connect method
+     * This method is called from various environments (connection button, blocksjr, blocks etc.)
+     * Known issue: connecting to a raft from within a platform won't add the newly connected raft to the connectedRafts hook
+     */
+    connectGeneric(afterRaftConnectedCb: (raft: RAFT) => void): Promise<void>;
+    /**
+     * Disconnect from RAFT generic
+     * This method is called from various environments (connection button, blocksjr, blocks etc.)
+     */
+    disconnectGeneric(raft: RAFT): Promise<void>;
+    /**
+     * Selects a RAFT in Phone's verification modal
+     */
+    selectRaft(ricToConnectTo: FOUND_RAFT_ON_DISCOVERY_RESPONSE['foundRIC'], method: RaftConnectionMethod): Promise<RAFT | null>;
+    connectToRIC(method: RaftConnectionMethod): Promise<RAFT | null>;
+    /**
+     * Disconnect from RAFT
+     */
+    disconnectFromRaft(raftId: string): Promise<void>;
+    /**
+     * Removes raft after a certain time
+     * Removes from the rics list after x seconds so that we can still get the last event
+     */
+    _removeRIC(raftId: string, timeout: number): void;
+    /**
+     * Start looking for rics to connect to
+     * This is used from the Phone App only
+     */
+    startDiscovery(ricSelectedCb: (raft: RAFT) => void): Promise<void>;
+    /**
+     * Stop verifying raft
+     */
+    stopVerifyingRaft(raftId: string, isCorrectRIC: boolean): Promise<void>;
+    /**
+     * Publishing events to observers
+     * It could be either events we get from RAFT, or custom events related to the app
+     */
+    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    subscribe(observer: RaftObserver, topics: Array<string>): void;
+    unsubscribe(observer: RaftObserver): void;
+    receivedRICEvent(raftId: string, eventType: any, eventEnum: any, eventName: any, eventData: any): void;
+    /**
+     * Save the file on the device
+     */
+    saveFileOnDevice(fileName: string, base64: string): void | Promise<unknown>;
+    /**
+     * Save the file on the device's local storage
+     */
+    saveFileOnDeviceLocalStorage(dirname: string, fileName: string, base64: string): void | Promise<unknown>;
+    /**
+     * Load the file from the device's local storage
+     */
+    loadFileFromDeviceLocalStorage(dirname: string, fileName: string): void | Promise<unknown>;
+    /**
+     * Delete the file from the device's local storage
+     */
+    deleteFileFromDeviceLocalStorage(dirname: string, fileName: string): void | Promise<unknown>;
+    /**
+     * List the files from the device's local storage
+     */
+    listFilesFromDeviceLocalStorage(dirname: string): Promise<unknown>;
+}

package/dist-types/src/application/ApplicationManager/ApplicationManager.js

@@ -0,0 +1,448 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { createElement } from "react";
+import modalState from "../../state-observables/modal/ModalState";
+import { RaftConnectionMethod, RaftTypeE } from "../../types/raft";
+import WebAppCommunicator from "../../wrapper-app/communicators/WebAppCommunicator";
+import RAFT from "../RAFTs/RAFT";
+import Marty from "../RAFTs/Marty/Marty";
+import Cog from "../RAFTs/Cog/Cog";
+import VerificationModal from "../../components/modals/VerificationModal";
+import { raftFoundSubscriptionHelper } from "../RAFTs/raft-subscription-helpers";
+import { AppSentMessage } from "../../types/communication-between-apps/wrapper-communication";
+import VerificationModalPhoneApp from "../../components/modals/VerificationModalPhoneApp";
+import Logger from "../../services/logger/Logger";
+import isPhoneApp from "../../utils/phone-app-communication/is-phone-app";
+import DisconnectConfirmationModal from "../../components/modals/DisconnectConfirmation";
+import Toaster from "../../utils/Toaster";
+var SHOW_LOGS = true;
+var TAG = "ApplicationManager";
+var ApplicationManager = /** @class */ (function () {
+    function ApplicationManager() {
+        // Observers
+        this._observers = {};
+        // Connected RICs
+        this.connectedRafts = {};
+        // Callback to call when a RAFT is selected (Phone App only)
+        // We need that to make sure the connection button gets the selected RAFT once the user selects one
+        this.ricSelectedCb = null;
+        // // RICNotificationsManager
+        // private _ricNotificationsManager: RICNotificationsManager = new RICNotificationsManager(
+        //     this
+        // );
+        // sound streaming stats
+        // public soundStreamingStats = new MartySoundStreamingStats();
+        // Updater removers: when marty disconnects
+        // these functions will clear the time intervals
+        // created for updating the sensors
+        // all dbs for session data
+        // public sessionDbs = new SessionsDBManager();
+        // toaster
+        this.toaster = Toaster;
+        // connected raft context methods
+        this.connectedRaftContextMethods = {
+            addConnectedRaft: function (connectedRaft) { },
+            removeConnectedRaft: function (connectedRaftId) { },
+            setSelectedRaft: function (connectedRaftId) { },
+        };
+        this.isPhoneApp = isPhoneApp;
+        // super();
+        // AnalyticsManager.appStartSession();
+    }
+    ApplicationManager.prototype.createNewCog = function (id) {
+        return new Cog(id);
+    };
+    ApplicationManager.prototype.createNewMarty = function (id) {
+        return new Marty(id);
+    };
+    /**
+     * Generic Connect method
+     * This method is called from various environments (connection button, blocksjr, blocks etc.)
+     * Known issue: connecting to a raft from within a platform won't add the newly connected raft to the connectedRafts hook
+     */
+    ApplicationManager.prototype.connectGeneric = function (afterRaftConnectedCb) {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_1, newRaft, e_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!isPhoneApp()) return [3 /*break*/, 5];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, window.applicationManager.startDiscovery(function (newRaft) {
+                                _this.connectedRaftContextMethods.addConnectedRaft({ id: newRaft.id, name: newRaft.getFriendlyName() || "", isSelected: true });
+                                afterRaftConnectedCb(newRaft);
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Failed to start discovery: ".concat(e_1));
+                        return [3 /*break*/, 4];
+                    case 4: return [3 /*break*/, 8];
+                    case 5:
+                        _a.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, window.applicationManager.connectToRIC(RaftConnectionMethod.WEB_BLE)];
+                    case 6:
+                        newRaft = _a.sent();
+                        if (newRaft) {
+                            this.connectedRaftContextMethods.addConnectedRaft({ id: newRaft.id, name: newRaft.getFriendlyName() || "", isSelected: true });
+                            afterRaftConnectedCb(newRaft);
+                        }
+                        return [3 /*break*/, 8];
+                    case 7:
+                        e_2 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Failed to connect to new robot: ".concat(e_2));
+                        return [3 /*break*/, 8];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnect from RAFT generic
+     * This method is called from various environments (connection button, blocksjr, blocks etc.)
+     */
+    ApplicationManager.prototype.disconnectGeneric = function (raft) {
+        return __awaiter(this, void 0, void 0, function () {
+            var confirmDisconnect, e_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, modalState.setModal(createElement(DisconnectConfirmationModal, { connectedRaft: window.applicationManager.connectedRafts[raft.id] }), "Are you sure you want to disconnect from your ".concat(raft.getFriendlyName(), "?"))];
+                    case 1:
+                        confirmDisconnect = _a.sent();
+                        if (!confirmDisconnect) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, window.applicationManager.disconnectFromRaft(raft.id)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_3 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Failed to disconnect from robot: ".concat(e_3));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Selects a RAFT in Phone's verification modal
+     */
+    ApplicationManager.prototype.selectRaft = function (ricToConnectTo, method) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var selectResults, raftId, raftType, raft;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_SELECT, { discoveredRIC: ricToConnectTo, method: method })];
+                    case 1:
+                        selectResults = _c.sent();
+                        if (!selectResults.success) return [3 /*break*/, 3];
+                        raftId = (_a = selectResults.data) === null || _a === void 0 ? void 0 : _a.raftId;
+                        raftType = (_b = selectResults.data) === null || _b === void 0 ? void 0 : _b.raftType;
+                        if (!raftId || !raftType) {
+                            throw new Error("RAFT ID or RAFT Type is missing: ".concat(raftId, " ").concat(raftType));
+                        }
+                        raft = void 0;
+                        switch (raftType) {
+                            case RaftTypeE.MARTY:
+                                raft = this.createNewMarty(raftId);
+                                break;
+                            case RaftTypeE.COG:
+                                raft = this.createNewCog(raftId);
+                                break;
+                            default:
+                                throw new Error("Unknown RAFT type");
+                        }
+                        this.connectedRafts[raftId] = raft;
+                        // get missed Connect event
+                        window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.GET_MISSED_CONN_EVENT, { raftId: raftId });
+                        // Note: we're verifying the RAFT from the place this functions is called
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 200); })];
+                    case 2:
+                        // Note: we're verifying the RAFT from the place this functions is called
+                        _c.sent();
+                        if (this.ricSelectedCb) {
+                            this.ricSelectedCb(raft);
+                        }
+                        return [2 /*return*/, raft];
+                    case 3:
+                        Logger.warn(SHOW_LOGS, TAG, "Failed to select RAFT with id: ".concat(ricToConnectTo._id));
+                        _c.label = 4;
+                    case 4: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    ApplicationManager.prototype.connectToRIC = function (method) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var wasConnectedObj, raftId, raftType, raft;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, RAFT.connect(method)];
+                    case 1:
+                        wasConnectedObj = _c.sent();
+                        if (!wasConnectedObj.success) return [3 /*break*/, 3];
+                        raftId = (_a = wasConnectedObj.data) === null || _a === void 0 ? void 0 : _a.raftId;
+                        raftType = (_b = wasConnectedObj.data) === null || _b === void 0 ? void 0 : _b.raftType;
+                        if (!raftId || !raftType) {
+                            throw new Error("RAFT ID or RAFT Type is missing: ".concat(raftId, " ").concat(raftType));
+                        }
+                        raft = void 0;
+                        switch (raftType) {
+                            case RaftTypeE.MARTY:
+                                raft = this.createNewMarty(raftId);
+                                break;
+                            case RaftTypeE.COG:
+                                raft = this.createNewCog(raftId);
+                                break;
+                            default:
+                                throw new Error("Unknown RAFT type");
+                        }
+                        this.connectedRafts[raftId] = raft;
+                        // get missed Connect event
+                        window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.GET_MISSED_CONN_EVENT, { raftId: raftId });
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 200); })];
+                    case 2:
+                        _c.sent();
+                        // start verification process
+                        modalState.setModal(createElement(VerificationModal, { connectedRAFT_: raft }), "Looking for ".concat(raft.type));
+                        return [2 /*return*/, raft];
+                    case 3: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnect from RAFT
+     */
+    ApplicationManager.prototype.disconnectFromRaft = function (raftId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var raft;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.connectedRaftContextMethods.removeConnectedRaft(raftId);
+                        raft = this.connectedRafts[raftId];
+                        if (!raft) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, raft.disconnect()];
+                    case 1:
+                        _a.sent();
+                        this._removeRIC(raftId, 11000);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Removes raft after a certain time
+     * Removes from the rics list after x seconds so that we can still get the last event
+     */
+    ApplicationManager.prototype._removeRIC = function (raftId, timeout) {
+        var _this = this;
+        var ricRemovalTimeout = setTimeout(function () {
+            delete _this.connectedRafts[raftId];
+            clearTimeout(ricRemovalTimeout);
+        }, timeout);
+    };
+    /**
+     * Start looking for rics to connect to
+     * This is used from the Phone App only
+     */
+    ApplicationManager.prototype.startDiscovery = function (ricSelectedCb) {
+        return __awaiter(this, void 0, void 0, function () {
+            var foundRICs, wasDiscoveryStarted;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.ricSelectedCb = ricSelectedCb;
+                        foundRICs = [];
+                        raftFoundSubscriptionHelper().subscribe(function (_a) {
+                            var discoveredRIC = _a.discoveredRIC;
+                            // if the discovered RAFT is already in the list, don't add it, just update the rssi
+                            var foundRICIdx = foundRICs.findIndex(function (ric_) { return ric_._id === discoveredRIC._id; });
+                            if (foundRICIdx !== -1) {
+                                foundRICs[foundRICIdx] = discoveredRIC;
+                            }
+                            else {
+                                foundRICs.push(discoveredRIC);
+                            }
+                            // foundRICs.sort((a, b) => b._rssi - a._rssi);
+                            modalState.setModal(createElement(VerificationModalPhoneApp, { foundRICs: foundRICs }), "Looking for RAFT");
+                        });
+                        return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_START_DISCOVERY)];
+                    case 1:
+                        wasDiscoveryStarted = _a.sent();
+                        if (!wasDiscoveryStarted) {
+                            return [2 /*return*/, raftFoundSubscriptionHelper().unsubscribe()];
+                        }
+                        return [4 /*yield*/, modalState.setModal(createElement(VerificationModalPhoneApp, { foundRICs: [] }), "Looking for RAFT")];
+                    case 2:
+                        _a.sent();
+                        raftFoundSubscriptionHelper().unsubscribe();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stop verifying raft
+     */
+    ApplicationManager.prototype.stopVerifyingRaft = function (raftId, isCorrectRIC) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, ((_a = this.connectedRafts[raftId]) === null || _a === void 0 ? void 0 : _a.stopVerifyingRaft(isCorrectRIC))];
+                    case 1:
+                        _b.sent();
+                        this._removeRIC(raftId, 11000);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Publishing events to observers
+     * It could be either events we get from RAFT, or custom events related to the app
+     */
+    ApplicationManager.prototype.publish = function (eventType, eventEnum, eventName, eventData) {
+        if (this._observers.hasOwnProperty(eventType)) {
+            for (var _i = 0, _a = this._observers[eventType]; _i < _a.length; _i++) {
+                var observer = _a[_i];
+                observer.notify(eventType, eventEnum, eventName, eventData);
+            }
+        }
+    };
+    // observer
+    ApplicationManager.prototype.subscribe = function (observer, topics) {
+        for (var _i = 0, topics_1 = topics; _i < topics_1.length; _i++) {
+            var topic = topics_1[_i];
+            if (!this._observers[topic]) {
+                this._observers[topic] = [];
+            }
+            if (this._observers[topic].indexOf(observer) === -1) {
+                this._observers[topic].push(observer);
+            }
+        }
+    };
+    ApplicationManager.prototype.unsubscribe = function (observer) {
+        for (var topic in this._observers) {
+            if (this._observers.hasOwnProperty(topic)) {
+                var index = this._observers[topic].indexOf(observer);
+                if (index !== -1) {
+                    this._observers[topic].splice(index, 1);
+                }
+            }
+        }
+    };
+    ApplicationManager.prototype.receivedRICEvent = function (raftId, eventType, eventEnum, eventName, eventData) {
+        var _a;
+        if (raftId === "scanner") {
+            this.publish(eventType, eventEnum, eventName, eventData);
+        }
+        else {
+            (_a = this.connectedRafts[raftId]) === null || _a === void 0 ? void 0 : _a.receivedRICEvent(eventType, eventEnum, eventName, eventData);
+        }
+    };
+    //======================//
+    /* NATIVE COMMANDS ONLY */
+    //======================//
+    /**
+     * Save the file on the device
+     */
+    ApplicationManager.prototype.saveFileOnDevice = function (fileName, base64) {
+        if (!fileName || !base64) {
+            return Logger.error(SHOW_LOGS, TAG, "fileName or base64 is missing: fileName: ".concat(fileName, ", base64: ").concat(base64));
+        }
+        return window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.SAVE_FILE_ON_DEVICE, { fileName: fileName, base64: base64 });
+    };
+    /**
+     * Save the file on the device's local storage
+     */
+    ApplicationManager.prototype.saveFileOnDeviceLocalStorage = function (dirname, fileName, base64) {
+        if (!fileName || !base64) {
+            return Logger.error(SHOW_LOGS, TAG, "fileName or base64 is missing: fileName: ".concat(fileName, ", base64: ").concat(base64));
+        }
+        return window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.SAVE_FILE_ON_DEVICE_LOCAL_STORAGE, { dirname: dirname, fileName: fileName, base64: base64 });
+    };
+    /**
+     * Load the file from the device's local storage
+     */
+    ApplicationManager.prototype.loadFileFromDeviceLocalStorage = function (dirname, fileName) {
+        if (!fileName) {
+            return Logger.error(SHOW_LOGS, TAG, "fileName is missing: fileName: ".concat(fileName));
+        }
+        return window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.LOAD_FILE_FROM_DEVICE_LOCAL_STORAGE, { dirname: dirname, fileName: fileName });
+    };
+    /**
+     * Delete the file from the device's local storage
+     */
+    ApplicationManager.prototype.deleteFileFromDeviceLocalStorage = function (dirname, fileName) {
+        if (!fileName) {
+            return Logger.error(SHOW_LOGS, TAG, "fileName is missing: fileName: ".concat(fileName));
+        }
+        return window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.DELETE_FILE_FROM_DEVICE_LOCAL_STORAGE, { dirname: dirname, fileName: fileName });
+    };
+    /**
+     * List the files from the device's local storage
+     */
+    ApplicationManager.prototype.listFilesFromDeviceLocalStorage = function (dirname) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.LIST_FILES_FROM_DEVICE_LOCAL_STORAGE, { dirname: dirname })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // Communicator to the wrapper app
+    ApplicationManager.wrapperAppCommunicator = new WebAppCommunicator();
+    return ApplicationManager;
+}());
+export default ApplicationManager;

package/dist-types/src/application/RAFTs/Cog/Cog.d.ts

@@ -0,0 +1,39 @@
+import RAFT from "../RAFT";
+import RICInterface from "../RAFTInterface";
+import { RaftTypeE } from "../../../types/raft";
+import { CogStateInfo, RICLedLcdColours } from "@robotical/roboticaljs";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+export declare class Cog extends RAFT implements RICInterface {
+    id: string;
+    type: RaftTypeE;
+    _ledLcdColours: RICLedLcdColours;
+    raftStateInfo: CogStateInfo | null;
+    constructor(id: string);
+    get ledLcdColours(): RICLedLcdColours;
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    getRSSI(): number;
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    getBatteryStrength(): number;
+    /**
+   * This methods handles RAFT events coming from the RICConnector of the wrapper
+   */
+    handleRaftEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+     * Pub Event Handler
+     */
+    pubEventHandler(eventEnum: RaftPublishEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Highlights the COG by flashing the LED and playing a tune
+     */
+    highlight(): Promise<void>;
+    /**
+     * Raft Info Event Handler
+     */
+    raftInfoEventHandler(eventEnum: RaftInfoEvents, eventName: string, data: any): Promise<void>;
+}
+export default Cog;