@robotical/webapp-types 0.6.58

package/dist-types/src/wrapper-app/communicators/WebAppCommunicator.js

@@ -0,0 +1,243 @@
+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 SelfdestructiveMessagePromise from "../../application/communicators/SelfdestructiveMessagePromise";
+import Logger from "../../services/logger/Logger";
+import { AppSentMessage } from "../../types/communication-between-apps/wrapper-communication";
+import randomHashGenerator from "../../utils/helpers/randomHashGenerator";
+import wrapperAppManager from "../WrapperAppManager";
+var SHOW_LOGS = true;
+var TAG = "WebAppCommunicator";
+/**
+ * This file is responsible for the communication between the web app and the Wrapper Web App
+ */
+var WebAppCommunicator = /** @class */ (function () {
+    function WebAppCommunicator() {
+        this.messagePromises = {};
+    }
+    WebAppCommunicator.prototype.receiveMessage = function (receivedMessageStringified) {
+        return __awaiter(this, void 0, void 0, function () {
+            var receivedMessage;
+            return __generator(this, function (_a) {
+                Logger.info(SHOW_LOGS, TAG, "Received message: " + receivedMessageStringified);
+                receivedMessage = JSON.parse(receivedMessageStringified);
+                receivedMessageHandler(receivedMessage.message, receivedMessage.data, receivedMessage.messagePromiseId);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * It sends a message to the phone app
+     * The client can await the response to that message
+     */
+    WebAppCommunicator.prototype.sendMessageAndWait = function (message, data) {
+        var _this = this;
+        Logger.info(SHOW_LOGS, TAG, "Sending message with waiting: " + message);
+        var messagePromiseId = randomHashGenerator();
+        var promise = new Promise(function (resolve, reject) {
+            // this.messagePromises[messagePromiseId] = { resolve: (value: R | PromiseLike<R>) => resolve(value), reject };
+            _this.messagePromises[messagePromiseId] = new SelfdestructiveMessagePromise(resolve, reject, messagePromiseId, _this.messagePromises);
+        });
+        var messageObject = {
+            message: message,
+            data: data,
+            messagePromiseId: messagePromiseId
+        };
+        window.wrapperCommunicator.receiveMessage(messageObject);
+        return promise;
+    };
+    /**
+     * It sends a message to the phone app
+     * The client cannot await the response to that message
+     */
+    WebAppCommunicator.prototype.sendMessageNoWait = function (message, data) {
+        // Logger.info(SHOW_LOGS, TAG, "Sending message without waiting: " + message);
+        var messagePromiseId = randomHashGenerator();
+        var messageObject = {
+            message: message,
+            data: data,
+            messagePromiseId: messagePromiseId
+        };
+        window.wrapperCommunicator.receiveMessage(messageObject);
+    };
+    /**
+     * Called by the react-native code to respond to sendMessage
+     */
+    WebAppCommunicator.prototype.onMessageResponse = function (response) {
+        var _a, _b;
+        Logger.info(SHOW_LOGS, TAG, "Received message reply: " + JSON.stringify(response));
+        if (this.messagePromises[response.messagePromiseId]) {
+            if (response.success) {
+                (_a = this.messagePromises[response.messagePromiseId]) === null || _a === void 0 ? void 0 : _a.resolve(response.results);
+            }
+            else {
+                (_b = this.messagePromises[response.messagePromiseId]) === null || _b === void 0 ? void 0 : _b.reject(response.error);
+            }
+        }
+        else {
+            Logger.warn(SHOW_LOGS, TAG, "Unhandled message reply with id: ".concat(response.messagePromiseId));
+        }
+    };
+    return WebAppCommunicator;
+}());
+export default WebAppCommunicator;
+var receivedMessageHandler = function (receivedMessage, data, messagePromiseId) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, connectionResults, error_1, ricName, error_2, verifyResults, error_3, stopVerifyResults, error_4, disconnectResults, error_5, restResults, error_6, missedConnEventResults, streamAudioResults;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = receivedMessage;
+                switch (_a) {
+                    case AppSentMessage.RAFT_IS_CONNECTED: return [3 /*break*/, 1];
+                    case AppSentMessage.RAFT_CONNECT: return [3 /*break*/, 2];
+                    case AppSentMessage.RAFT_GET_NAME: return [3 /*break*/, 6];
+                    case AppSentMessage.RAFT_VERIFY: return [3 /*break*/, 10];
+                    case AppSentMessage.RAFT_STOP_VERIFY: return [3 /*break*/, 14];
+                    case AppSentMessage.RAFT_DISCONNECT: return [3 /*break*/, 18];
+                    case AppSentMessage.RAFT_SEND_REST: return [3 /*break*/, 22];
+                    case AppSentMessage.GET_MISSED_CONN_EVENT: return [3 /*break*/, 26];
+                    case AppSentMessage.RAFT_STREAM_AUDIO: return [3 /*break*/, 27];
+                }
+                return [3 /*break*/, 28];
+            case 1:
+                try {
+                    console.log("3");
+                    // const connectionResults = await wrapperAppManager.isConnected();
+                    console.log("12");
+                    // console.log("raft is connected results", connectionResults);
+                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: { log: "13" }, messagePromiseId: messagePromiseId });
+                }
+                catch (error) {
+                    window.wrapperCommunicator.onMessageResponse({ success: false, error: error.message, messagePromiseId: messagePromiseId });
+                }
+                return [3 /*break*/, 29];
+            case 2:
+                _b.trys.push([2, 4, , 5]);
+                return [4 /*yield*/, wrapperAppManager.connect(data.method, data.uuids)];
+            case 3:
+                connectionResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: connectionResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 5];
+            case 4:
+                error_1 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_1.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 5];
+            case 5: return [3 /*break*/, 29];
+            case 6:
+                _b.trys.push([6, 8, , 9]);
+                return [4 /*yield*/, wrapperAppManager.getRaftName(data.raftId)];
+            case 7:
+                ricName = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: ricName, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 9];
+            case 8:
+                error_2 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_2.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 9];
+            case 9: return [3 /*break*/, 29];
+            case 10:
+                _b.trys.push([10, 12, , 13]);
+                return [4 /*yield*/, wrapperAppManager.verifyRaft(data.ledLcdColours, data.raftId)];
+            case 11:
+                verifyResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: verifyResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 13];
+            case 12:
+                error_3 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_3.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 13];
+            case 13: return [3 /*break*/, 29];
+            case 14:
+                _b.trys.push([14, 16, , 17]);
+                return [4 /*yield*/, wrapperAppManager.stopVerifyingRaft(data.isCorrectRIC, data.raftId)];
+            case 15:
+                stopVerifyResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: stopVerifyResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 17];
+            case 16:
+                error_4 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_4.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 17];
+            case 17: return [3 /*break*/, 29];
+            case 18:
+                _b.trys.push([18, 20, , 21]);
+                return [4 /*yield*/, wrapperAppManager.disconnect(data.raftId)];
+            case 19:
+                disconnectResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: disconnectResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 21];
+            case 20:
+                error_5 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_5.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 21];
+            case 21: return [3 /*break*/, 29];
+            case 22:
+                _b.trys.push([22, 24, , 25]);
+                return [4 /*yield*/, wrapperAppManager.sendRestMessage(data.msg, data.params, data.raftId)];
+            case 23:
+                restResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: restResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 25];
+            case 24:
+                error_6 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_6.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 25];
+            case 25: return [3 /*break*/, 29];
+            case 26:
+                try {
+                    missedConnEventResults = wrapperAppManager.getMissedConnEvent(data.raftId);
+                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: missedConnEventResults, messagePromiseId: messagePromiseId });
+                }
+                catch (error) {
+                    window.wrapperCommunicator.onMessageResponse({ success: false, error: error.message, messagePromiseId: messagePromiseId });
+                }
+                return [3 /*break*/, 29];
+            case 27:
+                try {
+                    streamAudioResults = wrapperAppManager.streamAudio(data.raftId, data.streamContents, data.clearExisting, data.duration);
+                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: streamAudioResults, messagePromiseId: messagePromiseId });
+                }
+                catch (error) {
+                    window.wrapperCommunicator.onMessageResponse({ success: false, error: error.message, messagePromiseId: messagePromiseId });
+                }
+                return [3 /*break*/, 29];
+            case 28:
+                Logger.warn(SHOW_LOGS, TAG, "Unhandled message: ".concat(receivedMessage));
+                _b.label = 29;
+            case 29: return [2 /*return*/];
+        }
+    });
+}); };

