feat: Add Be and tbd skill, also added Roadmap file

Skills/@be/be/node_modules/jibo-service-clients/lib/dts/index.d.ts

@@ -0,0 +1,29 @@
+import { ServiceContainer } from './utils/ServiceOwner';
+import { ServiceRecord, InitCallback } from './utils/Types';
+import * as errors from './services/ErrorService';
+export { errors };
+import * as ics from './services/IdentityCreationService';
+export { ics };
+import { lps } from './services/LPSService';
+export { lps };
+import { media } from './services/MediaService';
+export { media };
+import { mediaManager } from './services/MediaManagerService';
+export { mediaManager };
+import * as performance from './services/PerformanceService';
+export { performance };
+import * as scheduler from './services/SchedulerService';
+export { scheduler };
+import * as secureTransferService from './services/SecureTransferService';
+export { secureTransferService };
+import * as systemManager from './services/SystemManager';
+export { systemManager };
+import { system } from './services/SystemService';
+export { system };
+import * as tts from './services/TTSService';
+export { tts };
+import * as wifi from './services/WifiService';
+export { wifi };
+export { WebCommunication as web } from './utils/WebCommunication';
+export declare type AsyncMethod = (callback: Function) => void;
+export declare function init(owner: ServiceContainer, records: ServiceRecord[], callback: InitCallback, initWrapper?: (initFunction: AsyncMethod, service: string) => AsyncMethod): void;

Skills/@be/be/node_modules/jibo-service-clients/lib/expression-service-clients/index.d.ts

@@ -0,0 +1,6 @@
+import { ServiceContainer } from './utils/ServiceOwner';
+import { ServiceRecord, InitCallback } from './utils/Types';
+import { lps } from './services/LPSService';
+export { lps };
+export declare type AsyncMethod = (callback: Function) => void;
+export declare function init(owner: ServiceContainer, records: ServiceRecord[], callback: InitCallback, initWrapper?: (initFunction: AsyncMethod, service: string) => AsyncMethod): void;

Skills/@be/be/node_modules/jibo-service-clients/lib/expression-service-clients/index.js

