smartfacecloud-emulator-dispatcher/src/control/ControlService.js

Handles Emulator Dispatcher Part of SmartfaceCloud

const MessageFactory = require('../common/MessageFactory');
const Workspace = require('smartfacecloud-emulator-index');
const uuid = require('uuid');
const debugSession = require("../debug/debugsession.js");
const LogToConsole = require("../common/LogToConsole");
const sendResetTimeout = require("../common/sendResetTimeout");
const CONSTANTS = require("../constants");

function ControlService() {
    const UI = 'UI';
    const DEVICE = 'device';
    const MESSAGE = 'message';
    const FILE_TRANSFER = 'file-transfer';
    const DEBUGGER = 'debugger';
    const ALL = '*';
    const waitForSync = true;
    const messageFactory = new MessageFactory();

    var workspace = null;
    var request;
    var callbackList = {};
    var self = this;
    var log;
    this.request = null;
    this.deviceInfo = null;

    this.init = function(requestService, opts) {
        opts = opts || {};
        log = new LogToConsole(opts.logToConsole, '[CONTROL]').log;
        request = requestService;
        getWorkspaceOptions();
        log("ControlService init");
    };

    this.handleMessage = function(from, message, connectedObject) {
        log("Handle message from", from, "message", message);
        if (callbackList[message.id]) {
            callbackList[message.id](null, message);
        }
        else {
            if (message.event) {
                if (message.event === "fileTransferCompleted") {
                    self.start("Project");
                }
                else if (message.event === "switchedProject") {
                    self.init(request);
                }
            }

            if (message.command) {
                if (message.command === "pingDevice") {
                    self.ping();
                }
                else if (message.command === "start project") {
                    if (message.data.debugSupported) {
                        var randomID = uuid.v4(),
                            handledRespone = false;

                        if (global.shared.uiCommandEventEmiter) {
                            global.shared.uiCommandEventEmiter.once("resume project", sendDebugMessages);
                            global.shared.uiCommandEventEmiter.once("resumeFromSync", sendResumeFromSync);
                        }
                        var messageStartWithDebug = messageFactory.createMessage("start project", {
                            "responseID": randomID,
                            "debugger": message.data.debugger
                        });
                        sendRequest(UI, null, messageStartWithDebug);

                        var timeoutID = setTimeout(function() {
                            sendDebugMessages({
                                data: {}
                            });
                        }, 30000);
                    }
                    else {
                        sendStartDebug();
                    }
                }
                else if (message.command === "getIndex") {
                    self.deviceInfo = message.data;
                    global.shared.allDeviceInfos[self.deviceInfo.deviceID] = self.deviceInfo;

                    sendRequest(ALL, null, {
                        event: "deviceInfo",
                        deviceInfo: self.deviceInfo
                    });
                    if (workspace == null) {
                        getWorkspaceOptions(function(err, received) {
                            if (err)
                                throw err;

                            self.sendIndex();
                        });
                    }
                    else {
                        self.sendIndex();
                    }
                }
                else if (message.command === 'cancelTransfer') {
                    var messageToDevice = {};
                    messageToDevice.errors = [];
                    messageToDevice.warnings = [];
                    messageToDevice.errors.push(message.data.errorMessage);
                    sendRequest(DEVICE, null, messageFactory.createMessage(
                        'cancelTransfer', messageToDevice));
                }
                else if (message.command === 'stop project') {
                    var responseMessage = messageFactory.createMessage("stop project", {
                        responseID: uuid.v4()
                    });
                    sendRequest(UI, null, responseMessage);
                }
                else if (message.command === "resetTimeout") {
                    sendRequest(DEVICE, null, messageFactory.createMessage(message.command));
                }
            }
        }

        function sendStartDebug(isDebugging) {
            var allUIWebsockets = global.shared.allUIWebsockets,
                messageResponse;

            if (connectedObject && !allUIWebsockets[connectedObject.browserGuid]) {
                isDebugging = false;
            }
            messageResponse = messageFactory.createMessage("resume project", {
                debug: !!isDebugging,
                waitForSync: waitForSync
            });
            messageResponse.id = message.id;
            sendRequest(DEVICE, null, messageResponse);
            log("Sending resume project to DEVICE with isDebugging:", !!isDebugging);
        }

        function sendDebugMessages(message) {
            clearTimeout(timeoutID);
            if (handledRespone)
                return;
            handledRespone = true;
            var isDebugging = (randomID === message.data.responseID && message.data.isDebugging);
            if (isDebugging) {
                isDebugging = !!debugSession.createNewSession(connectedObject, {
                    logToConsole: true
                });
                if (isDebugging) {
                    var messageAttach = messageFactory.createMessage("attach", {});
                    log("Attach issued");
                    sendRequest(UI, null, messageAttach);
                }
            }
            sendStartDebug(isDebugging);
        }

        function sendResumeFromSync() {
            var messageResumeFromSync = messageFactory.createMessage("resumeFromSync", {});
            sendRequest(DEVICE, null, messageResumeFromSync);
        }
    };

    function getWorkspaceOptions(callback) {
        log("Received workspace options");
        const received = {
            path: CONSTANTS.WORKSPACE_PATH,
            projectID: process.env.C9_HOSTNAME
        };
        workspace = new Workspace({
            path: received.path,
            projectID: received.projectID
        });
        if (callback) {
            callback(null, received);
        }
    }

    // Commands

    this.sendIndex = function() {
        log("sendIndex");

        var deviceID = this.deviceInfo.deviceID;

        try {
            sendResetTimeout.set(deviceID, function() {
                sendRequest(DEVICE, "resetTimeout",
                    messageFactory.createMessage("resetTimeout"));
            });
            workspace.getIndex(self.deviceInfo, function(err, indexData) {
                sendResetTimeout.clear(deviceID);
                global.shared.allDeviceInfos[self.deviceInfo.deviceID].indexData = indexData;
                sendRequest(DEVICE, null, messageFactory.createMessage("getFiles", indexData));
            });
        }
        catch (ex) {
            sendResetTimeout.clear(deviceID);
            sendRequest(DEVICE, null, messageFactory.createMessage("getFiles", null));
        }
    };

    this.start = function(type) {
        log("start");
        var message = messageFactory.createMessage("start", type);
        sendRequest(DEVICE, null, message);
    };

    this.stop = function(type) {
        log("stop");
        var message = messageFactory.createMessage("stop", type);
        sendRequest(DEVICE, null, message);
    };

    this.erase = function() {
        log("erase");
        var message = messageFactory.createMessage("erase");
        sendRequest(DEVICE, null, message);
    };

    this.ping = function() {
        log("ping");
        var message = messageFactory.createMessage("ping");
        sendRequest(DEVICE, null, message);
    };

    this.openUrl = function(url) {
        log("openUrl");
        var message = messageFactory.createMessage("openUrl", {
            url: url
        });
        sendRequest(DEVICE, null, message);
    };

    // Communication

    function sendRequest(to, command, message, callback) {
        if (callback) {
            callbackList[message.id] = callback;
        }
        request(MESSAGE, to, command, message);
    }
}

module.exports = ControlService;