@robotical/webapp-types 1.1.0 → 1.1.1

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,7 +130,7 @@ 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;
@@ -143,7 +144,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 +152,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 +189,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 +220,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 +260,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 +338,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 +347,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 +505,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;
@@ -193,7 +208,7 @@ var Cog = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (eventEnum) {
                     case RaftInfoEvents.STATE_INFO:
-                        this.raftStateInfo = data.stateInfo;
+                        this.raftStateInfo = data;
                         break;
                     default:
                         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;

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

@@ -13,15 +13,59 @@ var __extends = (this && this.__extends) || (function () {
         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 { raftPubSubscriptionHelper } from "../raft-subscription-helpers";
 import { isVersionGreater_errorCatching } from "../../../utils/helpers/compare-version";
-import PublishedDataGetter from "./PublishedDataGetter";
 import EventEmitter from "events";
+import Logger from "../../../services/logger/Logger";
+var SHOW_LOGS = true;
+var TAG = "PublishedDataAnalyser";
 var PublishedDataAnalyser = /** @class */ (function (_super) {
     __extends(PublishedDataAnalyser, _super);
     function PublishedDataAnalyser(cog) {
         var _this = _super.call(this) || this;
         _this.cog = cog;
+        _this.rotationDetection = new RotationDetection();
+        _this.shakeDetector = new ShakeDetector();
+        _this.buttonClickDetection = new ButtonClickDetection();
+        _this.tiltDetection = new TiltDetection();
+        _this.objectSenseDetection = new ObjectSenseDetection();
+        _this.lightSenseDetection = new LightSenseDetection();
         _this.eventsMap = {
             tilt: {
                 forward: "tiltForward",
@@ -58,7 +102,6 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
             },
         };
         _this.TiltDetection = TiltDetection;
-        _this.PublishedDataGetter = PublishedDataGetter;
         _this.cog = cog;
         _this.cogState = {
             tilt: "none",
@@ -76,7 +119,7 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         var _this = this;
         this.pubSub = raftPubSubscriptionHelper(this.cog);
         this.pubSub.subscribe(function (data) {
-            _this.analyse(data.stateInfo);
+            _this.analyse(data);
         });
     };
     PublishedDataAnalyser.prototype.unsubscribeFromPublishedData = function () {
@@ -84,20 +127,19 @@ var PublishedDataAnalyser = /** @class */ (function (_super) {
         (_a = this.pubSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
     };
     PublishedDataAnalyser.prototype.analyse = function (data) {
-        //@ts-ignore
-        var accelData = PublishedDataGetter.getAccelerometerData(data.deviceManager);
-        //@ts-ignore
-        var gyroData = PublishedDataGetter.getGyroscopeData(data.deviceManager);
-        //@ts-ignore
-        var lightData = PublishedDataGetter.getLightData(data.deviceManager);
+        if (!data)
+            return;
+        var accelData = data.accelerometer;
+        var gyroData = data.gyroscope;
+        var lightData = data.light;
         var isMoving;
         if (accelData)
-            isMoving = shakeDetector.detectShake(accelData.ax, accelData.ay, accelData.az, Date.now(), this);
-        accelData && tiltDetection.detectTilt(accelData.ax, accelData.ay, accelData.az, isMoving, this, this.cog.getRaftVersion());
-        gyroData && rotationDetection.detectRotation(gyroData.gz, isMoving, this);
-        lightData && buttonClickDetection.detectButtonClick(lightData.ir2, this, this.cog.getRaftVersion());
-        lightData && objectSenseDetection.detectObjectSense([lightData.ir0, lightData.ir1], this);
-        lightData && lightSenseDetection.detectLightSense(lightData.amb0, this);
+            isMoving = this.shakeDetector.detectShake(accelData.ax, accelData.ay, accelData.az, Date.now(), this);
+        accelData && this.tiltDetection.detectTilt(accelData.ax, accelData.ay, accelData.az, isMoving, this, this.cog.getRaftVersion());
+        gyroData && this.rotationDetection.detectRotation(gyroData.gz, isMoving, this);
+        lightData && this.buttonClickDetection.detectButtonClick(lightData.ir2, this, this.cog.getRaftVersion());
+        lightData && this.objectSenseDetection.detectObjectSense([lightData.ir0, lightData.ir1], this);
+        lightData && this.lightSenseDetection.detectLightSense(lightData.amb0, this);
     };
     PublishedDataAnalyser.prototype.setTilt = function (tilt) {
         this.cogState.tilt = tilt;
@@ -157,7 +199,7 @@ var TiltDetection = /** @class */ (function () {
         if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
             tiltCorrection = tiltCorrectionForNewerCog;
         }
-        var _a = TiltDetection.rotateAccelData(ax, ay, az, tiltCorrection), x = _a.x, y = _a.y, z = _a.z;
+        var _a = TiltDetection.rotateAccelData(ax, ay, az * -1, tiltCorrection), x = _a.x, y = _a.y, z = _a.z;
         var pitch = Math.atan2(x, this.distance(y, z));
         var roll = Math.atan2(y, this.distance(x, z));
         var yaw = Math.atan2(z, this.distance(x, y));
@@ -392,27 +434,18 @@ var ButtonClickDetection = /** @class */ (function () {
         this.buttonClicked = false;
     }
     ButtonClickDetection.prototype.detectButtonClick = function (buttonValue, analyser, cogVersion) {
-        var correctionCutOffVersion = "1.2.0";
-        var clickThreshold = 1600;
-        if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
-            clickThreshold = 1500;
-        }
-        var releaseThreshold = 1590;
-        if (isVersionGreater_errorCatching(cogVersion, correctionCutOffVersion)) {
-            releaseThreshold = 1490;
-        }
-        this.clickThreshold = clickThreshold;
-        this.releaseThreshold = releaseThreshold;
         var currentTime = Date.now();
         if (buttonValue > this.clickThreshold && !this.buttonClicked) {
             // console.log("Button clicked", buttonValue);
             this.buttonClicked = true;
             this.lastTime = currentTime;
+            Logger.info(SHOW_LOGS, TAG, "Button clicked");
             analyser.setButtonClick("click");
         }
         else if (buttonValue < this.releaseThreshold && this.buttonClicked) {
             // console.log("Button released", buttonValue);
             this.buttonClicked = false;
+            Logger.info(SHOW_LOGS, TAG, "Button released");
             analyser.setButtonClick("release");
         }
         // } else {
@@ -422,6 +455,7 @@ var ButtonClickDetection = /** @class */ (function () {
     };
     return ButtonClickDetection;
 }());
+export { ButtonClickDetection };
 var ObjectSenseDetection = /** @class */ (function () {
     function ObjectSenseDetection() {
         this.objectSensed0Threshold = 2500; // left of the arrow
@@ -463,10 +497,37 @@ var LightSenseDetection = /** @class */ (function () {
     };
     return LightSenseDetection;
 }());
-var rotationDetection = new RotationDetection();
-var shakeDetector = new ShakeDetector();
-var buttonClickDetection = new ButtonClickDetection();
-var tiltDetection = new TiltDetection();
-var objectSenseDetection = new ObjectSenseDetection();
-var lightSenseDetection = new LightSenseDetection();
+export var setButtonThresholdsUtil = function (connectedCog) { return __awaiter(void 0, void 0, void 0, function () {
+    var lightResponse, irMin, irMax, buttonClickDetection, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                Logger.info(SHOW_LOGS, TAG, "Setting button thresholds");
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, connectedCog.sendRestMessage('light')];
+            case 2:
+                lightResponse = _a.sent();
+                if (lightResponse && lightResponse.rslt === "ok" && lightResponse.light.irMax4) {
+                    irMin = lightResponse.light.irMin4;
+                    irMax = lightResponse.light.irMax4;
+                    Logger.info(SHOW_LOGS, TAG, "Got button thresholds: irMin: ".concat(irMin, ", irMax: ").concat(irMax));
+                    buttonClickDetection = connectedCog.publishedDataAnalyser.buttonClickDetection;
+                    buttonClickDetection.clickThreshold = irMin + (irMax - irMin) / 2;
+                    buttonClickDetection.releaseThreshold = buttonClickDetection.clickThreshold - 10;
+                    Logger.info(SHOW_LOGS, TAG, "Set button thresholds: clickThreshold: ".concat(buttonClickDetection.clickThreshold, ", releaseThreshold: ").concat(buttonClickDetection.releaseThreshold));
+                }
+                else {
+                    Logger.warn(SHOW_LOGS, TAG, "Couldn't get button thresholds, probably older fw version");
+                }
+                return [3 /*break*/, 4];
+            case 3:
+                error_1 = _a.sent();
+                Logger.warn(SHOW_LOGS, TAG, "Couldn't get button thresholds, probably older fw version");
+                return [3 /*break*/, 4];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
 export default PublishedDataAnalyser;