@robotical/webapp-types 1.1.0 → 1.1.2

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

@@ -42,7 +42,7 @@ export default class ApplicationManager {
      * This method is called from various environments (connection button, blocksjr, blocks etc.)
      * Known issue: connecting to a raft from within a platform won't add the newly connected raft to the connectedRafts hook
      */
-    connectGeneric(afterRaftConnectedCb: (raft: RAFT) => void, uuid: string): Promise<void>;
+    connectGeneric(afterRaftConnectedCb: (raft: RAFT) => void, uuids?: string[]): Promise<void>;
     /**
      * Disconnect from RAFT generic
      * This method is called from various environments (connection button, blocksjr, blocks etc.)
@@ -52,7 +52,7 @@ export default class ApplicationManager {
      * Selects a RAFT in Phone's verification modal
      */
     selectRaft(ricToConnectTo: FOUND_RAFT_ON_DISCOVERY_RESPONSE['foundRIC'], method: RaftConnectionMethod): Promise<RAFT | null>;
-    connectToRIC(method: RaftConnectionMethod, uuid: string): Promise<RAFT | null>;
+    connectToRIC(method: RaftConnectionMethod, uuids: string[]): Promise<RAFT | null>;
     /**
      * Disconnect from RAFT
      */
@@ -66,7 +66,12 @@ export default class ApplicationManager {
      * Start looking for rics to connect to
      * This is used from the Phone App only
      */
-    startDiscovery(ricSelectedCb: (raft: RAFT) => void): Promise<void>;
+    startDiscovery(ricSelectedCb: (raft: RAFT) => void, uuids: string[]): Promise<void>;
+    /**
+     * Stοp discovery
+     * When the user cancels the discovery process without having first connected to a robot
+     */
+    stopDiscovery(): Promise<void>;
     /**
      * Stop verifying raft
      */
@@ -99,5 +104,10 @@ export default class ApplicationManager {
      * List the files from the device's local storage
      */
     listFilesFromDeviceLocalStorage(dirname: string): Promise<unknown>;
+    /**
+     * Injects JS code to the phone app
+     * This is used to call native functions from the web app
+     */
+    injectJS(jsCode: string): Promise<unknown>;
     getTheCurrentlySelectedDeviceOrFirstOfItsKind(deviceType: RaftTypeE): RAFT | undefined;
 }

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

@@ -35,7 +35,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { createElement } from "react";
-import modalState from "../../state-observables/modal/ModalState";
+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";
@@ -45,12 +45,13 @@ 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 { RaftChannelBLE, } from "@robotical/raftjs";
 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";
 var SHOW_LOGS = true;
 var TAG = "ApplicationManager";
 var ApplicationManager = /** @class */ (function () {
@@ -113,14 +114,14 @@ var ApplicationManager = /** @class */ (function () {
     ApplicationManager.prototype.connectGenericMarty = function (afterRaftConnectedCb) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.connectGeneric(afterRaftConnectedCb, RaftChannelBLE.RICServiceUUID)];
+                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, RaftChannelBLE.CogServiceUUID)];
+                return [2 /*return*/, this.connectGeneric(afterRaftConnectedCb, [ConnManager.COGUUID])];
             });
         });
     };
@@ -129,13 +130,16 @@ var ApplicationManager = /** @class */ (function () {
      * 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, uuid) {
+    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:
@@ -143,7 +147,7 @@ var ApplicationManager = /** @class */ (function () {
                         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];
@@ -151,22 +155,28 @@ var ApplicationManager = /** @class */ (function () {
                         e_1 = _a.sent();
                         Logger.error(SHOW_LOGS, TAG, "Failed to start discovery: ".concat(e_1));
                         return [3 /*break*/, 4];
-                    case 4: return [3 /*break*/, 8];
+                    case 4: return [3 /*break*/, 10];
                     case 5:
-                        _a.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, window.applicationManager.connectToRIC(RaftConnectionMethod.WEB_BLE, uuid)];
+                        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*/, 8];
-                    case 7:
+                        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*/, 8];
-                    case 8: return [2 /*return*/];
+                        return [3 /*break*/, 9];
+                    case 9:
+                        secondaryModalState.closeModal();
+                        _a.label = 10;
+                    case 10: return [2 /*return*/];
                 }
             });
         });
@@ -182,7 +192,7 @@ var ApplicationManager = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, modalState.setModal(createElement(DisconnectConfirmationModal, { connectedRaft: window.applicationManager.connectedRafts[raft.id] }), "Are you sure you want to disconnect from your ".concat(raft.getFriendlyName(), "?"))];
+                        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) {
@@ -213,7 +223,7 @@ var ApplicationManager = /** @class */ (function () {
             var selectResults, raftId, raftType, raft;
             return __generator(this, function (_c) {
                 switch (_c.label) {
-                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_SELECT, { discoveredRIC: ricToConnectTo, method: method })];
+                    case 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];
@@ -253,13 +263,13 @@ var ApplicationManager = /** @class */ (function () {
             });
         });
     };
