RemoteConnector.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_REMOTECONNECTOR_H_
#define _TCMENU_REMOTECONNECTOR_H_
 
#include <PlatformDetermination.h>
#include "RemoteTypes.h"
#include <tcUtil.h>
#include "MenuItems.h"
#include "RuntimeMenuItem.h"
#include "MessageProcessors.h"
#include "MenuIterator.h"
#include "ScrollChoiceMenuItem.h"
 
#define TAG_VAL_PROTOCOL 0x01
#define BINARY_GZ_PROTOCOL 0x02
#define START_OF_MESSAGE 0x01
#define TICK_INTERVAL 1
 
// This sets the DEFAULT heartbeat interval when no other interval has been set on a connection. IE if you create a
// connection and do not call setHeartbeatInterval(millis), this is what you'll get.
#ifndef HEARTBEAT_INTERVAL
# define HEARTBEAT_INTERVAL 1500
#endif
 
// Pairing is different to a normal connection, in that we just need to provide the user with reasonable time to
// accept the pairing request on a device, usually around 15 seconds is enough. You can redefine if needed.
#ifndef PAIRING_TIMEOUT_TICKS
#define PAIRING_TIMEOUT_TICKS (15000 / TICK_INTERVAL)
#endif
 
enum FieldValueType : uint8_t {
    FVAL_NEW_MSG,
    FVAL_END_MSG, 
    FVAL_FIELD, 
    FVAL_ERROR_PROTO,
    FVAL_PROCESSING, 
    FVAL_PROCESSING_WAITEQ, 
    FVAL_PROCESSING_VALUE, 
    FVAL_PROCESSING_AWAITINGMSG, 
    FVAL_PROCESSING_PROTOCOL,
    FVAL_PROCESSING_MSGTYPE_HI,
    FVAL_PROCESSING_MSGTYPE_LO
};
 
struct FieldAndValue {
    FieldValueType fieldType;
    uint16_t msgType;
    uint16_t field;
    char value[MAX_VALUE_LEN];
    uint8_t len;
};
 
#define COMMSERR_OK 0
#define COMMSERR_WRITE_NOT_CONNECTED 1
#define COMMSERR_PROTOCOL_ERROR 2
#define COMMSERR_CONNECTED 3
#define COMMSERR_DISCONNECTED 4
 
struct CommunicationInfo {
    uint16_t remoteNo: 4;
    uint16_t connected: 1;
    uint16_t errorMode: 8;
};
 
typedef void (*CommsCallbackFn)(CommunicationInfo);
 
// forward references.
class AuthenticationManager;
class EditableLargeNumberMenuItem;
 
enum TagValueTransportType {
    TVAL_UNBUFFERED,
    TVAL_BUFFERED,
    TVAL_BUFFERED_DELEGATE_ENCRYPT
};
 
class TagValueTransport {
protected:
    FieldAndValue currentField;
    TagValueTransportType transportType;
    uint8_t protocolUsed;
public:
    explicit TagValueTransport(TagValueTransportType type);
    virtual ~TagValueTransport() = default;
 
    virtual void startMsg(uint16_t msgType);
    void startBinMsg(uint16_t msgType, uint16_t byteLen);
    void writeField(uint16_t field, const char* value);
    void writeFieldInt(uint16_t field, int value);
    void writeFieldLong(uint16_t field, long value);
    FieldAndValue* fieldIfAvailable();
    void clearFieldStatus(FieldValueType ty = FVAL_PROCESSING);
    TagValueTransportType getTransportType() { return transportType; }
 
    virtual void flush() = 0;
    virtual int writeChar(char data) = 0;
    virtual int writeStr(const char* data) = 0;
    virtual uint8_t readByte()=0;
    virtual bool readAvailable()=0;
 
    virtual bool available() = 0;
    virtual bool connected() = 0;
    virtual void close() = 0;
    virtual void endMsg();
private:
    bool findNextMessageStart();
    bool processMsgKey();
    bool processValuePart();
};
 
#define FLAG_CURRENTLY_CONNECTED 0
#define FLAG_BOOTSTRAP_MODE 1
#define FLAG_BOOTSTRAP_COMPLETE 2
#define FLAG_AUTHENTICATED 3
#define FLAG_PAIRING_MODE 4
#define FLAG_FULLY_JOINED_RX 5
#define FLAG_FULLY_JOINED_TX 6
 
class TagValueRemoteConnector {
private:
    const ConnectorLocalInfo* localInfoPgm;
    uint16_t ticksLastSend;
    uint16_t ticksLastRead;
    uint16_t hbTimeoutTicks;
    CombinedMessageProcessor* processor;
    TagValueTransport* transport;   
    CommsCallbackFn commsCallback;
    AuthenticationManager* authManager;
 
    // used by bootstrapping and writing out messages
    MenuItemIterator iterator;
    MenuItemTypePredicate bootPredicate;
    RemoteNoMenuItemPredicate remotePredicate;
 
    // the remote connection details take 16 bytes
    char remoteName[16];
    uint8_t remoteMajorVer, remoteMinorVer;
    ApiPlatform remotePlatform;
    uint8_t flags;
    uint8_t remoteNo;
public:
    explicit TagValueRemoteConnector(uint8_t remoteNo = 0);
 
