@robotical/webapp-types 1.0.0

package/dist-types/src/application/RAFTs/Cog/Cog.js

@@ -0,0 +1,171 @@
+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 RAFT from "../RAFT";
+import { RaftTypeE } from "../../../types/raft";
+import { RaftPublishEvent } from "@robdobsn/raftjs";
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+var Cog = /** @class */ (function (_super) {
+    __extends(Cog, _super);
+    function Cog(id) {
+        var _this = _super.call(this, id) || this;
+        _this.id = id;
+        _this.type = RaftTypeE.COG;
+        // Colours to use for LED patterns
+        _this._ledLcdColours = [
+            { led: "#202000", lcd: "#FFFF00" },
+            { led: "#880000", lcd: "#FF0000" },
+            { led: "#000040", lcd: "#0080FF" },
+            { led: "#004000", lcd: "#00FF00" },
+        ];
+        // RAFT State Info
+        _this.raftStateInfo = null;
+        return _this;
+    }
+    Object.defineProperty(Cog.prototype, "ledLcdColours", {
+        get: function () {
+            return this._ledLcdColours;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    Cog.prototype.getRSSI = function () {
+        // RSSI is not published by the COG yet
+        var possibleValues = [126, 127];
+        return possibleValues[Math.floor(Math.random() * possibleValues.length)];
+    };
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    Cog.prototype.getBatteryStrength = function () {
+        var _a;
+        return ((_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.Power.battV) || 0;
+    };
+    /**
+   * This methods handles RAFT events coming from the RICConnector of the wrapper
+   */
+    Cog.prototype.handleRaftEvent = function (eventType, eventEnum, eventName, eventData) {
+        _super.prototype.handleRaftEvent.call(this, eventType, eventEnum, eventName, eventData);
+        switch (eventType) {
+            case "pub":
+                this.pubEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "raftinfo":
+                this.raftInfoEventHandler(eventEnum, eventName, eventData);
+                break;
+            default:
+                break;
+        }
+    };
+    /**
+     * Pub Event Handler
+     */
+    Cog.prototype.pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Highlights the COG by flashing the LED and playing a tune
+     */
+    Cog.prototype.highlight = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRestMessage('led//color/#ff8585')];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('audio/rtttl/NoteASharp:d=4,o=6,b=600:a#')];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('led//color/#000000')];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Raft Info Event Handler
+     */
+    Cog.prototype.raftInfoEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftInfoEvents.STATE_INFO:
+                        this.raftStateInfo = data.stateInfo;
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return Cog;
+}(RAFT));
+export { Cog };
+export default Cog;

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

@@ -0,0 +1,40 @@
+import RICInterface from "../RAFTInterface";
+import { RaftTypeE } from "../../../types/raft";
+import RAFT from "../RAFT";
+import { RaftConnEvent, RaftPublishEvent, RaftSystemInfo, RaftUpdateEvent } from "@robdobsn/raftjs";
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+import { RICLedLcdColours, RICStateInfo } from "@robotical/roboticaljs";
+export declare class Marty extends RAFT implements RICInterface {
+    id: string;
+    type: RaftTypeE;
+    raftStateInfo: RICStateInfo | null;
+    systemInfo: RaftSystemInfo | null;
+    _ledLcdColours: RICLedLcdColours;
+    constructor(id: string);
+    get ledLcdColours(): RICLedLcdColours;
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    getRSSI(): number;
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    getBatteryStrength(): number;
+    /**
+     * Highlights Marty by flashing the LED and playing a tune
+     */
+    highlight(): Promise<void>;
+    /**
+   * 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>;
+    /**
+     * Raft Info Event Handler
+     */
+    raftInfoEventHandler(eventEnum: RaftInfoEvents, eventName: string, data: any): Promise<void>;
+}
+export default Marty;

package/dist-types/src/application/RAFTs/Marty/Marty.js

@@ -0,0 +1,179 @@
+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 { RaftTypeE } from "../../../types/raft";
+import RAFT from "../RAFT";
+import { RaftPublishEvent } from "@robdobsn/raftjs";
+var Marty = /** @class */ (function (_super) {
+    __extends(Marty, _super);
+    // // Joint names
+    // private _jointNames = {
+    //     LeftHip: "LeftHip",
+    //     LeftTwist: "LeftTwist",
+    //     LeftKnee: "LeftKnee",
+    //     RightHip: "RightHip",
+    //     RightTwist: "RightTwist",
+    //     RightKnee: "RightKnee",
+    //     LeftArm: "LeftArm",
+    //     RightArm: "RightArm",
+    //     Eyes: "Eyes",
+    // };
+    function Marty(id) {
+        var _this = _super.call(this, id) || this;
+        _this.id = id;
+        _this.type = RaftTypeE.MARTY;
+        // RAFT State Info
+        _this.raftStateInfo = null;
+        // Marty System info
+        _this.systemInfo = null;
+        // Colours to use for LED patterns
+        _this._ledLcdColours = [
+            { led: "#202000", lcd: "#FFFF00" },
+            { led: "#880000", lcd: "#FF0000" },
+            { led: "#000040", lcd: "#0080FF" },
+        ];
+        return _this;
+    }
+    Object.defineProperty(Marty.prototype, "ledLcdColours", {
+        get: function () {
+            return this._ledLcdColours;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    Marty.prototype.getRSSI = function () {
+        var _a;
+        return ((_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.robotStatus.robotStatus.bleRSSI) || -200;
+    };
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    Marty.prototype.getBatteryStrength = function () {
+        var _a;
+        return ((_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.power.powerStatus.battRemainCapacityPercent) || 0;
+    };
+    /**
+     * Highlights Marty by flashing the LED and playing a tune
+     */
+    Marty.prototype.highlight = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRestMessage('led/LEDeye/color/#ff8585')];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('filerun/arcade-beep.mp3')];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('led/LEDeye/color/#000000')];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+   * This methods handles RAFT events coming from the RICConnector of the wrapper
+   */
+    Marty.prototype.handleRaftEvent = function (eventType, eventEnum, eventName, eventData) {
+        _super.prototype.handleRaftEvent.call(this, eventType, eventEnum, eventName, eventData);
+        switch (eventType) {
+            case "pub":
+                this.pubEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "raftinfo":
+                this.raftInfoEventHandler(eventEnum, eventName, eventData);
+                break;
+            default:
+                break;
+        }
+    };
+    /**
+     * Pub Event Handler
+     */
+    Marty.prototype.pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Raft Info Event Handler
+     */
+    Marty.prototype.raftInfoEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return Marty;
+}(RAFT));
+export { Marty };
+export default Marty;

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

@@ -0,0 +1,109 @@
+import { ConnectionAttemptResults, RaftConnectionMethod, RaftTypeE } from "../../types/raft";
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { FOUND_RAFT_ON_DISCOVERY_RESPONSE } from "../../types/phone-app-communicator";
+import RICInterface from "./RAFTInterface";
+import { RaftObserver } from "./RaftObserver";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent, RaftOKFail, RaftSystemInfo } from "@robdobsn/raftjs";
+import { CogStateInfo, RICLedLcdColours, RICStateInfo } from "@robotical/roboticaljs";
+export default class RAFT implements RICInterface {
+    id: string;
+    type: RaftTypeE;
+    _ledLcdColours: RICLedLcdColours;
+    protected _observers: {
+        [key: string]: Array<RaftObserver>;
+    };
+    isSerialNoRegisteredInWarranty: boolean | null;
+    systemInfo: RaftSystemInfo | null;
+    raftStateInfo: RICStateInfo | CogStateInfo | null;
+    /**
+     * Method to get ledLcdColours, to be implemented in child classes.
+     */
+    get ledLcdColours(): RICLedLcdColours;
+    constructor(id: string);
+    /**
+     * Check if RAFT is connected
+     * Sends a message to the Wrapper RICConnector and waits for a response
+     */
+    getIsConnectedFresh(): Promise<boolean>;
+    /**
+    * Connect to a RAFT
+    * We first connect, then we discover the raft type, and then we create the appopriate raft instance
+    */
+    static connect(method: RaftConnectionMethod): Promise<ConnectionAttemptResults>;
+    /**
+     * Disconnect from a RAFT
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Get RAFT name
+     */
+    getRaftName(): Promise<string>;
+    /**
+    * Verify correct RAFT is selected for phone app
+    */
+    verifyRaftPhoneApp(discoveredRIC: FOUND_RAFT_ON_DISCOVERY_RESPONSE['foundRIC']): Promise<boolean>;
+    /**
+    * Verify correct RAFT is selected
+    */
+    verifyRaft(): Promise<boolean>;
+    /**
+     * Stops the verification process
+     */
+    stopVerifyingRaft(isCorrectRIC: boolean): Promise<boolean>;
+    /**
+     * Receiveds events from the RICConnector
+     */
+    receivedRICEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+     * Send a REST message to the RAFT
+     */
+    sendRestMessage(msg: string, params?: object): Promise<RaftOKFail>;
+    /**
+     * Highlights the raft
+     */
+    highlight(): 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;
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    getRSSI(): number;
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    getBatteryStrength(): number;
+    /**
+     * Gets the version of the RAFT
+     */
+    getRaftVersion(): string;
+    /**
+     * Gets the Serial Number of the RAFT
+     */
+    getSerialNumber(): string;
+    /**
+     * Gets the Friendly name of the RAFT
+     */
+    getFriendlyName(): string | undefined;
+    /**
+     * Stream audio to the RAFT
+     */
+    streamAudio(streamContents: Uint8Array, clearExisting: boolean, duration: number): Promise<boolean>;
+    /**
+     * Handles RAFT events
+     * (to be implemented in child classes)
+     */
+    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>;
+    /**
+     * Raft Info Event Handler
+     */
+    _raftInfoEventHandler(eventEnum: RaftInfoEvents, eventName: string, data: any): Promise<void>;
+}