-    ApplicationManager.prototype.connectToRIC = function (method, uuid) {
+    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, uuid)];
+                    case 0: return [4 /*yield*/, RAFT.connect(method, uuids)];
                     case 1:
                         wasConnectedObj = _c.sent();
                         if (!wasConnectedObj.success) return [3 /*break*/, 3];
@@ -331,7 +341,7 @@ var ApplicationManager = /** @class */ (function () {
      * Start looking for rics to connect to
      * This is used from the Phone App only
      */
-    ApplicationManager.prototype.startDiscovery = function (ricSelectedCb) {
+    ApplicationManager.prototype.startDiscovery = function (ricSelectedCb, uuids) {
         return __awaiter(this, void 0, void 0, function () {
             var foundRICs, wasDiscoveryStarted;
             return __generator(this, function (_a) {
@@ -340,33 +350,52 @@ var ApplicationManager = /** @class */ (function () {
                         this.ricSelectedCb = ricSelectedCb;
                         foundRICs = [];
                         raftFoundSubscriptionHelper().subscribe(function (_a) {
-                            var discoveredRIC = _a.discoveredRIC;
+                            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 === discoveredRIC._id; });
+                            var foundRICIdx = foundRICs.findIndex(function (ric_) { return ric_._id === discoveredDevice._id; });
                             if (foundRICIdx !== -1) {
-                                foundRICs[foundRICIdx] = discoveredRIC;
+                                foundRICs[foundRICIdx] = discoveredDevice;
                             }
                             else {
-                                foundRICs.push(discoveredRIC);
+                                foundRICs.push(discoveredDevice);
                             }
                             // foundRICs.sort((a, b) => b._rssi - a._rssi);
                             modalState.setModal(createElement(VerificationModalPhoneApp, { foundRICs: foundRICs }), "Looking for RAFT");
                         });
-                        return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_START_DISCOVERY)];
+                        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();
-                        if (!wasDiscoveryStarted) {
-                            return [2 /*return*/, raftFoundSubscriptionHelper().unsubscribe()];
-                        }
                         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
      */
@@ -479,6 +508,13 @@ var ApplicationManager = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 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 */

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

@@ -1,7 +1,8 @@
 import RAFT from "../RAFT";
 import RICInterface from "../RAFTInterface";
 import { RaftTypeE } from "../../../types/raft";
-import { CogStateInfo, RICLedLcdColours } from "@robotical/roboticaljs";
+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";
@@ -9,7 +10,7 @@ export declare class Cog extends RAFT implements RICInterface {
     id: string;
     type: RaftTypeE;
     _ledLcdColours: RICLedLcdColours;
-    raftStateInfo: CogStateInfo | null;
+    raftStateInfo: SimplifiedCogStateInfo | null;
     publishedDataAnalyser: PublishedDataAnalyser;
     constructor(id: string);
     get ledLcdColours(): RICLedLcdColours;
@@ -17,6 +18,10 @@ export declare class Cog extends RAFT implements RICInterface {
     * 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
      */

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

@@ -51,9 +51,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import RAFT from "../RAFT";
 import { RaftTypeE } from "../../../types/raft";
-import { deviceAttrGetLatestFormatted, RaftConnEvent, RaftPublishEvent } from "@robotical/raftjs";
+import { RaftConnEvent, RaftPublishEvent } from "@robotical/raftjs";
 import { RaftInfoEvents } from "../../../types/events/raft-info";
-import PublishedDataAnalyser from "./PublishedDataAnalyser";
+import PublishedDataAnalyser, { setButtonThresholdsUtil } from "./PublishedDataAnalyser";
 var Cog = /** @class */ (function (_super) {
     __extends(Cog, _super);
     function Cog(id) {
@@ -87,25 +87,36 @@ var Cog = /** @class */ (function (_super) {
         var possibleValues = [126, 127];
         return possibleValues[Math.floor(Math.random() * possibleValues.length)];
     };
+    /**
+     * Helper function to calculate battery strength based on voltage
+     */
+    Cog.prototype.calculateBatteryStrength = function (voltage) {
+        if (voltage >= 2.7) {
+            return 100;
+        }
+        else if (voltage >= 2.3) {
+            return ((voltage - 2.3) / 0.4) * 80 + 20;
+        }
+        else if (voltage >= 2.0) {
+            return ((voltage - 2.0) / 0.3) * 20;
+        }
+        else {
+            return 0;
+        }
+    };
     /**
      * Gets the battery strength of the RAFT
      */
     Cog.prototype.getBatteryStrength = function () {
-        var _a, _b, _c, _d;
         /* check if usb is connected */
-        var usbAttr = (_b = (_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.deviceManager.getDeviceState('RoboCogPowerV1_00')) === null || _b === void 0 ? void 0 : _b.deviceAttributes['USB'];
-        if (!usbAttr)
+        if (!this.raftStateInfo)
             return 0.1;
-        var usb = deviceAttrGetLatestFormatted(usbAttr);
-        if (usb === 'yes')
+        if (this.raftStateInfo.power.usb === 'yes')
             return 0; // 0 indicates USB is connected
         /* if usb is not connected, check battery voltage */
-        var battVAttr = (_d = (_c = this.raftStateInfo) === null || _c === void 0 ? void 0 : _c.deviceManager.getDeviceState('RoboCogPowerV1_00')) === null || _d === void 0 ? void 0 : _d.deviceAttributes['battV'];
-        if (!battVAttr)
-            return 0.1;
-        var battV = deviceAttrGetLatestFormatted(battVAttr);
+        var battV = this.raftStateInfo.power.battV;
         if (!isNaN(+battV)) {
-            return Math.round(+battV * 100);
+            return Math.round(this.calculateBatteryStrength(+battV));
         }
         return 0;
     };
@@ -135,6 +146,10 @@ var Cog = /** @class */ (function (_super) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (eventEnum) {
+                    case RaftConnEvent.CONN_VERIFIED_CORRECT:
+                        // set up cog thresholds 
+                        setButtonThresholdsUtil(this);
+                        break;
                     case RaftConnEvent.CONN_DISCONNECTED:
                         // this.publishedDataAnalyser.unsubscribeFromPublishedData();
                         break;

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

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import { CogStateInfo } from "@robotical/roboticaljs";
 import RAFT from "../RAFT";
-import PublishedDataGetter from "./PublishedDataGetter";
 import EventEmitter from "events";
+import Cog from "./Cog";
+import { SimplifiedCogStateInfo } from "@robotical/roboticaljs/dist/SystemTypeCog/CogTypes";
 interface CogState {
     tilt: "none" | "forward" | "backward" | "left" | "right";
     movementType: "none" | "shake" | "move";
@@ -15,6 +15,12 @@ declare class PublishedDataAnalyser extends EventEmitter {
     private cog;
     cogState: CogState;
     private pubSub;
+    rotationDetection: RotationDetection;
+    shakeDetector: ShakeDetector;
+    buttonClickDetection: ButtonClickDetection;
+    tiltDetection: TiltDetection;
+    objectSenseDetection: ObjectSenseDetection;
+    lightSenseDetection: LightSenseDetection;
     eventsMap: {
         tilt: {
             [key in CogState["tilt"]]: string;
@@ -36,11 +42,10 @@ declare class PublishedDataAnalyser extends EventEmitter {
         };
     };
     TiltDetection: typeof TiltDetection;
-    PublishedDataGetter: typeof PublishedDataGetter;
     constructor(cog: RAFT);
     subscribeToPublishedData(): void;
     unsubscribeFromPublishedData(): void;
-    analyse(data: CogStateInfo): void;
+    analyse(data: SimplifiedCogStateInfo): void;
     setTilt(tilt: CogState["tilt"]): void;
     setMovementType(movementType: CogState["movementType"]): void;
     setRotation(rotation: CogState["rotation"]): void;
@@ -57,4 +62,59 @@ declare class TiltDetection {
     };
     detectTilt(ax: number, ay: number, az: number, isMoving: boolean | undefined, analyser: PublishedDataAnalyser, cogVersion: string): void;
 }
+declare class RotationDetection {
+    private dataBuffer;
+    private bufferSize;
+    private DELAY_FOR_ROTATION;
+    private ROTATION_THRESHOLD;
+    private rotationDetected;
+    private lastRotationDetectionTime;
+    private rotationTimer;
+    constructor();
+    addToBuffer(data: number): void;
+    detectRotation(gz: number, isMoving: boolean | undefined, analyser: PublishedDataAnalyser): void;
+    calculateMetric(): number;
+}
+declare class ShakeDetector {
+    private thresholdAccelerationMove;
+    private thresholdAcceleration;
+    private thresholdShakeNumber;
+    private interval;
+    private maxShakeDuration;
+    private coolOffPeriod;
+    private lastTime;
+    private lastTimeShakeDetected;
+    private sensorBundles;
+    private gravityVector;
+    private lastVector;
+    private shakeInProgress;
+    private moveInProgress;
+    constructor();
+    detectShake(xAcc: number, yAcc: number, zAcc: number, timestamp: number, analyser: PublishedDataAnalyser): boolean;
+    performCheck(analyser: PublishedDataAnalyser): void;
+    updateAxis(index: number, acceleration: number, matrix: number[][], adjustment?: number): void;
+}
+export declare class ButtonClickDetection {
+    clickThreshold: number;
+    releaseThreshold: number;
+    lastTime: number;
+    buttonClicked: boolean;
+    constructor();
+    detectButtonClick(buttonValue: number, analyser: PublishedDataAnalyser, cogVersion: string): void;
+}
+declare class ObjectSenseDetection {
+    private objectSensed0Threshold;
+    private objectSensed1Threshold;
+    private objectSensed2Threshold;
+    constructor();
+    detectObjectSense(objectSenseValue: number[], analyser: PublishedDataAnalyser): void;
+}
+declare class LightSenseDetection {
+    private lowLightThreshold;
+    private midLightThreshold;
+    private highLightThreshold;
+    constructor();
+    detectLightSense(lightSenseValue: number, analyser: PublishedDataAnalyser): void;
+}
+export declare const setButtonThresholdsUtil: (connectedCog: Cog) => Promise<void>;
 export default PublishedDataAnalyser;