package/dist-types/src/wrapper-app/connectors/CogConnector/CogConnector.d.ts

@@ -0,0 +1,40 @@
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+import { ConnectionAttemptResults, RaftTypeE } from "../../../types/raft";
+import Connector from "../Connector";
+import ConnectorInterface from "../ConnectorInterface";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { ConnManager } from "@robotical/roboticaljs";
+declare class CogConnector extends Connector implements ConnectorInterface {
+    type: RaftTypeE;
+    constructor(raftId: string, connManager: ConnManager);
+    /**
+     * Publish an event to all observers
+     * Set in RICConnector as an event listener callback
+     */
+    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+     * Connect to a RAFT
+     */
+    connect(): Promise<ConnectionAttemptResults>;
+    /**
+     * Disconnect from Cog
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Event handler
+     */
+    eventHandler(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, data: any): Promise<void>;
+    /**
+     * Connection Event Handler
+     */
+    connectionEventHandler(eventEnum: RaftConnEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Update Event Handler
+     */
+    updateEventHandler(eventEnum: RaftUpdateEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Pub Event Handler
+     */
+    pubEventHandler(eventEnum: RaftPublishEvent, eventName: string, data: any): Promise<void>;
+}
+export default CogConnector;

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

@@ -0,0 +1,209 @@
+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 { RaftInfoEvents } from "../../../types/events/raft-info";
+import Logger from "../../../services/logger/Logger";
+import { RaftTypeE } from "../../../types/raft";
+import Connector from "../Connector";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { CogPublishedDataGetter } from "@robotical/roboticaljs";
+import { WrapperSentMessage } from "../../../types/communication-between-apps/wrapper-communication";
+var SHOW_LOGS = true;
+var TAG = "CogConnector";
+var CogConnector = /** @class */ (function (_super) {
+    __extends(CogConnector, _super);
+    function CogConnector(raftId, connManager) {
+        var _this = _super.call(this, raftId, connManager) || this;
+        _this.type = RaftTypeE.COG;
+        return _this;
+    }
+    /**
+     * Publish an event to all observers
+     * Set in RICConnector as an event listener callback
+     */
+    CogConnector.prototype.publish = function (eventType, eventEnum, eventName, eventData) {
+        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
+     */
+    CogConnector.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var sysInfoOk;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connManager.getConnector().getRaftSystemUtils().getSystemInfo()];
+                    case 1:
+                        sysInfoOk = _a.sent();
+                        if (!sysInfoOk) {
+                            // this.emit(RAFT_REJECTED)
+                            return [2 /*return*/, { success: false, reason: 'no_sys_info' }];
+                        }
+                        return [2 /*return*/, { success: true, reason: 'success' }];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnect from Cog
+     */
+    CogConnector.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
+     */
+    CogConnector.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
+     */
+    CogConnector.prototype.connectionEventHandler = 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 RaftConnEvent.CONN_CONNECTED:
+                        break;
+                    case RaftConnEvent.CONN_VERIFIED_CORRECT:
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Update Event Handler
+     */
+    CogConnector.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
+     */
+    CogConnector.prototype.pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var systemType, stateInfo, simplifiedInfo;
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        systemType = this.connManager.getConnector().getSystemType();
+                        if (systemType) {
+                            stateInfo = systemType.getStateInfo();
+                            if (stateInfo.deviceManager) {
+                                simplifiedInfo = {
+                                    power: CogPublishedDataGetter.getPowerData(stateInfo.deviceManager),
+                                    accelerometer: CogPublishedDataGetter.getAccelerometerData(stateInfo.deviceManager),
+                                    light: CogPublishedDataGetter.getLightData(stateInfo.deviceManager),
+                                    gyroscope: CogPublishedDataGetter.getGyroscopeData(stateInfo.deviceManager)
+                                };
+                                this.publish("raftinfo", RaftInfoEvents.STATE_INFO, "StateInfo", { stateInfo: simplifiedInfo });
+                            }
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return CogConnector;
+}(Connector));
+export default CogConnector;

package/dist-types/src/wrapper-app/connectors/Connector.d.ts

@@ -0,0 +1,72 @@
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { ConnectionAttemptResults, RaftTypeE } from "../../types/raft";
+import { RaftObserver } from "../../application/RAFTs/RaftObserver";
+import ConnectorInterface from "./ConnectorInterface";
+import { ConnManager, RICLedLcdColours } from "@robotical/roboticaljs";
+import { RaftOKFail, RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robotical/raftjs";
+declare class Connector implements ConnectorInterface {
+    id: string;
+    type: RaftTypeE;
+    protected _observers: {
+        [key: string]: Array<RaftObserver>;
+    };
+    connManager: ConnManager;
+    constructor(id: string, connManager: ConnManager);
+    /**
+     * Connect to a RAFT after having found the RAFT type
+     */
+    connect(): Promise<ConnectionAttemptResults>;
+    /**
+     * Get connected raft info
+     */
+    getSystemInfo(): Promise<import("@robotical/raftjs").RaftSystemInfo>;
+    /**
+     * Gets the RAFT name
+     */
+    getRaftName(): Promise<string>;
+    /**
+     * Send a REST message to the RAFT
+     */
+    sendRestMessage(msg: string, params?: object): Promise<RaftOKFail>;
+    /**
+     * Verify correct RAFT is selected
+     */
+    verifyRaft(ledLcdColours: RICLedLcdColours): Promise<boolean>;
+    /**
+     * Disconnect from a RAFT
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Stop verifying RAFT
+     * @param confirmCorrectRIC - indicates if the correct RAFT was selected (user input)
+     */
+    stopVerifyingRaft(confirmCorrectRIC: boolean): Promise<boolean>;
+    /**
+     * Audio streaming
+     */
+    streamAudio(streamContents: Uint8Array, clearExisting: boolean, duration: number): Promise<void>;
+    /**
+     * Publish an event to all observers
+     * Set in RICConnector as an event listener callback
+     */
+    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+    * Event handler
+    */
+    eventHandler(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, data: any): Promise<void>;
+    /**
+     * Connection Event Handler
+     * This handles the events that are the same for all RAFT systems (e.g., Marty, Cog, etc.)
+     * While the system-specific events are handled in the system-specific connectors
+     */
+    _connectionEventHandler(eventEnum: RaftConnEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Update Event Handler
+     */
+    _updateEventHandler(eventEnum: RaftUpdateEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Pub Event Handler
+     */
+    _pubEventHandler(eventEnum: RaftPublishEvent, eventName: string, data: any): Promise<void>;
+}
+export default Connector;