Components/Hosted/include/Hosted/Client.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * Client.h
 *
 * @author 2021 Slavey Karadzhov <slav@attachix.com>
 *
 *
 ****/

#pragma once

#ifndef ARCH_HOST
#error "Hosted::Client can be used only on the Host architecture!"
#endif

#include <Stream.h>
#include <WHashMap.h>
#include <WString.h>
#include <simpleRPC.h>
#include <simpleRPC/parser.h>
#include <hostlib/emu.h>
#include <hostlib/hostmsg.h>
#include "Util.h"

using namespace simpleRPC;

namespace Hosted
{
constexpr int COMMAND_NOT_FOUND = -1;

class Client
{
public:
    using RemoteCommands = HashMap<String, uint8_t>;

    Client(Stream& stream, char methodEndsWith = ':') : stream(stream), methodEndsWith(methodEndsWith)
    {
    }

    template <typename... Args> bool send(const String& functionName, Args... args)
    {
        int functionId = getFunctionId(functionName);
        if(functionId == COMMAND_NOT_FOUND) {
            return false;
        }

        rpcPrint(stream, uint8_t(functionId), args...);
        stream.flush();

        return true;
    }

    template <typename R> R wait()
    {
        size_t neededBytes = sizeof(R);

        while(stream.available() < int(neededBytes)) {
            stream.flush();
            host_main_loop();
        }

        R result{};
        stream.readBytes(reinterpret_cast<char*>(&result), sizeof(result));
        return result;
    }

    int getFunctionId(String name)
    {
        if(fetchCommands) {
            getRemoteCommands();
        }

        if(name.indexOf('(') != -1 && name.indexOf(')') != -1) {
            // most probably we have a name with a signature
            name = convertFQN(name);
        }

        int id = commands.indexOf(name);
        if(id < 0) {
            return COMMAND_NOT_FOUND;
        }

        return commands[name];
    }

    bool getRemoteCommands()
    {
        host_debug_i("Getting remote RPC commands \033[5m...\033[0m");

        uint8_t head = 0xff;
        stream.write(&head, 1);
        char buffer[512];
        ParserSettings settings;
        settings.startMethods = ParserSettings::SimpleMethod(&Client::startMethods, this);
        settings.startMethod = ParserSettings::SimpleMethod(&Client::startMethod, this);
        settings.methodSignature = ParserSettings::CharMethod(&Client::methodSignature, this);
        settings.methodName = ParserSettings::CharMethod(&Client::methodName, this);
        settings.endMethod = ParserSettings::SimpleMethod(&Client::endMethod, this);
        settings.endMethods = ParserSettings::SimpleMethod(&Client::endMethods, this);
        settings.state = ParserState::ready;

        do {
            stream.flush();
            host_main_loop();

            size_t length = stream.readBytes(buffer, 512);
            if(!length) {
                continue;
            }

            ParserResult result = parse(settings, buffer, length, methodEndsWith);
            if(result == ParserResult::finished) {
                break;
            }

            if(result == ParserResult::error) {
                host_debug_e("Invalid header");
                return false;
            }
        } while(true);

        host_debug_i("Available commands:");

        for(size_t i = 0; i < commands.count(); i++) {
            host_debug_i("\t%s => %d", commands.keyAt(i).c_str(), commands.valueAt(i));
        }

        host_debug_i("Connected. Starting application");

        return true;
    }

private:
    Stream& stream;
    bool fetchCommands{true};
    RemoteCommands commands;
    uint8_t methodPosition = 0;
    String name;
    String signature;
    char methodEndsWith;

    void startMethods()
    {
        methodPosition = 0;
        commands.clear();
    }

    void startMethod()
    {
        name = "";
        signature = "";
    }

    void methodSignature(char ch)
    {
        signature += ch;
    }

    void methodName(char ch)
    {
        name += ch;
    }

    void endMethod()
    {
        if(!commands.contains(name) || signature == ":") {
            commands[name] = methodPosition;
        }
        commands[name + "(" + signature + ")"] = methodPosition++;
    }

    void endMethods()
    {
        fetchCommands = false;
    }
};

} // namespace Hosted