@robotical/webapp-types 0.6.58

package/dist-types/src/wrapper-app/connectors/MartyConnector/MartyConnector.js

@@ -0,0 +1,243 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 { RICRoboticalAddOns } from "@robotical/ricjs-robotical-addons";
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+import Logger from "../../../services/logger/Logger";
+import { RaftTypeE } from "../../../types/raft";
+import Connector from "../Connector";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent, } from "@robotical/raftjs";
+import { RICServoParamUpdater, RICSystemUtils, } from "@robotical/roboticaljs";
+import { WrapperSentMessage } from "../../../types/communication-between-apps/wrapper-communication";
+var SHOW_LOGS = true;
+var TAG = "MartyConnector";
+var MartyConnector = /** @class */ (function (_super) {
+    __extends(MartyConnector, _super);
+    function MartyConnector(raftId, connManager) {
+        var _this = _super.call(this, raftId, connManager) || this;
+        _this.type = RaftTypeE.MARTY;
+        return _this;
+    }
+    /**
+     * Publish an event to all observers
+     * Set in RICConnector as an event listener callback
+     */
+    MartyConnector.prototype.publish = function (eventType, eventEnum, eventName, eventData) {
+        if (eventType === "raftinfo") {
+            // marty info do not need manipulation like Cog
+        }
+        window.WebAppCommunicator.sendMessageNoWait(WrapperSentMessage.RAFT_PUBLISHED_EVENT, { raftId: this.id, eventType: eventType, eventEnum: eventEnum, eventName: eventName, eventData: 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);
+            }
+        }
+    };
+    /**
+     * Connect to a RAFT
+     */
+    MartyConnector.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var raftSystemUtils, sysInfoOk, pystatus;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        raftSystemUtils = this.connManager.getConnector().getRaftSystemUtils();
+                        return [4 /*yield*/, raftSystemUtils.getSystemInfo()];
+                    case 1:
+                        sysInfoOk = _a.sent();
+                        if (!sysInfoOk) {
+                            // this.emit(RAFT_REJECTED)
+                            return [2 /*return*/, { success: false, reason: 'no_sys_info' }];
+                        }
+                        return [4 /*yield*/, this.sendRestMessage("pystatus")];
+                    case 2:
+                        pystatus = _a.sent();
+                        // if it's in unplugged mode update the relevant state
+                        // that shows a modal
+                        if (pystatus && pystatus.running === "screenfree.py") {
+                            Logger.warn(SHOW_LOGS, TAG, "Marty is in unplugged mode");
+                            return [2 /*return*/, { success: false, reason: 'unplugged' }];
+                        }
+                        return [2 /*return*/, { success: true, reason: 'success' }];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnect from Marty
+     */
+    MartyConnector.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _super.prototype.disconnect.call(this)];
+                    case 1: 
+                    // this.sendRestMessage('blerestart');
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Event handler
+     */
+    MartyConnector.prototype.eventHandler = function (eventType, eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                _super.prototype.eventHandler.call(this, eventType, eventEnum, eventName, data);
+                switch (eventType) {
+                    case "conn":
+                        this.connectionEventHandler(eventEnum, eventName, data);
+                        break;
+                    case "update":
+                        this.updateEventHandler(eventEnum, eventName, data);
+                        break;
+                    case "pub":
+                        this.pubEventHandler(eventEnum, eventName, data);
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Connection Event Handler
+     */
+    MartyConnector.prototype.connectionEventHandler = function (eventEnum, eventName, data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _b, addOnManager, raftSystemUtils, msgHandler, addonManager, ricSystemUtils, spu, spuTwo, shouldUseLegacySoktoMode;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        Logger.info(SHOW_LOGS, TAG, "Event: ".concat(eventEnum, " data: ").concat(data));
+                        _b = eventEnum;
+                        switch (_b) {
+                            case RaftConnEvent.CONN_CONNECTED: return [3 /*break*/, 1];
+                            case RaftConnEvent.CONN_VERIFIED_CORRECT: return [3 /*break*/, 2];
+                        }
+                        return [3 /*break*/, 4];
+                    case 1: 
+                    // ignore
+                    return [3 /*break*/, 5];
+                    case 2:
+                        addOnManager = this.connManager.getSystemType().getAddOnManager();
+                        RICRoboticalAddOns.registerAddOns(addOnManager);
+                        raftSystemUtils = this.connManager.getConnector().getRaftSystemUtils();
+                        msgHandler = raftSystemUtils.getMsgHandler();
+                        addonManager = this.connManager.getSystemType().getAddOnManager();
+                        ricSystemUtils = new RICSystemUtils(msgHandler, addonManager);
+                        return [4 /*yield*/, ricSystemUtils.retrieveMartySystemInfo()];
+                    case 3:
+                        _c.sent();
+                        spu = RICServoParamUpdater.getSingletonInstance(msgHandler);
+                        spu && spu.init();
+                        spuTwo = RICServoParamUpdater.getSingletonInstance();
+                        spuTwo && spuTwo.setRobotConnected(true);
+                        shouldUseLegacySoktoMode = false // this.soundStreamingStats.shouldUseLegacySoktoMode(systemInfo);
+                        ;
+                        this.connManager.getConnector().setLegacySoktoMode(shouldUseLegacySoktoMode);
+                        // checking for servo faults (this will trigger reportMsgCallback)
+                        (_a = this.connManager.getConnector().getSystemType()) === null || _a === void 0 ? void 0 : _a.getRICServoFaultDetector().atomicReadOperation();
+                        return [3 /*break*/, 5];
+                    case 4: return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Update Event Handler
+     */
+    MartyConnector.prototype.updateEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                Logger.info(SHOW_LOGS, TAG, "Event: ".concat(eventEnum, " data: ").concat(data));
+                switch (eventEnum) {
+                    case RaftUpdateEvent.UPDATE_APP_UPDATE_REQUIRED:
+                        // do something
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Pub Event Handler
+     */
+    MartyConnector.prototype.pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var systemType, stateInfo;
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        systemType = this.connManager.getConnector().getSystemType();
+                        if (systemType) {
+                            stateInfo = systemType.getStateInfo();
+                            this.publish("raftinfo", RaftInfoEvents.STATE_INFO, "StateInfo", { stateInfo: stateInfo });
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return MartyConnector;
+}(Connector));
+export default MartyConnector;

package/dist-types/types-package/application-manager.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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;
+        WebAppCommunicator: WebAppCommunicator;
+        wrapperCommunicator: WrapperCommunicator;
+        applicationManager: ApplicationManager;
+        Logger: Logger;
+    }
+}

package/dist-types/types-package/application-manager.js

@@ -0,0 +1,5 @@
+/**
+ * This file is needed so we can build and publish the ApplicationManager interface to the children projects
+ */
+import ApplicationManager from "../src/application/ApplicationManager/ApplicationManager";
+export { ApplicationManager };

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@robotical/webapp-types",
+  "version": "0.6.58",
+  "description": "Type definitions for the Application Manager",
+  "main": "dist/application-manager.d.ts",
+  "types": "dist/application-manager.d.ts",
+  "author": "Nikos Theodoropoulos",
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}