BaseRemoteComponents.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 https://www.thecoderscorner.com (Dave Cherry).
 * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
 */

 
#ifndef TCMENU_BASEREMOTECOMPONENTS_H
#define TCMENU_BASEREMOTECOMPONENTS_H
 
#include <PlatformDetermination.h>
#include "../RemoteConnector.h"
 
// This defines the number of different connections that can be established, for example each websocket, or each
// tagval connection takes one of these, you can define this to a different number as a build flag. Web server static
// content servers don't count toward this.
#ifndef ALLOWED_CONNECTIONS
#define ALLOWED_CONNECTIONS 4
#endif
 
namespace tcremote {
 
    class BaseRemoteServerConnection;

    class DeviceInitialisation {
    protected:
        bool initialised = false;
    public:
        bool isInitialised() const { return initialised; }
        virtual bool attemptInitialisation()=0;
        virtual bool attemptNewConnection(BaseRemoteServerConnection* remoteConnection)=0;
    };

    class NoInitialisationNeeded : public DeviceInitialisation {
    private:
        bool attemptConnectionReturn;
    public:
        explicit NoInitialisationNeeded(bool attemptConnectionReturn = true) : attemptConnectionReturn(attemptConnectionReturn) {}
 
        bool attemptInitialisation() override {
            initialised = true;
            return true;
        }
 
        bool attemptNewConnection(BaseRemoteServerConnection *transport) override { return true; }
    };
 
    enum RemoteServerType: uint8_t {
        TAG_VAL_REMOTE_SERVER, SIMHUB_CONNECTOR, TAG_VAL_WEB_SOCKET
    };
 
    class BaseRemoteServerConnection {
    protected:
        DeviceInitialisation &initialisation;
        RemoteServerType remoteServerType;
    public:
        BaseRemoteServerConnection(DeviceInitialisation &initialisation, RemoteServerType remoteServerType)
                : initialisation(initialisation), remoteServerType(remoteServerType) {}
 
        RemoteServerType getRemoteServerType() { return remoteServerType; }
 
        DeviceInitialisation& getDeviceInitialisation() const { return initialisation; }
        void runLoop();
        virtual void init(int remoteNumber, const ConnectorLocalInfo& info) = 0;
        virtual void tick() = 0;
        virtual bool connected() = 0;
        virtual void copyConnectionStatus(char *buffer, int bufferSize) = 0;
        virtual void notifyRemoteHasClosed() {}
    };

    class TagValueRemoteServerConnection : public BaseRemoteServerConnection {
    private:
        TagValueRemoteConnector remoteConnector;
        TagValueTransport &remoteTransport;
        CombinedMessageProcessor messageProcessor;
    public:
        TagValueRemoteServerConnection(TagValueTransport &transport, DeviceInitialisation& initialisation);
 
        void init(int remoteNumber, const ConnectorLocalInfo& info) override;
 
        TagValueRemoteConnector *connector() { return &remoteConnector; }
 
        TagValueTransport *transport() { return &remoteTransport; }
 
        CombinedMessageProcessor *messageProcessors() { return &messageProcessor; }
 
        void tick() override;
        bool connected() override { return remoteTransport.connected(); }
 
        void copyConnectionStatus(char *buffer, int bufferSize) override;
 
        void notifyRemoteHasClosed() override;
    };

    class TcMenuRemoteServer : public Executable {
        BaseRemoteServerConnection* connections[ALLOWED_CONNECTIONS];
        const ConnectorLocalInfo& appInfo;
        uint8_t remotesAdded;
    public:
        explicit TcMenuRemoteServer(const ConnectorLocalInfo& appInfo) : connections{}, appInfo(appInfo), remotesAdded(0) { }

        void clearRemotes() {
            remotesAdded = 0;
        }
 
        void exec() override;

        uint8_t addConnection(BaseRemoteServerConnection *toAdd);

        uint8_t remoteCount() const { return remotesAdded; }

        TagValueRemoteConnector *getRemoteConnector(int num) {
            if(num >= remotesAdded || connections[num]->getRemoteServerType() != TAG_VAL_REMOTE_SERVER) return nullptr;
            return reinterpret_cast<TagValueRemoteServerConnection*>(connections[num])->connector();
        }

        TagValueTransport *getTransport(int num) {
            if(num >= remotesAdded || connections[num]->getRemoteServerType() != TAG_VAL_REMOTE_SERVER) return nullptr;
            return reinterpret_cast<TagValueRemoteServerConnection*>(connections[num])->transport();
        }

        BaseRemoteServerConnection* getRemoteServerConnection(int num) {
            if(num >= remotesAdded) return nullptr;
            return connections[num];
        }
 
        void setHeartbeatIntervalAll(uint16_t milli);
    };

    int fromWiFiRSSITo4StateIndicator(int strength);
 
}
 
#endif //TCMENU_BASEREMOTECOMPONENTS_H