@robotical/webapp-types 1.0.7 → 1.0.9

package/dist-types/src/analytics/AnalyticsManager.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AnalyticsManager
+ *
+ * This class is responsible for managing the analytics services for the testing phase.
+ * Analytics gathered:
+ * - Connections
+ * - Disconnections
+ * - Visited pages
+ * - emoji feedback
+ * - text feedback
+ *
+ * Each of them will be stored as an event. They will stored in the order they were received so we can track the user's journey.
+ * There will be a timestamp for each event.
+ *
+ * We store client's id in a cookie so we can track the user's journey.
+ */
+type EventType = "connection" | "disconnection" | "page" | "emojifeedback" | "textfeedback" | "connection_issue" | "connection_issue_resolved";
+export declare class AnalyticsManager {
+    private static instance;
+    private clientId;
+    private eventsStorer;
+    private constructor();
+    static getInstance(): AnalyticsManager;
+    private getClientId;
+    private generateClientId;
+    logEvent(eventType: EventType, data: any): void;
+}
+export {};

package/dist-types/src/analytics/AnalyticsManager.js

@@ -0,0 +1,171 @@
+/**
+ * AnalyticsManager
+ *
+ * This class is responsible for managing the analytics services for the testing phase.
+ * Analytics gathered:
+ * - Connections
+ * - Disconnections
+ * - Visited pages
+ * - emoji feedback
+ * - text feedback
+ *
+ * Each of them will be stored as an event. They will stored in the order they were received so we can track the user's journey.
+ * There will be a timestamp for each event.
+ *
+ * We store client's id in a cookie so we can track the user's journey.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+var AnalyticsManager = /** @class */ (function () {
+    function AnalyticsManager() {
+        this.clientId = this.getClientId();
+        this.eventsStorer = new EventsStorer(this.clientId);
+    }
+    AnalyticsManager.getInstance = function () {
+        if (!AnalyticsManager.instance) {
+            AnalyticsManager.instance = new AnalyticsManager();
+        }
+        return AnalyticsManager.instance;
+    };
+    AnalyticsManager.prototype.getClientId = function () {
+        var clientId = localStorage.getItem('@robotical/webapp/analytics/clientId');
+        if (!clientId) {
+            clientId = this.generateClientId();
+            localStorage.setItem('@robotical/webapp/analytics/clientId', clientId);
+        }
+        return clientId;
+    };
+    AnalyticsManager.prototype.generateClientId = function () {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    };
+    AnalyticsManager.prototype.logEvent = function (eventType, data) {
+        var event = new AnalyticsEvent(eventType, data);
+        this.eventsStorer.addEvent(event);
+    };
+    return AnalyticsManager;
+}());
+export { AnalyticsManager };
+var AnalyticsEvent = /** @class */ (function () {
+    function AnalyticsEvent(type, data) {
+        this.type = type;
+        this.data = data;
+        this.isProcessed = false;
+        this.timestamp = new Date().toString();
+        this.urlSafeTimestamp = new Date().toISOString().replaceAll("T", "_").replaceAll(":", "-").replaceAll("/", "-").replaceAll(".", "_");
+    }
+    AnalyticsEvent.prototype.process = function () {
+        this.isProcessed = true;
+    };
+    return AnalyticsEvent;
+}());
+var EventsStorer = /** @class */ (function () {
+    function EventsStorer(clientId) {
+        this.clientId = clientId;
+        this.events = [];
+        this.processing = false;
+    }
+    EventsStorer.prototype.addEvent = function (event) {
+        this.events.push(event);
+        this._processEvents();
+    };
+    EventsStorer.prototype._processEvents = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, event_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.processing)
+                            return [2 /*return*/];
+                        this.processing = true;
+                        _i = 0, _a = this.events;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        event_1 = _a[_i];
+                        if (!!event_1.isProcessed) return [3 /*break*/, 3];
+                        this._processEvent(event_1);
+                        return [4 /*yield*/, this._delay(1000)];
+                    case 2:
+                        _b.sent(); // 1 second debounce time
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        this.processing = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EventsStorer.prototype._delay = function (ms) {
+        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+    };
+    EventsStorer.prototype._processEvent = function (event) {
+        event.process();
+        var data = __assign(__assign(__assign({}, event), event.data), { data: undefined, isProcessed: undefined, urlSafeTimestamp: undefined });
+        var path = "".concat(this.clientId, "/").concat(event.urlSafeTimestamp, "-").concat(event.type);
+        FirebaseInteractor.put(path, data);
+    };
+    return EventsStorer;
+}());
+var FirebaseInteractor = /** @class */ (function () {
+    function FirebaseInteractor() {
+    }
+    FirebaseInteractor.put = function (path, data) {
+        fetch("".concat(this.db_href, "/").concat(path, ".json"), {
+            method: 'PUT',
+            body: JSON.stringify(data),
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    };
+    FirebaseInteractor.db_href = "https://app-v2-analytics-default-rtdb.firebaseio.com";
+    return FirebaseInteractor;
+}());

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

@@ -6,9 +6,10 @@ import Cog from "../RAFTs/Cog/Cog";
 import { FOUND_RAFT_ON_DISCOVERY_RESPONSE } from "../../types/phone-app-communicator";
 import { RaftObserver } from "../RAFTs/RaftObserver";
 import { RaftInfoEvents } from "../../types/events/raft-info";
-import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robdobsn/raftjs";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robotical/raftjs";
 import { ConnectedRaftItem } from "../../store/SelectedRaftContext";
 import Toaster from "../../utils/Toaster";
+import { AnalyticsManager } from "../../analytics/AnalyticsManager";
 export default class ApplicationManager {
     private _observers;
     static wrapperAppCommunicator: WebAppCommunicator;
@@ -16,8 +17,13 @@ export default class ApplicationManager {
         [key: string]: RAFT;
     };
     connectedRaftsContext: ConnectedRaftItem[];
+    returnToMainApp: () => void;
+    private _router;
+    setRouter(router: any): void;
+    navigateTo(path: string): void;
     ricSelectedCb: ((raft: RAFT) => void) | null;
     toaster: typeof Toaster;
+    analyticsManager: AnalyticsManager;
     showBackHomeButton: () => void;
     hideBackHomeButton: () => void;
     connectedRaftContextMethods: {
@@ -55,7 +61,7 @@ export default class ApplicationManager {
      * Removes raft after a certain time
      * Removes from the rics list after x seconds so that we can still get the last event
      */
-    _removeRIC(raftId: string, timeout: number): void;
+    _removeRaft(raftId: string, timeout: number): void;
     /**
      * Start looking for rics to connect to
      * This is used from the Phone App only

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

@@ -45,11 +45,12 @@ 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 "@robdobsn/raftjs";
+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";
 var SHOW_LOGS = true;
 var TAG = "ApplicationManager";
 var ApplicationManager = /** @class */ (function () {
@@ -59,10 +60,11 @@ var ApplicationManager = /** @class */ (function () {
         // Connected RICs
         this.connectedRafts = {};
         this.connectedRaftsContext = [];
+        this.returnToMainApp = function () { };
         // Callback to call when a RAFT is selected (Phone App only)
         // We need that to make sure the connection button gets the selected RAFT once the user selects one
         this.ricSelectedCb = null;
-        // // RICNotificationsManager
+        // RICNotificationsManager
         // private _ricNotificationsManager: RICNotificationsManager = new RICNotificationsManager(
         //     this
         // );
@@ -75,6 +77,8 @@ var ApplicationManager = /** @class */ (function () {
         // public sessionDbs = new SessionsDBManager();
         // toaster
         this.toaster = Toaster;
+        // Analytics Manager
+        this.analyticsManager = AnalyticsManager.getInstance();
         this.showBackHomeButton = function () { };
         this.hideBackHomeButton = function () { };
         // connected raft context methods
@@ -85,10 +89,21 @@ var ApplicationManager = /** @class */ (function () {
         };
         this.isPhoneApp = isPhoneApp;
         // super();
-        // AnalyticsManager.appStartSession();
+        // DatabaseManager.appStartSession();
         this.connectGenericMarty = this.connectGenericMarty.bind(this);
         this.connectGenericCog = this.connectGenericCog.bind(this);
     }
+    ApplicationManager.prototype.setRouter = function (router) {
+        this._router = router;
+    };
+    ApplicationManager.prototype.navigateTo = function (path) {
+        if (this._router) {
+            this._router.navigate(path);
+        }
+        else {
+            Logger.error(SHOW_LOGS, TAG, "Router is not set");
+        }
+    };
     ApplicationManager.prototype.createNewCog = function (id) {
         return new Cog(id);
     };
@@ -126,7 +141,7 @@ var ApplicationManager = /** @class */ (function () {
                     case 1:
                         _a.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, window.applicationManager.startDiscovery(function (newRaft) {
-                                _this.connectedRaftContextMethods.addConnectedRaft({ id: newRaft.id, name: newRaft.getFriendlyName() || "", isSelected: true });
+                                _this.connectedRaftContextMethods.addConnectedRaft({ id: newRaft.id, type: newRaft.type, name: newRaft.getFriendlyName() || "", isSelected: true });
                                 afterRaftConnectedCb(newRaft);
                             })];
                     case 2:
@@ -143,7 +158,7 @@ var ApplicationManager = /** @class */ (function () {
                     case 6:
                         newRaft = _a.sent();
                         if (newRaft) {
-                            this.connectedRaftContextMethods.addConnectedRaft({ id: newRaft.id, name: newRaft.getFriendlyName() || "", isSelected: true });
+                            this.connectedRaftContextMethods.addConnectedRaft({ id: newRaft.id, type: newRaft.type, name: newRaft.getFriendlyName() || "", isSelected: true });
                             afterRaftConnectedCb(newRaft);
                         }
                         return [3 /*break*/, 8];
@@ -292,7 +307,7 @@ var ApplicationManager = /** @class */ (function () {
                         return [4 /*yield*/, raft.disconnect()];
                     case 1:
                         _a.sent();
-                        this._removeRIC(raftId, 11000);
+                        this._removeRaft(raftId, 3000);
                         return [2 /*return*/];
                 }
             });
@@ -302,7 +317,7 @@ var ApplicationManager = /** @class */ (function () {
      * Removes raft after a certain time
      * Removes from the rics list after x seconds so that we can still get the last event
      */
-    ApplicationManager.prototype._removeRIC = function (raftId, timeout) {
+    ApplicationManager.prototype._removeRaft = function (raftId, timeout) {
         var _this = this;
         var ricRemovalTimeout = setTimeout(function () {
             delete _this.connectedRafts[raftId];
@@ -360,7 +375,7 @@ var ApplicationManager = /** @class */ (function () {
                     case 0: return [4 /*yield*/, ((_a = this.connectedRafts[raftId]) === null || _a === void 0 ? void 0 : _a.stopVerifyingRaft(isCorrectRIC))];
                     case 1:
                         _b.sent();
-                        this._removeRIC(raftId, 11000);
+                        this._removeRaft(raftId, 3000);
                         return [2 /*return*/];
                 }
             });

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

@@ -2,7 +2,7 @@ import RAFT from "../RAFT";
 import RICInterface from "../RAFTInterface";
 import { RaftTypeE } from "../../../types/raft";
 import { CogStateInfo, RICLedLcdColours } from "@robotical/roboticaljs";
-import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
 import { RaftInfoEvents } from "../../../types/events/raft-info";
 import PublishedDataAnalyser from "./PublishedDataAnalyser";
 export declare class Cog extends RAFT implements RICInterface {

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

@@ -51,7 +51,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import RAFT from "../RAFT";
 import { RaftTypeE } from "../../../types/raft";
-import { deviceAttrGetLatestFormatted, RaftConnEvent, RaftPublishEvent } from "@robdobsn/raftjs";
+import { deviceAttrGetLatestFormatted, RaftConnEvent, RaftPublishEvent } from "@robotical/raftjs";
 import { RaftInfoEvents } from "../../../types/events/raft-info";
 import PublishedDataAnalyser from "./PublishedDataAnalyser";
 var Cog = /** @class */ (function (_super) {

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

@@ -1,32 +1,52 @@
+/// <reference types="node" />
 import { CogStateInfo } from "@robotical/roboticaljs";
 import RAFT from "../RAFT";
 import PublishedDataGetter from "./PublishedDataGetter";
+import EventEmitter from "events";
 interface CogState {
-    tilt: boolean | "forward" | "backward" | "left" | "right";
-    movementType: boolean | "shake" | "move";
-    rotation: boolean | "clockwise" | "counter-clockwise";
-    buttonClick: boolean;
-    objectSense: boolean | "left" | "right";
-    lightSense: boolean | "left" | "right";
-    irMessage: boolean | "left" | "right";
+    tilt: "none" | "forward" | "backward" | "left" | "right";
+    movementType: "none" | "shake" | "move";
+    rotation: "none" | "clockwise" | "counterClockwise";
+    buttonClick: "none" | "click" | "release";
+    objectSense: "none" | "left" | "right";
+    lightSense: "none" | "high" | "mid" | "low";
 }
-declare class PublishedDataAnalyser {
+declare class PublishedDataAnalyser extends EventEmitter {
     private cog;
     cogState: CogState;
     private pubSub;
+    eventsMap: {
+        tilt: {
+            [key in CogState["tilt"]]: string;
+        };
+        movementType: {
+            [key in CogState["movementType"]]: string;
+        };
+        rotation: {
+            [key in CogState["rotation"]]: string;
+        };
+        buttonClick: {
+            [key in CogState["buttonClick"]]: string;
+        };
+        objectSense: {
+            [key in CogState["objectSense"]]: string;
+        };
+        lightSense: {
+            [key in CogState["lightSense"]]: string;
+        };
+    };
     TiltDetection: typeof TiltDetection;
     PublishedDataGetter: typeof PublishedDataGetter;
     constructor(cog: RAFT);
     subscribeToPublishedData(): void;
     unsubscribeFromPublishedData(): void;
     analyse(data: CogStateInfo): void;
-    detectMovement(ax: number, ay: number, az: number): boolean;
-    detectTilt(ax: number, ay: number, az: number, isMoving: boolean): void;
-    detectRotation(gz: number, isMoving: boolean): void;
-    detectButtonClick(buttonLightValue: number): void;
-    detectObjectSense(leftIRValue: number, rightIRValue: number): void;
-    detectLightSense(ambientLightValue: number): void;
-    detectIRMessage(data: CogStateInfo): void;
+    setTilt(tilt: CogState["tilt"]): void;
+    setMovementType(movementType: CogState["movementType"]): void;
+    setRotation(rotation: CogState["rotation"]): void;
+    setButtonClick(buttonClick: CogState["buttonClick"]): void;
+    setObjectSense(objectSense: CogState["objectSense"]): void;
+    setLightSense(lightSense: CogState["lightSense"]): void;
 }
 declare class TiltDetection {
     distance(a: number, b: number): number;
@@ -35,6 +55,6 @@ declare class TiltDetection {
         y: number;
         z: number;
     };
-    detectTilt(ax: number, ay: number, az: number, isMoving: boolean | undefined, cogState: CogState, cogVersion: string): void;
+    detectTilt(ax: number, ay: number, az: number, isMoving: boolean | undefined, analyser: PublishedDataAnalyser, cogVersion: string): void;
 }
 export default PublishedDataAnalyser;