    void initialise(TagValueTransport* transport, CombinedMessageProcessor* processor, const ConnectorLocalInfo* localInfoPgm, uint8_t remoteNo);
 
    void setAuthManager(AuthenticationManager* mgr) { authManager = mgr; }
 
    void setCommsNotificationCallback(CommsCallbackFn callback) { this->commsCallback = callback; }
 
    bool isTransportAvailable() { return transport->available(); }
 
    void provideAuthentication(const char* auth);
 
    bool isTransportConnected() { return transport->connected(); }
 
    void encodeJoin();
 
    void encodeCustomTagValMessage(uint16_t msgType, void (*msgWriter)(TagValueTransport*, void*), void*);
 
    void encodeCustomBinaryMessage(uint16_t msgType, uint16_t len, void (*msgWriter)(TagValueTransport*, void*, size_t), void* data = nullptr);
 
    void encodeDialogMsg(uint8_t mode, uint8_t btn1, uint8_t btn2, const char* hdrPgm, const char* buffer);
 
    void encodeBootstrap(bool isComplete);
 
    void encodeHeartbeat(HeartbeatMode restartConnection);
 
    void encodeAnalogItem(int parentId, AnalogMenuItem* item);
 
    void encodeSubMenu(int parentId, SubMenuItem* item);
 
    void encodeBooleanMenu(int parentId, BooleanMenuItem* item);
 
    void encodeEnumMenu(int parentId, EnumMenuItem* item);
 
    void encodeActionMenu(int parentId, ActionMenuItem* item);
 
    void encodeFloatMenu(int parentId, FloatMenuItem* item);
 
    void encodeRuntimeMenuItem(int parentId, RuntimeMenuItem* item);
 
    void encodeMultiEditMenu(int parentId, RuntimeMenuItem* item);
 
    void encodeLargeNumberMenuItem(int parentId, EditableLargeNumberMenuItem* item);
 
    void encodeChangeValue(MenuItem* theItem);
 
    void encodeAcknowledgement(uint32_t correlation, AckResponseStatus status);
 
    void encodeColorMenuItem(int id, Rgb32MenuItem *pItem);
 
    void encodeScrollMenuItem(int id, ScrollChoiceMenuItem *pItem);
 
    void tick();
 
    void pairingRequest(const char* name, const char* uuid);
 
    void initiateBootstrap();
 
    uint8_t getRemoteNo() const {return remoteNo;}
 
    const char* getRemoteName() {return remoteName;}
 
    uint8_t getRemoteMajorVer() const {return remoteMajorVer;}
 
    uint8_t getRemoteMinorVer() const {return remoteMinorVer;}
    
    ApiPlatform getRemotePlatform() {return remotePlatform;}
 
    bool isConnected() { return bitRead(flags, FLAG_CURRENTLY_CONNECTED); }
 
    void setRemoteName(const char* name);
 
    void setRemoteConnected(uint8_t major, uint8_t minor, ApiPlatform platform);
 
    void commsNotify(uint16_t commsEventType);
 
    void close();
 
    bool isAuthenticated() { return bitRead(flags, FLAG_AUTHENTICATED); }
    AuthenticationManager* getAuthManager() { return authManager; }
 
    void setHeartbeatTimeout(uint16_t milli) { hbTimeoutTicks = milli / TICK_INTERVAL; }
private:
    void encodeBaseMenuFields(int parentId, MenuItem* item);
    bool prepareWriteMsg(uint16_t msgType);
    void nextBootstrap();
    void performAnyWrites();
    void dealWithHeartbeating();
    void setConnected(bool conn);
 
    bool isBootstrapMode() { return bitRead(flags, FLAG_BOOTSTRAP_MODE); }
    void setBootstrapMode(bool mode) { bitWrite(flags, FLAG_BOOTSTRAP_MODE, mode); }
 
    bool isBootstrapComplete() { return bitRead(flags, FLAG_BOOTSTRAP_COMPLETE); }
    void setBootstrapComplete(bool mode) { bitWrite(flags, FLAG_BOOTSTRAP_COMPLETE, mode); }
 
    void setAuthenticated(bool auth) { bitWrite(flags, FLAG_AUTHENTICATED, auth); }
 
    bool isPairing() { return bitRead(flags, FLAG_PAIRING_MODE); }
    void setPairing(bool pair) { bitWrite(flags, FLAG_PAIRING_MODE, pair); }
 
    bool isConnectionFullyEstablished() {
        return isConnected() && (bitRead(flags, FLAG_FULLY_JOINED_RX) != 0) && (bitRead(flags, FLAG_FULLY_JOINED_TX) != 0);
    }
 
    void setFullyJoinedRx(bool joinRx) { bitWrite(flags, FLAG_FULLY_JOINED_RX, joinRx); }
 
    void setFullyJoinedTx(bool joinTx) { bitWrite(flags, FLAG_FULLY_JOINED_TX, joinTx); }
 
    bool beginEncodeChange(MenuItem *item);
};
 
#endif /* _TCMENU_REMOTECONNECTOR_H_ */