@@ -0,0 +1,388 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.index = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+if (!global.XMLHttpRequest) {
+    global.XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest;
+    Object.defineProperty(global.XMLHttpRequest.prototype, 'response', {
+        get: function () {
+            if (this.responseType === 'json') {
+                try {
+                    this.__response = JSON.parse(this.responseText);
+                }
+                catch (e) {
+                    this.responseType = null;
+                }
+            }
+            if (this.__response) {
+                return this.__response;
+            }
+            return this.responseXML || this.responseText;
+        }
+    });
+}
+const jibo_log_1 = require("jibo-log");
+const async = require("async");
+const ServiceOwner_1 = require("./utils/ServiceOwner");
+const log = new jibo_log_1.Log('SF.ServiceClients');
+const services = {};
+const LPSService_1 = require("./services/LPSService");
+exports.lps = LPSService_1.lps;
+services.lps = LPSService_1.lps.init;
+function init(owner, records, callback, initWrapper) {
+    ServiceOwner_1.ServiceOwner.init(owner);
+    const tasks = [];
+    records.forEach((service) => {
+        const initFunction = services[service.name];
+        if (initFunction) {
+            let actualInit = (callback) => {
+                initFunction(service, log, callback);
+            };
+            if (initWrapper) {
+                actualInit = initWrapper(actualInit, service.name);
+            }
+            tasks.push(actualInit);
+        }
+    });
+    async.parallel(tasks, callback);
+}
+exports.init = init;
+
+},{"./services/LPSService":2,"./utils/ServiceOwner":3,"async":undefined,"jibo-log":undefined,"xmlhttprequest":undefined}],2:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async = require("async");
+const jibo_client_framework_1 = require("jibo-client-framework");
+let log;
+let lpsData = {};
+lpsData.motionData = {
+    cameras: [],
+    entities: [],
+    ts: [0, 0]
+};
+lpsData.audioData = {
+    entities: [],
+    ts: [0, 0]
+};
+let httpUrl;
+let lpsServiceUrl;
+let motionSocket;
+let audioSocket;
+let _demandDetectQueue = [];
+let _demandDetectRedetect = false;
+class lps {
+    static get httpUrl() {
+        return httpUrl;
+    }
+    static get motionData() {
+        return lpsData.motionData;
+    }
+    static get audioData() {
+        return lpsData.audioData;
+    }
+}
+exports.lps = lps;
+(function (lps) {
+    function getClosestVisualEntity() {
+        let entity;
+        if (lpsData.motionData !== undefined &&
+            lpsData.motionData.entities !== undefined &&
+            lpsData.motionData.entities.length > 0) {
+            entity = lpsData.motionData.entities[0];
+        }
+        return entity;
+    }
+    lps.getClosestVisualEntity = getClosestVisualEntity;
+    function getVisualEntityById(id) {
+        let entity;
+        for (let i = 0; i < lpsData.motionData.entities.length; i++) {
+            let itr = lpsData.motionData.entities[i];
+            if (itr && (itr.id === id)) {
+                entity = itr;
+                break;
+            }
+        }
+        return entity;
+    }
+    lps.getVisualEntityById = getVisualEntityById;
+    function getClosestAudibleEntity() {
+        let entity;
+        if (lpsData.audioData !== undefined &&
+            lpsData.audioData.entities !== undefined &&
+            lpsData.audioData.entities.length > 0) {
+            entity = lpsData.audioData.entities[0];
+        }
+        return entity;
+    }
+    lps.getClosestAudibleEntity = getClosestAudibleEntity;
+    function getAudibleEntityById(id) {
+        let entity;
+        for (let i = 0; i < lpsData.audioData.entities.length; i++) {
+            let itr = lpsData.audioData.entities[i];
+            if (itr && (itr.id === id)) {
+                entity = itr;
+                break;
+            }
+        }
+        return entity;
+    }
+    lps.getAudibleEntityById = getAudibleEntityById;
+    function getCameraParameters(cameraID, cb) {
+        if (httpUrl === undefined) {
+            cb('Identity service is not initialized', null);
+            return;
+        }
+        let params = {};
+        params.cameraId = cameraID;
+        let request = new XMLHttpRequest();
+        request.open("GET", httpUrl + '/lps/camera/calibration?cameraId=' + cameraID, true);
+        request.onreadystatechange = () => {
+            if (request.readyState === 4) {
+                if (request.status >= 200 && request.status <= 299) {
+                    try {
+                        const data = JSON.parse(request.response);
+                        cb(null, data);
+                    }
+                    catch (e) {
+                        const errorData = 'Response is not JSON.';
+                        cb(errorData, null);
+                    }
+                }
+                else {
+                    let msg = 'LPS service unavailable:';
+                    if (request.statusText !== undefined && request.statusText !== "") {
+                        msg += request.statusText;
+                    }
+                    let errorData = null;
+                    if (request.response) {
+                        try {
+                            errorData = JSON.parse(request.response);
+                        }
+                        catch (e) {
+                            errorData = 'Response is not JSON.';
+                        }
+                    }
+                    cb(msg, errorData);
+                }
+            }
+        };
+        request.send();
+    }
+    lps.getCameraParameters = getCameraParameters;
+    function getFaces(cameraID, cb, kind, initTracks = false) {
+        if (httpUrl === undefined) {
+            cb('Identity service is not initialized', null);
+            return;
+        }
+        let params = {};
+        params.camera_id = cameraID;
+        params.kind = kind;
+        params.init_tracks = initTracks;
+        let request = new XMLHttpRequest();
+        request.open("POST", httpUrl + '/lps/faces', true);
+        request.onreadystatechange = () => {
+            if (request.readyState === 4) {
+                if (request.status >= 200 && request.status <= 299) {
+                    try {
+                        const data = JSON.parse(request.response);
+                        cb(null, data);
+                    }
+                    catch (e) {
+                        const errorData = 'Response is not JSON.';
+                        cb(errorData, null);
+                    }
+                }
+                else {
+                    let msg = 'LPS service unavailable:';
+                    if (request.statusText !== undefined && request.statusText !== "") {
+                        msg += request.statusText;
+                    }
+                    let errorData = null;
+                    if (request.response) {
+                        try {
+                            errorData = JSON.parse(request.response);
+                        }
+                        catch (e) {
+                            errorData = 'Response is not JSON.';
+                        }
+                    }
+                    cb(msg, errorData);
+                }
+            }
+        };
+        request.send(JSON.stringify(params));
+    }
+    lps.getFaces = getFaces;
+    function demandDetect(cameraID, redetect, cb) {
+        log.debug("demandDetect", cameraID, redetect);
+        if (!!_demandDetectQueue.length) {
+            if (_demandDetectRedetect === redetect) {
+                _demandDetectQueue.push(cb);
+                return;
+            }
+            else {
+                cb('Cannot Demand Detect while call with redetect:' + _demandDetectRedetect + ' is in progress', null);
+                return;
+            }
+        }
+        _demandDetectRedetect = redetect;
+        _demandDetectQueue.push(cb);
+        if (httpUrl === undefined) {
+            _clearDemandDetectCallbacks('LPS service is not initialized', null);
+            return;
+        }
+        const data = {
+            'camera_id': cameraID,
+            'roi': {
+                'left': 0,
+                'top': 0,
+                'right': 640,
+                'bottom': 360
+            },
+            'redetect': redetect
+        };
+        const request = new XMLHttpRequest();
+        request.open('POST', httpUrl + '/lps/demand_detect', true);
+        request.onreadystatechange = () => {
+            if (request.readyState === 4) {
+                if (request.status >= 200 && request.status <= 299) {
+                    if (request.response) {
+                        let response = {};
+                        try {
+                            response = JSON.parse(request.response);
+                            _clearDemandDetectCallbacks(null, response.detections);
+                        }
+                        catch (e) {
+                            cb(e, null);
+                        }
+                    }
+                    else {
+                        _clearDemandDetectCallbacks('No data received from LPS demand detection', null);
+                    }
+                }
+                else {
+                    let msg = 'Demand Detect failure:';
+                    if (request.statusText !== undefined && request.statusText !== '') {
+                        msg += request.statusText;
+                    }
+                    _clearDemandDetectCallbacks(msg, null);
+                }
+            }
+        };
+        request.send(JSON.stringify(data));
+    }
+    lps.demandDetect = demandDetect;
+    function _clearDemandDetectCallbacks(err, data) {
+        _demandDetectQueue.forEach((callback) => {
+            callback(err, data);
+        });
+        _demandDetectQueue = [];
+    }
+    lps._clearDemandDetectCallbacks = _clearDemandDetectCallbacks;
+    function readBarcode(cb) {
+        if (httpUrl === undefined) {
+            cb('Barcode service is not initialized', null);
+            return;
+        }
+        let request = new XMLHttpRequest();
+        request.open("GET", httpUrl + '/lps/barcode', true);
+        request.onreadystatechange = () => {
+            if (request.readyState === 4) {
+                if (request.status >= 200 && request.status <= 299) {
+                    if (request.response) {
+                        let response = JSON.parse(request.response);
+                        cb(null, response.barcodes);
+                    }
+                    else {
+                        cb('No data received from barcode service', null);
+                    }
+                }
+                else {
+                    let msg = 'Barcode service unavailable';
+                    if (request.statusText !== undefined && request.statusText !== "") {
+                        msg = request.statusText;
+                    }
+                    cb(msg, null);
+                }
+            }
+        };
+        request.send();
+    }
+    lps.readBarcode = readBarcode;
+    function setPresence(presenceData, cb) {
+        if (httpUrl === undefined) {
+            cb('LPS Service is not initialized', null);
+            return;
+        }
+        let request = new XMLHttpRequest();
+        request.open("POST", httpUrl + '/lps/presence', true);
+        request.onreadystatechange = () => {
+            if (request.readyState === 4) {
+                if (request.status >= 200 && request.status <= 299) {
+                    if (request.response) {
+                        const response = JSON.parse(request.response);
+                        cb(null, response);
+                    }
+                    else {
+                        cb('No data received from barcode service', null);
+                    }
+                }
+                else {
+                    let msg = 'Failed to set presence';
+                    if (request.statusText !== undefined && request.statusText !== "") {
+                        msg += request.statusText;
+                    }
+                    cb(msg, null);
+                }
+            }
+        };
+        request.send(JSON.stringify(presenceData));
+    }
+    lps.setPresence = setPresence;
+    function init(service, parentLog, cb) {
+        log = parentLog.createChild('LPS');
+        lpsServiceUrl = "ws:" + service.host + ":" + service.port;
+        httpUrl = "http://" + service.host + ":" + service.port;
+        async.parallel([
+            _createMotionSocket,
+            _createAudioSocket
+        ], cb);
+    }
+    lps.init = init;
+    function _createMotionSocket(cb) {
+        motionSocket = new jibo_client_framework_1.WSClient(lpsServiceUrl + "/lps/visual_awareness");
+        motionSocket.on('error', () => {
+            console.error(`Error opening visual awareness socket at ${lpsServiceUrl}/visual_awareness`);
+        });
+        motionSocket.on('message', (data) => {
+            lpsData.motionData = data;
+        });
+        cb();
+    }
+    lps._createMotionSocket = _createMotionSocket;
+    function _createAudioSocket(cb) {
+        audioSocket = new jibo_client_framework_1.WSClient(lpsServiceUrl + "/lps/audible_awareness");
+        audioSocket.on('error', () => {
+            console.error(`Error opening audible awareness socket at ${lpsServiceUrl}/audible_awareness`);
+        });
+        audioSocket.on('message', (data) => {
+            lpsData.audioData = data;
+        });
+        cb();
+    }
+    lps._createAudioSocket = _createAudioSocket;
+})(lps = exports.lps || (exports.lps = {}));
+
+},{"async":undefined,"jibo-client-framework":undefined}],3:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ServiceOwner {
+    static init(owner) {
+        this._owner = owner;
+    }
+}
+exports.ServiceOwner = ServiceOwner;
+
+},{}]},{},[1])(1)
+});
+
+//# sourceMappingURL=index.js.map