JSTcpClient.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_JSTCPCLIENT_HXX_
#define _UTILS_JSTCPCLIENT_HXX_
 
#ifdef __EMSCRIPTEN__
 
#include <emscripten.h>
#include <emscripten/val.h>
 
#include "utils/Hub.hxx"
#include "utils/JSHubPort.hxx"
 
class JSTcpClient : private JSHubFeedback
{
public:
    enum ConnectionFeedback {
        CONNECTION_UP,
        CONNECTION_DOWN,
        CONNECTION_ERROR
    };
    
    JSTcpClient(CanHubFlow *hflow, string host, int port,
        std::function<void(ConnectionFeedback)> cb = nullptr)
        : canHub_(hflow)
        , callback_(std::move(cb))
    {
        string script = "Module.remote_server = '" + host + "';\n";
        emscripten_run_script(script.c_str());
        
        EM_ASM_(
            {
                var net = require('net');
                console.log(
                    'Connecting to ' + Module.remote_server + ": " + $0);
                var c = net.connect($0, Module.remote_server, function() {
                    console.log('connected to hub: ' + c);
                    c.setEncoding('utf-8');
                    c.setTimeout(0);
                    c.setKeepAlive(true);
                    var client_port = new Module.JSHubPort(
                        $1, function(data) { c.write(data); }, $2);
                    c.on('close', function() {
                        console.log('connection lost');
                        client_port.fb_close();
                        client_port.abandon();
                    });
                    c.on('error', function(err) {
                        console.log('connection error -- disconnected');
                        client_port.fb_error(err.toString());
                        client_port.abandon();
                    });
                    c.on('data', function(data) { client_port.recv(data); });
                });
                c.on('error', function(err) {
                    console.log('Failed to connect.');
                    Module.JSHubFeedback.call_on_error($2, err.toString());
                });
            },
            port, (unsigned long)canHub_, (unsigned long)((JSHubFeedback*)this));
    }
 
    bool is_connected()
    {
        return connected_;
    }
 
private:
 
    void on_open() override
    {
        connected_ = true;
        LOG(INFO, "connected");
        if (callback_)
        {
            callback_(CONNECTION_UP);
        }
    }
 
    void on_close() override
    {
        connected_ = false;
        LOG(INFO, "closed");
        if (callback_)
        {
            callback_(CONNECTION_DOWN);
        }
    }
 
    void on_error(string error) override
    {
        LOG(INFO, "%s", error.c_str());
        connected_ = false;
        if (callback_)
        {
            callback_(CONNECTION_ERROR);
        }
    }
 
    CanHubFlow *canHub_;
    bool connected_ = false;
    std::function<void(ConnectionFeedback)> callback_;    
};
 
#endif // __EMSCRIPTEN__
#endif // _UTILS_JSTCPCLIENT_HXX_