@robotical/webapp-types 0.6.58

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

@@ -0,0 +1,567 @@
+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, { secondaryModalState } 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";
+import { AnalyticsManager } from "../../analytics/AnalyticsManager";
+import { ConnManager } from "@robotical/roboticaljs";
+import ConnectingLoadingSpinnerModal from "../../components/modals/ConnectingLoadingSpinnerModal";
+import draggableModalState from "../../state-observables/modal/DraggableModalState";
+import SensorsDashboardModal from "../../components/modals/ SensorsDashboardModal";
+var SHOW_LOGS = true;
+var TAG = "ApplicationManager";
+var ApplicationManager = /** @class */ (function () {
+    function ApplicationManager() {
+        // Observers
+        this._observers = {};
+        // Connected RICs
+        this.connectedRafts = {};
+        this.connectedRaftsContext = [];
+        this.returnToMainApp = function () { };
+        // 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;
+        // Analytics Manager
+        this.analyticsManager = AnalyticsManager.getInstance();
+        this.showBackHomeButton = function () { };
+        this.hideBackHomeButton = function () { };
+        // connected raft context methods
+        this.connectedRaftContextMethods = {
+            addConnectedRaft: function (connectedRaft) { },
+            removeConnectedRaft: function (connectedRaftId) { },
+            setSelectedRaft: function (connectedRaftId) { },
+        };
+        this.isPhoneApp = isPhoneApp;
+        // super();
+        // DatabaseManager.appStartSession();
+        this.connectGenericMarty = this.connectGenericMarty.bind(this);
+        this.connectGenericCog = this.connectGenericCog.bind(this);
+    }
+    ApplicationManager.prototype.setRouter = function (router) {
+        this._router = router;
+    };
+    ApplicationManager.prototype.navigateTo = function (path) {
+        if (this._router) {
+            this._router.navigate(path);
+        }
+        else {
+            Logger.error(SHOW_LOGS, TAG, "Router is not set");
+        }
+    };
+    ApplicationManager.prototype.createNewCog = function (id) {
+        return new Cog(id);
+    };
+    ApplicationManager.prototype.createNewMarty = function (id) {
+        return new Marty(id);
+    };
+    ApplicationManager.prototype.connectGenericMarty = function (afterRaftConnectedCb) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.connectGeneric(afterRaftConnectedCb, [ConnManager.RICUUID])];
+            });
+        });
+    };
+    ApplicationManager.prototype.connectGenericCog = function (afterRaftConnectedCb) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.connectGeneric(afterRaftConnectedCb, [ConnManager.COGUUID])];
+            });
+        });
+    };
+    /**
+     * 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, uuids) {
+        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 (!uuids) {
+                            uuids = [ConnManager.COGUUID, ConnManager.RICUUID];
+                        }
+                        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, type: newRaft.type, name: newRaft.getFriendlyName() || "", isSelected: true });
+                                afterRaftConnectedCb(newRaft);
+                            }, uuids)];
+                    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*/, 10];
+                    case 5:
+                        secondaryModalState.setModal(createElement(ConnectingLoadingSpinnerModal, {}), "Connecting...", false);
+                        _a.label = 6;
+                    case 6:
+                        _a.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, window.applicationManager.connectToRIC(RaftConnectionMethod.WEB_BLE, uuids)];
+                    case 7:
+                        newRaft = _a.sent();
+                        if (newRaft) {
+                            this.connectedRaftContextMethods.addConnectedRaft({ id: newRaft.id, type: newRaft.type, name: newRaft.getFriendlyName() || "", isSelected: true });
+                            afterRaftConnectedCb(newRaft);
+                        }
+                        return [3 /*break*/, 9];
+                    case 8:
+                        e_2 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Failed to connect to new robot: ".concat(e_2));
+                        return [3 /*break*/, 9];
+                    case 9:
+                        secondaryModalState.closeModal();
+                        _a.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnect from RAFT generic
+     * This method is called from various environments (connection button, blocksjr, blocks etc.)
+     */
+    ApplicationManager.prototype.disconnectGeneric = function (raft, afterRaftDisconnectedCb) {
+        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), "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();
+                        if (afterRaftDisconnectedCb) {
+                            afterRaftDisconnectedCb();
+                        }
+                        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, { discoveredDevice: 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, uuids) {
+        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, uuids)];
+                    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];
+                }
+            });
+        });
+    };
+    /**
+     * Toggles the Sensors Dashboard modal
+     */
+    ApplicationManager.prototype.toggleSensorsDashboard = function () {
+        if (draggableModalState.modalContent) {
+            return draggableModalState.closeModal();
+        }
+        return draggableModalState.setModal(createElement(SensorsDashboardModal), "Sensor Insights Hub (βETA)", "sensors-dashboard");
+    };
+    /**
+     * 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._removeRaft(raftId, 3000);
+                        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._removeRaft = 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, uuids) {
+        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 discoveredDevice = _a.discoveredDevice;
+                            // 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 === discoveredDevice._id; });
+                            if (foundRICIdx !== -1) {
+                                foundRICs[foundRICIdx] = discoveredDevice;
+                            }
+                            else {
+                                foundRICs.push(discoveredDevice);
+                            }
+                            // foundRICs.sort((a, b) => b._rssi - a._rssi);
+                            modalState.setModal(createElement(VerificationModalPhoneApp, { foundRICs: foundRICs }), "Looking for RAFT");
+                        });
+                        modalState.setModal(createElement(VerificationModalPhoneApp, { foundRICs: [] }), "Looking for RAFT");
+                        return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_START_DISCOVERY, { uuids: uuids })];
+                    case 1:
+                        wasDiscoveryStarted = _a.sent();
+                        return [4 /*yield*/, modalState.setModal(createElement(VerificationModalPhoneApp, { foundRICs: [] }), "Looking for RAFT")];
+                    case 2:
+                        _a.sent();
+                        if (!wasDiscoveryStarted) {
+                            return [2 /*return*/, raftFoundSubscriptionHelper().unsubscribe()];
+                        }
+                        raftFoundSubscriptionHelper().unsubscribe();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stοp discovery
+     * When the user cancels the discovery process without having first connected to a robot
+     */
+    ApplicationManager.prototype.stopDiscovery = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var wasDiscoveryStopped;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_STOP_DISCOVERY)];
+                    case 1:
+                        wasDiscoveryStopped = _a.sent();
+                        Logger.phoneAppLog(SHOW_LOGS, TAG, "Was discovery stopped: " + wasDiscoveryStopped);
+                        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._removeRaft(raftId, 3000);
+                        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()];
+                }
+            });
+        });
+    };
+    /**
+     * Injects JS code to the phone app
+     * This is used to call native functions from the web app
+     */
+    ApplicationManager.prototype.injectJS = function (jsCode) {
+        return window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.INJECT_JS, { jsCode: jsCode });
+    };
+    /*======== END OF NATIVE COMMANDS ONLY ========*/
+    //======================//
+    /* UI */
+    //======================//
+    //======================//
+    /* HELPERS */
+    //======================//
+    ApplicationManager.prototype.getTheCurrentlySelectedDeviceOrFirstOfItsKind = function (deviceType) {
+        var _a;
+        // checks if the currently selected device is a deviceType and returns it
+        // if not, returns the first deviceType in the list (if there is one)
+        var currentlySelectedId = (_a = this.connectedRaftsContext.find(function (connectedRaft) { return connectedRaft.isSelected; })) === null || _a === void 0 ? void 0 : _a.id;
+        if (currentlySelectedId) {
+            var selectedRaft = this.connectedRafts[currentlySelectedId];
+            if (!selectedRaft) {
+                return;
+            }
+            if (selectedRaft.type === deviceType) {
+                // the currently selected device is a cog, return it
+                return selectedRaft;
+            }
+            else {
+                // the currently selected device is not a cog, find the first cog in the list
+                var fistCog = void 0;
+                for (var raftId in this.connectedRafts) {
+                    if (this.connectedRafts[raftId].type === deviceType) {
+                        fistCog = this.connectedRafts[raftId];
+                        break;
+                    }
+                }
+                return fistCog;
+            }
+        }
+    };
+    // 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,50 @@
+import RAFT from "../RAFT";
+import RICInterface from "../RAFTInterface";
+import { RaftTypeE } from "../../../types/raft";
+import { RICLedLcdColours } from "@robotical/roboticaljs";
+import { SimplifiedCogStateInfo } from "@robotical/roboticaljs/dist/SystemTypeCog/CogTypes";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+import PublishedDataAnalyser from "./PublishedDataAnalyser";
+export declare class Cog extends RAFT implements RICInterface {
+    id: string;
+    type: RaftTypeE;
+    _ledLcdColours: RICLedLcdColours;
+    raftStateInfo: SimplifiedCogStateInfo | null;
+    publishedDataAnalyser: PublishedDataAnalyser;
+    constructor(id: string);
+    get ledLcdColours(): RICLedLcdColours;
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    getRSSI(): number;
+    /**
+     * Helper function to calculate battery strength based on voltage
+     */
+    calculateBatteryStrength(voltage: number): 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;
+    /**
+     * Conn Event Handler
+     */
+    connEventHandler(eventEnum: RaftConnEvent, eventName: string, data: any): Promise<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;