refactor NetworkDevice interface to work with new esp mqtt lib

2023-01-28 17:17:46 +01:00
parent a6010a7f49
commit 5853b0dc0e
24 changed files with 493 additions and 287 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -49,6 +49,8 @@ file(GLOB SRCFILES
        networkDevices/NetworkDevice.h
        networkDevices/WifiDevice.cpp
        networkDevices/W5500Device.cpp
+        networkDevices/ClientSyncEthernet.cpp
+        networkDevices/espMqttClientEthernet.cpp
        NukiWrapper.cpp
        NukiOpenerWrapper.cpp
        MqttTopics.h
--- a/Config.h
+++ b/Config.h
@@ -1,6 +1,6 @@
 #pragma once

-#define NUKI_HUB_VERSION "7.3-esp-mqtt-5"
+#define NUKI_HUB_VERSION "7.3-esp-mqtt-6"

 #define MQTT_QOS_LEVEL 1
 #define MQTT_CLEAN_SESSIONS false
--- a/Network.cpp
+++ b/Network.cpp
@@ -136,8 +136,8 @@ void Network::initialize()
    Log->print(F(":"));
    Log->println(port);

-    _device->mqttClient()->setClientId(_hostnameArr);
-    _device->mqttClient()->setCleanSession(MQTT_CLEAN_SESSIONS);
+    _device->mqttSetClientId(_hostnameArr);
+    _device->mqttSetCleanSession(MQTT_CLEAN_SESSIONS);

    _networkTimeout = _preferences->getInt(preference_network_timeout);
    if(_networkTimeout == 0)
@@ -182,7 +182,7 @@ bool Network::update()

    }

-    if(!_device->mqttClient()->connected())
+    if(!_device->mqttConnected())
    {
        if(_networkTimeout > 0 && (ts - _lastConnectedTs > _networkTimeout * 1000) && ts > 60000)
        {
@@ -238,7 +238,7 @@ bool Network::reconnect()
    _mqttConnectionState = 0;
    int port = _preferences->getInt(preference_mqtt_broker_port);

-    while (!_device->mqttClient()->connected() && millis() > _nextReconnect)
+    while (!_device->mqttConnected() && millis() > _nextReconnect)
    {
        if(strcmp(_mqttBrokerAddr, "") == 0)
        {
@@ -252,23 +252,23 @@ bool Network::reconnect()
        if(strlen(_mqttUser) == 0)
        {
            Log->println(F("MQTT: Connecting without credentials"));
-            _device->mqttClient()->setServer(_mqttBrokerAddr, port);
-            _device->mqttClient()->connect();
+            _device->mqttSetServer(_mqttBrokerAddr, port);
+            _device->mqttConnect();
        }
        else
        {
            Log->print(F("MQTT: Connecting with user: ")); Log->println(_mqttUser);
-            _device->mqttClient()->setCredentials(_mqttUser, _mqttPass);
-            _device->mqttClient()->setServer(_mqttBrokerAddr, port);
-            _device->mqttClient()->connect();
+            _device->mqttSetCredentials(_mqttUser, _mqttPass);
+            _device->mqttSetServer(_mqttBrokerAddr, port);
+            _device->mqttConnect();
        }

-        bool connected = _device->mqttClient()->connected();
+        bool connected = _device->mqttConnected();
        unsigned long timeout = millis() + 5000;

        while(!connected && millis() < timeout)
        {
-            connected = _device->mqttClient()->connected();
+            connected = _device->mqttConnected();
            delay(200);
        }

@@ -279,17 +279,17 @@ bool Network::reconnect()
            delay(100);

            // TODO
-            _device->mqttClient()->onMessage(Network::onMqttDataReceivedCallback);
+            _device->mqttOnMessage(Network::onMqttDataReceivedCallback);
            for(const String& topic : _subscribedTopics)
            {
-                _device->mqttClient()->subscribe(topic.c_str(), MQTT_QOS_LEVEL);
+                _device->mqttSubscribe(topic.c_str(), MQTT_QOS_LEVEL);
            }
            if(_firstConnect)
            {
                _firstConnect = false;
                for(const auto& it : _initTopics)
                {
-                    _device->mqttClient()->publish(it.first.c_str(), MQTT_QOS_LEVEL, true, it.second.c_str());
+                    _device->mqttPublish(it.first.c_str(), MQTT_QOS_LEVEL, true, it.second.c_str());
                }
            }
            delay(1000);
@@ -371,11 +371,6 @@ void Network::onMqttDataReceived(const espMqttClientTypes::MessageProperties& pr
    }
 }

-MqttClientSetup *Network::mqttClient()
-{
-    return _device->mqttClient();
-}
-
 void Network::reconfigureDevice()
 {
    _device->reconfigure();
@@ -405,7 +400,7 @@ void Network::publishFloat(const char* prefix, const char* topic, const float va
    dtostrf(value, 0, precision, str);
    char path[200] = {0};
    buildMqttPath(prefix, topic, path);
-    _device->mqttClient()->publish(path, MQTT_QOS_LEVEL, true, str);
+    _device->mqttPublish(path, MQTT_QOS_LEVEL, true, str);
 }

 void Network::publishInt(const char* prefix, const char *topic, const int value)
@@ -414,7 +409,7 @@ void Network::publishInt(const char* prefix, const char *topic, const int value)
    itoa(value, str, 10);
    char path[200] = {0};
    buildMqttPath(prefix, topic, path);
-    _device->mqttClient()->publish(path, MQTT_QOS_LEVEL, true, str);
+    _device->mqttPublish(path, MQTT_QOS_LEVEL, true, str);
 }

 void Network::publishUInt(const char* prefix, const char *topic, const unsigned int value)
@@ -423,7 +418,7 @@ void Network::publishUInt(const char* prefix, const char *topic, const unsigned
    utoa(value, str, 10);
    char path[200] = {0};
    buildMqttPath(prefix, topic, path);
-    _device->mqttClient()->publish(path, MQTT_QOS_LEVEL, true, str);
+    _device->mqttPublish(path, MQTT_QOS_LEVEL, true, str);
 }

 void Network::publishULong(const char* prefix, const char *topic, const unsigned long value)
@@ -432,7 +427,7 @@ void Network::publishULong(const char* prefix, const char *topic, const unsigned
    utoa(value, str, 10);
    char path[200] = {0};
    buildMqttPath(prefix, topic, path);
-    _device->mqttClient()->publish(path, MQTT_QOS_LEVEL, true, str);
+    _device->mqttPublish(path, MQTT_QOS_LEVEL, true, str);
 }

 void Network::publishBool(const char* prefix, const char *topic, const bool value)
@@ -441,14 +436,14 @@ void Network::publishBool(const char* prefix, const char *topic, const bool valu
    str[0] = value ? '1' : '0';
    char path[200] = {0};
    buildMqttPath(prefix, topic, path);
-    _device->mqttClient()->publish(path, MQTT_QOS_LEVEL, true, str);
+    _device->mqttPublish(path, MQTT_QOS_LEVEL, true, str);
 }

 bool Network::publishString(const char* prefix, const char *topic, const char *value)
 {
    char path[200] = {0};
    buildMqttPath(prefix, topic, path);
-    return _device->mqttClient()->publish(path, MQTT_QOS_LEVEL, true, value) > 0;
+    return _device->mqttPublish(path, MQTT_QOS_LEVEL, true, value) > 0;
 }

 void Network::publishHASSConfig(char* deviceType, const char* baseTopic, char* name, char* uidString, char* lockAction, char* unlockAction, char* openAction, char* lockedState, char* unlockedState)
@@ -490,7 +485,7 @@ void Network::publishHASSConfig(char* deviceType, const char* baseTopic, char* n
        path.concat(uidString);
        path.concat("/smartlock/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());

        // Battery critical
        configJSON = "{\"dev\":{\"ids\":[\"nuki_";
@@ -514,7 +509,7 @@ void Network::publishHASSConfig(char* deviceType, const char* baseTopic, char* n
        path.concat(uidString);
        path.concat("/battery_low/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());

        // Keypad battery critical
        configJSON = "{\"dev\":{\"ids\":[\"nuki_";
@@ -538,7 +533,7 @@ void Network::publishHASSConfig(char* deviceType, const char* baseTopic, char* n
        path.concat(uidString);
        path.concat("/keypad_battery_low/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());

        // Battery voltage
        configJSON = "{\"dev\":{\"ids\":[\"nuki_";
@@ -564,7 +559,7 @@ void Network::publishHASSConfig(char* deviceType, const char* baseTopic, char* n
        path.concat(uidString);
        path.concat("/battery_voltage/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());

        // Trigger
        configJSON = "{\"dev\":{\"ids\":[\"nuki_";
@@ -589,7 +584,7 @@ void Network::publishHASSConfig(char* deviceType, const char* baseTopic, char* n
        path.concat(uidString);
        path.concat("/trigger/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
    }
 }

@@ -625,7 +620,7 @@ void Network::publishHASSConfigBatLevel(char *deviceType, const char *baseTopic,
        path.concat(uidString);
        path.concat("/battery_level/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
    }
 }

@@ -660,7 +655,7 @@ void Network::publishHASSConfigDoorSensor(char *deviceType, const char *baseTopi
        path.concat(uidString);
        path.concat("/door_sensor/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
    }
 }

@@ -694,7 +689,7 @@ void Network::publishHASSConfigRingDetect(char *deviceType, const char *baseTopi
        path.concat(uidString);
        path.concat("/ring/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
    }
 }

@@ -732,7 +727,7 @@ void Network::publishHASSWifiRssiConfig(char *deviceType, const char *baseTopic,
        path.concat(uidString);
        path.concat("/wifi_signal_strength/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
    }
 }

@@ -764,7 +759,7 @@ void Network::publishHASSBleRssiConfig(char *deviceType, const char *baseTopic,
        path.concat(uidString);
        path.concat("/bluetooth_signal_strength/config");

-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, configJSON.c_str());
    }
 }

@@ -778,55 +773,55 @@ void Network::removeHASSConfig(char* uidString)
        path.concat("/lock/");
        path.concat(uidString);
        path.concat("/smartlock/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/binary_sensor/");
        path.concat(uidString);
        path.concat("/battery_low/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/sensor/");
        path.concat(uidString);
        path.concat("/battery_voltage/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/sensor/");
        path.concat(uidString);
        path.concat("/trigger/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/sensor/");
        path.concat(uidString);
        path.concat("/battery_level/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/binary_sensor/");
        path.concat(uidString);
        path.concat("/door_sensor/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/binary_sensor/");
        path.concat(uidString);
        path.concat("/ring/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/sensor/");
        path.concat(uidString);
        path.concat("/wifi_signal_strength/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");

        path = discoveryTopic;
        path.concat("/sensor/");
        path.concat(uidString);
        path.concat("/bluetooth_signal_strength/config");
-        _device->mqttClient()->publish(path.c_str(), MQTT_QOS_LEVEL, true, "");
+        _device->mqttPublish(path.c_str(), MQTT_QOS_LEVEL, true, "");
    }
 }

@@ -839,3 +834,8 @@ const NetworkDeviceType Network::networkDeviceType()
 {
    return _networkDeviceType;
 }
+
+uint16_t Network::subscribe(const char *topic, uint8_t qos)
+{
+    return _device->mqttSubscribe(topic, qos);
+}
--- a/Network.h
+++ b/Network.h
@@ -43,11 +43,12 @@ public:

    void publishPresenceDetection(char* csv);

-    MqttClientSetup* mqttClient();
    int mqttConnectionState(); // 0 = not connected; 1 = connected; 2 = connected and mqtt processed

    const NetworkDeviceType networkDeviceType();

+    uint16_t subscribe(const char* topic, uint8_t qos);
+
 private:
    static void onMqttDataReceivedCallback(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total);
    void onMqttDataReceived(const espMqttClientTypes::MessageProperties& properties, const char* topic, const uint8_t* payload, size_t len, size_t index, size_t total);
--- a/NetworkOpener.cpp
+++ b/NetworkOpener.cpp
@@ -476,7 +476,7 @@ void NetworkOpener::subscribe(const char *path)
 {
    char prefixedPath[500];
    buildMqttPath(path, prefixedPath);
-    _network->mqttClient()->subscribe(prefixedPath, MQTT_QOS_LEVEL);
+    _network->subscribe(prefixedPath, MQTT_QOS_LEVEL);
 }

 bool NetworkOpener::comparePrefixedPath(const char *fullPath, const char *subPath)
--- a/lib/MqttLogger/src/MqttLogger.cpp
+++ b/lib/MqttLogger/src/MqttLogger.cpp
@@ -7,7 +7,7 @@ MqttLogger::MqttLogger(MqttLoggerMode mode)
    this->setBufferSize(MQTT_MAX_PACKET_SIZE);
 }

-MqttLogger::MqttLogger(MqttClientSetup& client, const char* topic, MqttLoggerMode mode)
+MqttLogger::MqttLogger(NetworkDevice* client, const char* topic, MqttLoggerMode mode)
 {
    this->setClient(client);
    this->setTopic(topic);
@@ -19,9 +19,9 @@ MqttLogger::~MqttLogger()
 {
 }

-void MqttLogger::setClient(MqttClientSetup& client)
+void MqttLogger::setClient(NetworkDevice* client)
 {
-    this->client = &client;
+    this->client = client;
 }

 void MqttLogger::setTopic(const char* topic)
@@ -74,9 +74,9 @@ void MqttLogger::sendBuffer()
    if (this->bufferCnt > 0)
    {
        bool doSerial = this->mode==MqttLoggerMode::SerialOnly || this->mode==MqttLoggerMode::MqttAndSerial;
-        if (this->mode!=MqttLoggerMode::SerialOnly && this->client != NULL && this->client->connected()) 
+        if (this->mode!=MqttLoggerMode::SerialOnly && this->client != NULL && this->client->mqttConnected())
        {
-            this->client->publish(topic, 0, true, (uint8_t*)this->buffer, this->bufferCnt);
+            this->client->mqttPublish(topic, 0, true, (uint8_t*)this->buffer, this->bufferCnt);
        } else if (this->mode == MqttLoggerMode::MqttAndSerialFallback)
        {
            doSerial = true;
--- a/lib/MqttLogger/src/MqttLogger.h
+++ b/lib/MqttLogger/src/MqttLogger.h
@@ -11,8 +11,7 @@

 #include <Arduino.h>
 #include <Print.h>
-#include "MqttClient.h"
-#include "MqttClientSetup.h"
+#include "../../../networkDevices/NetworkDevice.h"

 #define MQTT_MAX_PACKET_SIZE 1024

@@ -30,16 +29,16 @@ private:
    uint8_t* buffer;
    uint8_t* bufferEnd;
    uint16_t bufferCnt = 0, bufferSize = 0;
-    MqttClientSetup* client;
+    NetworkDevice* client;
    MqttLoggerMode mode;
    void sendBuffer();

 public:
    MqttLogger(MqttLoggerMode mode=MqttLoggerMode::MqttAndSerialFallback);
-    MqttLogger(MqttClientSetup& client, const char* topic, MqttLoggerMode mode=MqttLoggerMode::MqttAndSerialFallback);
+    MqttLogger(NetworkDevice* client, const char* topic, MqttLoggerMode mode=MqttLoggerMode::MqttAndSerialFallback);
    ~MqttLogger();

-    void setClient(MqttClientSetup& client);
+    void setClient(NetworkDevice* client);
    void setTopic(const char* topic);
    void setMode(MqttLoggerMode mode);
    void setRetained(boolean retained);
--- a/lib/espMqttClient/src/MqttClientSetup.h
+++ b/lib/espMqttClient/src/MqttClientSetup.h
@@ -13,103 +13,104 @@ the LICENSE file.

 #include "MqttClient.h"

+template <typename T>
 class MqttClientSetup : public MqttClient {
-public:
-    void setKeepAlive(uint16_t keepAlive) {
-        _keepAlive = keepAlive * 1000;  // s to ms conversion, will also do 16 to 32 bit conversion
+ public:
+  T& setKeepAlive(uint16_t keepAlive) {
+    _keepAlive = keepAlive * 1000;  // s to ms conversion, will also do 16 to 32 bit conversion
+    return static_cast<T&>(*this);
+  }

+  T& setClientId(const char* clientId) {
+    _clientId = clientId;
+    return static_cast<T&>(*this);
+  }
+
+  T& setCleanSession(bool cleanSession) {
+    _cleanSession = cleanSession;
+    return static_cast<T&>(*this);
+  }
+
+  T& setCredentials(const char* username, const char* password) {
+    _username = username;
+    _password = password;
+    return static_cast<T&>(*this);
+  }
+
+  T& setWill(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length) {
+    _willTopic = topic;
+    _willQos = qos;
+    _willRetain = retain;
+    _willPayload = payload;
+    if (!_willPayload) {
+      _willPayloadLength = 0;
+    } else {
+      _willPayloadLength = length;
    }
+    return static_cast<T&>(*this);
+  }

-    void setClientId(const char* clientId) {
-        _clientId = clientId;
+  T& setWill(const char* topic, uint8_t qos, bool retain, const char* payload) {
+    return setWill(topic, qos, retain, reinterpret_cast<const uint8_t*>(payload), strlen(payload));
+  }

-    }
+  T& setServer(IPAddress ip, uint16_t port) {
+    _ip = ip;
+    _port = port;
+    _useIp = true;
+    return static_cast<T&>(*this);
+  }

-    void setCleanSession(bool cleanSession) {
-        _cleanSession = cleanSession;
+  T& setServer(const char* host, uint16_t port) {
+    _host = host;
+    _port = port;
+    _useIp = false;
+    return static_cast<T&>(*this);
+  }

-    }
+  T& onConnect(espMqttClientTypes::OnConnectCallback callback) {
+    _onConnectCallback = callback;
+    return static_cast<T&>(*this);
+  }

-    void setCredentials(const char* username, const char* password) {
-        _username = username;
-        _password = password;
+  T& onDisconnect(espMqttClientTypes::OnDisconnectCallback callback) {
+    _onDisconnectCallback = callback;
+    return static_cast<T&>(*this);
+  }

-    }
+  T& onSubscribe(espMqttClientTypes::OnSubscribeCallback callback) {
+    _onSubscribeCallback = callback;
+    return static_cast<T&>(*this);
+  }

-    void setWill(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length) {
-        _willTopic = topic;
-        _willQos = qos;
-        _willRetain = retain;
-        _willPayload = payload;
-        if (!_willPayload) {
-            _willPayloadLength = 0;
-        } else {
-            _willPayloadLength = length;
-        }
+  T& onUnsubscribe(espMqttClientTypes::OnUnsubscribeCallback callback) {
+    _onUnsubscribeCallback = callback;
+    return static_cast<T&>(*this);
+  }

-    }
+  T& onMessage(espMqttClientTypes::OnMessageCallback callback) {
+    _onMessageCallback = callback;
+    return static_cast<T&>(*this);
+  }

-    void setWill(const char* topic, uint8_t qos, bool retain, const char* payload) {
-        return setWill(topic, qos, retain, reinterpret_cast<const uint8_t*>(payload), strlen(payload));
-    }
+  T& onPublish(espMqttClientTypes::OnPublishCallback callback) {
+    _onPublishCallback = callback;
+    return static_cast<T&>(*this);
+  }

-    void setServer(IPAddress ip, uint16_t port) {
-        _ip = ip;
-        _port = port;
-        _useIp = true;
+  /*
+  T& onError(espMqttClientTypes::OnErrorCallback callback) {
+    _onErrorCallback = callback;
+    return static_cast<T&>(*this);
+  }
+  */

-    }
-
-    void setServer(const char* host, uint16_t port) {
-        _host = host;
-        _port = port;
-        _useIp = false;
-
-    }
-
-    void onConnect(espMqttClientTypes::OnConnectCallback callback) {
-        _onConnectCallback = callback;
-
-    }
-
-    void onDisconnect(espMqttClientTypes::OnDisconnectCallback callback) {
-        _onDisconnectCallback = callback;
-
-    }
-
-    void onSubscribe(espMqttClientTypes::OnSubscribeCallback callback) {
-        _onSubscribeCallback = callback;
-
-    }
-
-    void onUnsubscribe(espMqttClientTypes::OnUnsubscribeCallback callback) {
-        _onUnsubscribeCallback = callback;
-
-    }
-
-    void onMessage(espMqttClientTypes::OnMessageCallback callback) {
-        _onMessageCallback = callback;
-
-    }
-
-    void onPublish(espMqttClientTypes::OnPublishCallback callback) {
-        _onPublishCallback = callback;
-
-    }
-
-    /*
-    void onError(espMqttClientTypes::OnErrorCallback callback) {
-      _onErrorCallback = callback;
-
-    }
-    */
-
-protected:
+ protected:
 #if defined(ESP32)
-    explicit MqttClientSetup(bool useTask, uint8_t priority = 1, uint8_t core = 1)
-            : MqttClient(useTask, priority, core) {}
+  explicit MqttClientSetup(bool useTask, uint8_t priority = 1, uint8_t core = 1)
+  : MqttClient(useTask, priority, core) {}
 #else
-    MqttClientSetup()
+  MqttClientSetup()
  : MqttClient() {}
 #endif
 };
--- a/lib/espMqttClient/src/Transport/ClientSecureSync.cpp
+++ b/lib/espMqttClient/src/Transport/ClientSecureSync.cpp
@@ -13,61 +13,61 @@ the LICENSE file.

 namespace espMqttClientInternals {

-ClientSecureSync::ClientSecureSync(WiFiClientSecure* wiFiClient)
-: client(wiFiClient) {
+ClientSecureSync::ClientSecureSync()
+: client() {
  // empty
 }

 bool ClientSecureSync::connect(IPAddress ip, uint16_t port) {
-  bool ret = client->connect(ip, port);  // implicit conversion of return code int --> bool
+  bool ret = client.connect(ip, port);  // implicit conversion of return code int --> bool
  if (ret) {
    #if defined(ARDUINO_ARCH_ESP8266)
-    client->setNoDelay(true);
+    client.setNoDelay(true);
    #elif defined(ARDUINO_ARCH_ESP32)
    // Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure
    int val = true;
-    client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
+    client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
    #endif
  }
  return ret;
 }

 bool ClientSecureSync::connect(const char* host, uint16_t port) {
-  bool ret = client->connect(host, port);  // implicit conversion of return code int --> bool
+  bool ret = client.connect(host, port);  // implicit conversion of return code int --> bool
  if (ret) {
    #if defined(ARDUINO_ARCH_ESP8266)
-    client->setNoDelay(true);
+    client.setNoDelay(true);
    #elif defined(ARDUINO_ARCH_ESP32)
    // Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure
    int val = true;
-    client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
+    client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
    #endif
  }
  return ret;
 }

 size_t ClientSecureSync::write(const uint8_t* buf, size_t size) {
-  return client->write(buf, size);
+  return client.write(buf, size);
 }

 int ClientSecureSync::available() {
-  return client->available();
+  return client.available();
 }

 int ClientSecureSync::read(uint8_t* buf, size_t size) {
-  return client->read(buf, size);
+  return client.read(buf, size);
 }

 void ClientSecureSync::stop() {
-  client->stop();
+  client.stop();
 }

 bool ClientSecureSync::connected() {
-  return client->connected();
+  return client.connected();
 }

 bool ClientSecureSync::disconnected() {
-  return !client->connected();
+  return !client.connected();
 }

 }  // namespace espMqttClientInternals
--- a/lib/espMqttClient/src/Transport/ClientSecureSync.h
+++ b/lib/espMqttClient/src/Transport/ClientSecureSync.h
@@ -18,7 +18,7 @@ namespace espMqttClientInternals {

 class ClientSecureSync : public Transport {
 public:
-  ClientSecureSync(WiFiClientSecure* wiFiClient);
+  ClientSecureSync();
  bool connect(IPAddress ip, uint16_t port) override;
  bool connect(const char* host, uint16_t port) override;
  size_t write(const uint8_t* buf, size_t size) override;
@@ -27,7 +27,7 @@ class ClientSecureSync : public Transport {
  void stop() override;
  bool connected() override;
  bool disconnected() override;
-  WiFiClientSecure* client;
+  WiFiClientSecure client;
 };

 }  // namespace espMqttClientInternals
--- a/lib/espMqttClient/src/Transport/ClientSync.cpp
+++ b/lib/espMqttClient/src/Transport/ClientSync.cpp
@@ -13,61 +13,61 @@ the LICENSE file.

 namespace espMqttClientInternals {

-ClientSync::ClientSync(WiFiClient* wiFiClient)
-: client(wiFiClient) {
+ClientSync::ClientSync()
+: client() {
  // empty
 }

 bool ClientSync::connect(IPAddress ip, uint16_t port) {
-  bool ret = client->connect(ip, port);  // implicit conversion of return code int --> bool
+  bool ret = client.connect(ip, port);  // implicit conversion of return code int --> bool
  if (ret) {
    #if defined(ARDUINO_ARCH_ESP8266)
-    client->setNoDelay(true);
+    client.setNoDelay(true);
    #elif defined(ARDUINO_ARCH_ESP32)
    // Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
    int val = true;
-    client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
+    client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
    #endif
  }
  return ret;
 }

 bool ClientSync::connect(const char* host, uint16_t port) {
-  bool ret = client->connect(host, port);  // implicit conversion of return code int --> bool
+  bool ret = client.connect(host, port);  // implicit conversion of return code int --> bool
  if (ret) {
    #if defined(ARDUINO_ARCH_ESP8266)
-    client->setNoDelay(true);
+    client.setNoDelay(true);
    #elif defined(ARDUINO_ARCH_ESP32)
    // Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
    int val = true;
-    client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
+    client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
    #endif
  }
  return ret;
 }

 size_t ClientSync::write(const uint8_t* buf, size_t size) {
-  return client->write(buf, size);
+  return client.write(buf, size);
 }

 int ClientSync::available() {
-  return client->available();
+  return client.available();
 }

 int ClientSync::read(uint8_t* buf, size_t size) {
-  return client->read(buf, size);
+  return client.read(buf, size);
 }

 void ClientSync::stop() {
-  client->stop();
+  client.stop();
 }

 bool ClientSync::connected() {
-  return client->connected();
+  return client.connected();
 }

 bool ClientSync::disconnected() {
-  return !client->connected();
+  return !client.connected();
 }

 }  // namespace espMqttClientInternals
--- a/lib/espMqttClient/src/Transport/ClientSync.h
+++ b/lib/espMqttClient/src/Transport/ClientSync.h
@@ -18,7 +18,7 @@ namespace espMqttClientInternals {

 class ClientSync : public Transport {
 public:
-  ClientSync(WiFiClient* wiFiClient);
+  ClientSync();
  bool connect(IPAddress ip, uint16_t port) override;
  bool connect(const char* host, uint16_t port) override;
  size_t write(const uint8_t* buf, size_t size) override;
@@ -27,7 +27,7 @@ class ClientSync : public Transport {
  void stop() override;
  bool connected() override;
  bool disconnected() override;
-  WiFiClient* client;
+  WiFiClient client;
 };

 }  // namespace espMqttClientInternals
--- a/lib/espMqttClient/src/espMqttClient.cpp
+++ b/lib/espMqttClient/src/espMqttClient.cpp
@@ -9,9 +9,9 @@ the LICENSE file.
 #include "espMqttClient.h"

 #if defined(ARDUINO_ARCH_ESP32)
-espMqttClient::espMqttClient(WiFiClient* wiFiClient, uint8_t priority, uint8_t core)
+espMqttClient::espMqttClient(uint8_t priority, uint8_t core)
 : MqttClientSetup(true, priority, core)
-, _client(wiFiClient) {
+, _client() {
 #else
 espMqttClient::espMqttClient()
 : _client() {
@@ -21,9 +21,9 @@ espMqttClient::espMqttClient()

 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
 #if defined(ARDUINO_ARCH_ESP32)
-espMqttClientSecure::espMqttClientSecure(WiFiClientSecure* wiFiClient, uint8_t priority, uint8_t core)
+espMqttClientSecure::espMqttClientSecure(uint8_t priority, uint8_t core)
 : MqttClientSetup(priority, core)
-, _client(wiFiClient) {
+, _client() {
 #else
 espMqttClientSecure::espMqttClientSecure()
 : _client() {
@@ -32,66 +32,55 @@ espMqttClientSecure::espMqttClientSecure()
 }

 espMqttClientSecure& espMqttClientSecure::setInsecure() {
-  _client.client->setInsecure();
+  _client.client.setInsecure();
  return *this;
 }

 #if defined(ARDUINO_ARCH_ESP32)
 espMqttClientSecure& espMqttClientSecure::setCACert(const char* rootCA) {
-  _client.client->setCACert(rootCA);
+  _client.client.setCACert(rootCA);
  return *this;
 }

 espMqttClientSecure& espMqttClientSecure::setCertificate(const char* clientCa) {
-  _client.client->setCertificate(clientCa);
+  _client.client.setCertificate(clientCa);
  return *this;
 }

 espMqttClientSecure& espMqttClientSecure::setPrivateKey(const char* privateKey) {
-  _client.client->setPrivateKey(privateKey);
+  _client.client.setPrivateKey(privateKey);
  return *this;
 }

 espMqttClientSecure& espMqttClientSecure::setPreSharedKey(const char* pskIdent, const char* psKey) {
-  _client.client->setPreSharedKey(pskIdent, psKey);
+  _client.client.setPreSharedKey(pskIdent, psKey);
  return *this;
 }
 #elif defined(ARDUINO_ARCH_ESP8266)
 espMqttClientSecure& espMqttClientSecure::setFingerprint(const uint8_t fingerprint[20]) {
-  _client.client->setFingerprint(fingerprint);
+  _client.client.setFingerprint(fingerprint);
  return *this;
 }

 espMqttClientSecure& espMqttClientSecure::setTrustAnchors(const X509List *ta) {
-  _client.client->setTrustAnchors(ta);
+  _client.client.setTrustAnchors(ta);
  return *this;
 }

 espMqttClientSecure& espMqttClientSecure::setClientRSACert(const X509List *cert, const PrivateKey *sk) {
-  _client.client->setClientRSACert(cert, sk);
+  _client.client.setClientRSACert(cert, sk);
  return *this;
 }

 espMqttClientSecure& espMqttClientSecure::setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type) {
-  _client.client->setClientECCert(cert, sk, allowed_usages, cert_issuer_key_type);
+  _client.client.setClientECCert(cert, sk, allowed_usages, cert_issuer_key_type);
  return *this;
 }

 espMqttClientSecure& espMqttClientSecure::setCertStore(CertStoreBase *certStore) {
-  _client.client->setCertStore(certStore);
+  _client.client.setCertStore(certStore);
  return *this;
 }
 #endif

 #endif
-
-#if defined(ARDUINO_ARCH_ESP32)
-espMqttClientEthernet::espMqttClientEthernet(EthernetClient* ethernetClient, uint8_t priority, uint8_t core)
-        : MqttClientSetup(true, priority, core)
-        , _client(ethernetClient) {
-#else
-    espMqttClientEthernet::espMqttClientEthernet()
-: _client() {
-#endif
-    _transport = &_client;
-}
--- a/lib/espMqttClient/src/espMqttClient.h
+++ b/lib/espMqttClient/src/espMqttClient.h
@@ -19,64 +19,47 @@ the LICENSE file.
 #endif

 #include "MqttClientSetup.h"
-#include "Transport/ClientSyncEthernet.h"

-class espMqttClient : public MqttClientSetup {
-public:
+class espMqttClient : public MqttClientSetup<espMqttClient> {
+ public:
 #if defined(ARDUINO_ARCH_ESP32)
-    explicit espMqttClient(WiFiClient* wiFiClient, uint8_t priority = 1, uint8_t core = 1);
+  explicit espMqttClient(uint8_t priority = 1, uint8_t core = 1);
 #else
-    espMqttClient();
+  espMqttClient();
 #endif

-protected:
+ protected:
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-    espMqttClientInternals::ClientSync _client;
+  espMqttClientInternals::ClientSync _client;
 #elif defined(__linux__)
-    espMqttClientInternals::ClientPosix _client;
+  espMqttClientInternals::ClientPosix _client;
 #endif
 };

 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-class espMqttClientSecure : public MqttClientSetup {
-public:
-#if defined(ARDUINO_ARCH_ESP32)
-    explicit espMqttClientSecure(WiFiClientSecure* wiFiClient, uint8_t priority = 1, uint8_t core = 1);
-#else
-    espMqttClientSecure();
-#endif
-    espMqttClientSecure& setInsecure();
-#if defined(ARDUINO_ARCH_ESP32)
-    espMqttClientSecure& setCACert(const char* rootCA);
-    espMqttClientSecure& setCertificate(const char* clientCa);
-    espMqttClientSecure& setPrivateKey(const char* privateKey);
-    espMqttClientSecure& setPreSharedKey(const char* pskIdent, const char* psKey);
-#else
-    espMqttClientSecure& setFingerprint(const uint8_t fingerprint[20]);
+class espMqttClientSecure : public MqttClientSetup<espMqttClientSecure> {
+ public:
+  #if defined(ARDUINO_ARCH_ESP32)
+  explicit espMqttClientSecure(uint8_t priority = 1, uint8_t core = 1);
+  #else
+  espMqttClientSecure();
+  #endif
+  espMqttClientSecure& setInsecure();
+  #if defined(ARDUINO_ARCH_ESP32)
+  espMqttClientSecure& setCACert(const char* rootCA);
+  espMqttClientSecure& setCertificate(const char* clientCa);
+  espMqttClientSecure& setPrivateKey(const char* privateKey);
+  espMqttClientSecure& setPreSharedKey(const char* pskIdent, const char* psKey);
+  #else
+  espMqttClientSecure& setFingerprint(const uint8_t fingerprint[20]);
  espMqttClientSecure& setTrustAnchors(const X509List *ta);
  espMqttClientSecure& setClientRSACert(const X509List *cert, const PrivateKey *sk);
  espMqttClientSecure& setClientECCert(const X509List *cert, const PrivateKey *sk, unsigned allowed_usages, unsigned cert_issuer_key_type);
  espMqttClientSecure& setCertStore(CertStoreBase *certStore);
-#endif
+  #endif

-protected:
-    espMqttClientInternals::ClientSecureSync _client;
-};
-
-class espMqttClientEthernet : public MqttClientSetup {
-public:
-#if defined(ARDUINO_ARCH_ESP32)
-    explicit espMqttClientEthernet(EthernetClient* ethernetClient, uint8_t priority = 1, uint8_t core = 1);
-#else
-    espMqttClient();
-#endif
-
-protected:
-#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-    espMqttClientInternals::ClientSyncEthernet _client;
-#elif defined(__linux__)
-    espMqttClientInternals::ClientPosix _client;
-#endif
+ protected:
+  espMqttClientInternals::ClientSecureSync _client;
 };

 #endif
--- a/lib/espMqttClient/src/espMqttClientAsync.h
+++ b/lib/espMqttClient/src/espMqttClientAsync.h
@@ -17,7 +17,7 @@ the LICENSE file.

 #include "MqttClientSetup.h"

-class espMqttClientAsync : public MqttClientSetup {
+class espMqttClientAsync : public MqttClientSetup<espMqttClientAsync> {
 public:
 #if defined(ARDUINO_ARCH_ESP32)
  explicit espMqttClientAsync(uint8_t priority = 1, uint8_t core = 1);
--- a/lib/espMqttClient/src/Transport/ClientSyncEthernet.cpp
+++ b/lib/espMqttClient/src/Transport/ClientSyncEthernet.cpp
@@ -13,65 +13,65 @@ the LICENSE file.

 namespace espMqttClientInternals {

-    ClientSyncEthernet::ClientSyncEthernet(EthernetClient* ethernetClient)
-            : client(ethernetClient) {
+    ClientSyncEthernet::ClientSyncEthernet()
+            : client() {
        // empty
    }

    bool ClientSyncEthernet::connect(IPAddress ip, uint16_t port) {
-        bool ret = client->connect(ip, port);  // implicit conversion of return code int --> bool
+        bool ret = client.connect(ip, port);  // implicit conversion of return code int --> bool
        if (ret) {
 #if defined(ARDUINO_ARCH_ESP8266)
-            client->setNoDelay(true);
+            client.setNoDelay(true);
 #elif defined(ARDUINO_ARCH_ESP32)
            // Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
            int val = true;

            // TODO
-//            client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
+//            client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
 #endif
        }
        return ret;
    }

    bool ClientSyncEthernet::connect(const char* host, uint16_t port) {
-        bool ret = client->connect(host, port);  // implicit conversion of return code int --> bool
+        bool ret = client.connect(host, port);  // implicit conversion of return code int --> bool
        if (ret) {
 #if defined(ARDUINO_ARCH_ESP8266)
-            client->setNoDelay(true);
+            client.setNoDelay(true);
 #elif defined(ARDUINO_ARCH_ESP32)
            // Set TCP option directly to bypass lack of working setNoDelay for WiFiClientSecure (for consistency also here)
            int val = true;

            // TODO
-//            client->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
+//            client.setSocketOption(IPPROTO_TCP, TCP_NODELAY, &val, sizeof(int));
 #endif
        }
        return ret;
    }

    size_t ClientSyncEthernet::write(const uint8_t* buf, size_t size) {
-        return client->write(buf, size);
+        return client.write(buf, size);
    }

    int ClientSyncEthernet::available() {
-        return client->available();
+        return client.available();
    }

    int ClientSyncEthernet::read(uint8_t* buf, size_t size) {
-        return client->read(buf, size);
+        return client.read(buf, size);
    }

    void ClientSyncEthernet::stop() {
-        client->stop();
+        client.stop();
    }

    bool ClientSyncEthernet::connected() {
-        return client->connected();
+        return client.connected();
    }

    bool ClientSyncEthernet::disconnected() {
-        return !client->connected();
+        return !client.connected();
    }

 }  // namespace espMqttClientInternals
--- a/lib/espMqttClient/src/Transport/ClientSyncEthernet.h
+++ b/lib/espMqttClient/src/Transport/ClientSyncEthernet.h
@@ -2,14 +2,14 @@

 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)

-#include "Transport.h"
+#include "Transport/Transport.h"
 #include "EthernetClient.h"

 namespace espMqttClientInternals {

    class ClientSyncEthernet : public Transport {
    public:
-        ClientSyncEthernet(EthernetClient* ethernetClient);
+        ClientSyncEthernet();
        bool connect(IPAddress ip, uint16_t port) override;
        bool connect(const char* host, uint16_t port) override;
        size_t write(const uint8_t* buf, size_t size) override;
@@ -18,7 +18,7 @@ namespace espMqttClientInternals {
        void stop() override;
        bool connected() override;
        bool disconnected() override;
-        EthernetClient* client;
+        EthernetClient client;
    };

 }  // namespace espMqttClientInternals
--- a/networkDevices/NetworkDevice.h
+++ b/networkDevices/NetworkDevice.h
@@ -17,8 +17,6 @@ public:
    : _hostname(hostname)
    {}

-    virtual MqttClientSetup* mqttClient() = 0;
-
    virtual void initialize() = 0;
    virtual ReconnectStatus reconnect() = 0;
    virtual void reconfigure() = 0;
@@ -29,6 +27,17 @@ public:
    virtual bool isConnected() = 0;
    virtual int8_t signalStrength() = 0;

+    virtual void mqttSetClientId(const char* clientId) = 0;
+    virtual void mqttSetCleanSession(bool cleanSession) = 0;
+    virtual uint16_t mqttPublish(const char* topic, uint8_t qos, bool retain, const char* payload) = 0;
+    virtual uint16_t mqttPublish(const char* topic, uint8_t qos, bool retain, const uint8_t* payload, size_t length) = 0;
+    virtual bool mqttConnected() const = 0;
+    virtual void mqttSetServer(const char* host, uint16_t port) = 0;
+    virtual bool mqttConnect() = 0;
+    virtual void mqttSetCredentials(const char* username, const char* password) = 0;
+    virtual void mqttOnMessage(espMqttClientTypes::OnMessageCallback callback) = 0;
+    virtual uint16_t mqttSubscribe(const char* topic, uint8_t qos) = 0;
+
 protected:
    const uint16_t _mqttMaxBufferSize = 6144;
    const String _hostname;
--- a/networkDevices/W5500Device.cpp
+++ b/networkDevices/W5500Device.cpp
@@ -38,8 +38,6 @@ void W5500Device::initialize()
    resetDevice();

    Ethernet.init(ETHERNET_CS_PIN);
-    _ethClient = new EthernetClient();
-    _mqttClient = new espMqttClientEthernet(_ethClient);

    if(_preferences->getBool(preference_mqtt_log_enabled))
    {
@@ -49,7 +47,7 @@ void W5500Device::initialize()
        String pathStr = _preferences->getString(preference_mqtt_lock_path);
        pathStr.concat(mqtt_topic_log);
        strcpy(_path, pathStr.c_str());
-        Log = new MqttLogger(*_mqttClient, _path, MqttLoggerMode::MqttAndSerial);
+        Log = new MqttLogger(this, _path, MqttLoggerMode::MqttAndSerial);
    }

    reconnect();
@@ -185,8 +183,52 @@ int8_t W5500Device::signalStrength()
    return 127;
 }

-MqttClientSetup *W5500Device::mqttClient()
+void W5500Device::mqttSetClientId(const char *clientId)
 {
-    return _mqttClient;
+    _mqttClient.setClientId(clientId);
 }

+void W5500Device::mqttSetCleanSession(bool cleanSession)
+{
+    _mqttClient.setCleanSession(cleanSession);
+}
+
+uint16_t W5500Device::mqttPublish(const char *topic, uint8_t qos, bool retain, const char *payload)
+{
+    return _mqttClient.publish(topic, qos, retain, payload);
+}
+
+bool W5500Device::mqttConnected() const
+{
+    return _mqttClient.connected();
+}
+
+void W5500Device::mqttSetServer(const char *host, uint16_t port)
+{
+    _mqttClient.setServer(host, port);
+}
+
+bool W5500Device::mqttConnect()
+{
+    return _mqttClient.connect();
+}
+
+void W5500Device::mqttSetCredentials(const char *username, const char *password)
+{
+    _mqttClient.setCredentials(username, password);
+}
+
+void W5500Device::mqttOnMessage(espMqttClientTypes::OnMessageCallback callback)
+{
+    _mqttClient.onMessage(callback);
+}
+
+uint16_t W5500Device::mqttSubscribe(const char *topic, uint8_t qos)
+{
+    return _mqttClient.subscribe(topic, qos);
+}
+
+uint16_t W5500Device::mqttPublish(const char *topic, uint8_t qos, bool retain, const uint8_t *payload, size_t length)
+{
+    return _mqttClient.publish(topic, qos, retain, payload, length);
+}
--- a/networkDevices/W5500Device.h
+++ b/networkDevices/W5500Device.h
@@ -2,6 +2,7 @@

 #include "NetworkDevice.h"
 #include "espMqttClient.h"
+#include "espMqttClientEthernet.h"
 #include <Ethernet.h>
 #include <Preferences.h>

@@ -22,14 +23,31 @@ public:

    int8_t signalStrength() override;

-    virtual MqttClientSetup* mqttClient();
+    void mqttSetClientId(const char *clientId) override;
+
+    void mqttSetCleanSession(bool cleanSession) override;
+
+    uint16_t mqttPublish(const char *topic, uint8_t qos, bool retain, const char *payload) override;
+
+    uint16_t mqttPublish(const char *topic, uint8_t qos, bool retain, const uint8_t *payload, size_t length) override;
+
+    bool mqttConnected() const override;
+
+    void mqttSetServer(const char *host, uint16_t port) override;
+
+    bool mqttConnect() override;
+
+    void mqttSetCredentials(const char *username, const char *password) override;
+
+    void mqttOnMessage(espMqttClientTypes::OnMessageCallback callback) override;
+
+    uint16_t mqttSubscribe(const char *topic, uint8_t qos) override;

 private:
    void resetDevice();
    void initializeMacAddress(byte* mac);

-    EthernetClient* _ethClient = nullptr;
-    MqttClientSetup* _mqttClient = nullptr;
+    espMqttClientEthernet _mqttClient;
    Preferences* _preferences = nullptr;

    int _maintainResult = 0;
--- a/networkDevices/WifiDevice.cpp
+++ b/networkDevices/WifiDevice.cpp
@@ -18,26 +18,26 @@ WifiDevice::WifiDevice(const String& hostname, Preferences* _preferences)
    size_t crtLength = _preferences->getString(preference_mqtt_crt,_cert,TLS_CERT_MAX_SIZE);
    size_t keyLength = _preferences->getString(preference_mqtt_key,_key,TLS_KEY_MAX_SIZE);

-    if(caLength > 1) // length is 1 when empty
+    _useEncryption = caLength > 1;
+
+    if(_useEncryption > 1) // length is 1 when empty
    {
        Log->println(F("MQTT over TLS."));
        Log->println(_ca);
-        _wifiClientSecure = new WiFiClientSecure();
-        _wifiClientSecure->setCACert(_ca);
+        _mqttClientSecure = new espMqttClientSecure();
+        _mqttClientSecure->setCACert(_ca);
        if(crtLength > 1 && keyLength > 1) // length is 1 when empty
        {
            Log->println(F("MQTT with client certificate."));
            Log->println(_cert);
            Log->println(_key);
-            _wifiClientSecure->setCertificate(_cert);
-            _wifiClientSecure->setPrivateKey(_key);
+            _mqttClientSecure->setCertificate(_cert);
+            _mqttClientSecure->setPrivateKey(_key);
        }
-        _mqttClient = new espMqttClientSecure(_wifiClientSecure);
    } else
    {
        Log->println(F("MQTT without TLS."));
-        _wifiClient = new WiFiClient();
-        _mqttClient = new espMqttClient(_wifiClient);
+        _mqttClient = new espMqttClient();
    }

    if(_preferences->getBool(preference_mqtt_log_enabled))
@@ -48,7 +48,7 @@ WifiDevice::WifiDevice(const String& hostname, Preferences* _preferences)
        String pathStr = _preferences->getString(preference_mqtt_lock_path);
        pathStr.concat(mqtt_topic_log);
        strcpy(_path, pathStr.c_str());
-        Log = new MqttLogger(*_mqttClient, _path, MqttLoggerMode::MqttAndSerial);
+        Log = new MqttLogger(this, _path, MqttLoggerMode::MqttAndSerial);
    }
 }

@@ -108,12 +108,12 @@ void WifiDevice::reconfigure()

 void WifiDevice::printError()
 {
-    if(_wifiClientSecure != nullptr)
-    {
-        char lastError[100];
-        _wifiClientSecure->lastError(lastError,100);
-        Log->println(lastError);
-    }
+//    if(_wifiClientSecure != nullptr)
+//    {
+//        char lastError[100];
+//        _wifiClientSecure->lastError(lastError,100);
+//        Log->println(lastError);
+//    }
    Log->print(F("Free Heap: "));
    Log->println(ESP.getFreeHeap());
 }
@@ -152,7 +152,122 @@ void WifiDevice::clearRtcInitVar(WiFiManager *)
    memset(WiFiDevice_reconfdetect, 0, sizeof WiFiDevice_reconfdetect);
 }

-MqttClientSetup *WifiDevice::mqttClient()
+void WifiDevice::mqttSetClientId(const char *clientId)
 {
-    return _mqttClient;
+    if(_useEncryption)
+    {
+        _mqttClientSecure->setClientId(clientId);
+    }
+    else
+    {
+        _mqttClient->setClientId(clientId);
+    }
+}
+
+void WifiDevice::mqttSetCleanSession(bool cleanSession)
+{
+    if(_useEncryption)
+    {
+        _mqttClientSecure->setCleanSession(cleanSession);
+    }
+    else
+    {
+        _mqttClient->setCleanSession(cleanSession);
+    }
+}
+
+uint16_t WifiDevice::mqttPublish(const char *topic, uint8_t qos, bool retain, const char *payload)
+{
+    if(_useEncryption)
+    {
+        return _mqttClientSecure->publish(topic, qos, retain, payload);
+    }
+    else
+    {
+        return _mqttClient->publish(topic, qos, retain, payload);
+    }
+}
+
+uint16_t WifiDevice::mqttPublish(const char *topic, uint8_t qos, bool retain, const uint8_t *payload, size_t length)
+{
+    if(_useEncryption)
+    {
+        return _mqttClientSecure->publish(topic, qos, retain, payload, length);
+    }
+    else
+    {
+        return _mqttClient->publish(topic, qos, retain, payload, length);
+    }
+}
+
+bool WifiDevice::mqttConnected() const
+{
+    if(_useEncryption)
+    {
+        return _mqttClientSecure->connected();
+    }
+    else
+    {
+        return _mqttClient->connected();
+    }
+}
+
+void WifiDevice::mqttSetServer(const char *host, uint16_t port)
+{
+    if(_useEncryption)
+    {
+        _mqttClientSecure->setServer(host, port);
+    }
+    else
+    {
+        _mqttClient->setServer(host, port);
+    }
+}
+
+bool WifiDevice::mqttConnect()
+{
+    if(_useEncryption)
+    {
+        return _mqttClientSecure->connect();
+    }
+    else
+    {
+        return _mqttClient->connect();
+    }
+}
+
+void WifiDevice::mqttSetCredentials(const char *username, const char *password)
+{
+    if(_useEncryption)
+    {
+        _mqttClientSecure->setCredentials(username, password);
+    }
+    else
+    {
+        _mqttClient->setCredentials(username, password);
+    }
+}
+
+void WifiDevice::mqttOnMessage(espMqttClientTypes::OnMessageCallback callback)
+{
+    if(_useEncryption)
+    {
+        _mqttClientSecure->onMessage(callback);
+    }
+    else
+    {
+        _mqttClient->onMessage(callback);
+    }
+}
+
+uint16_t WifiDevice::mqttSubscribe(const char *topic, uint8_t qos)
+{
+    if(_useEncryption)
+    {
+        return _mqttClientSecure->subscribe(topic, qos);
+    }
+    else
+    {
+        return _mqttClient->subscribe(topic, qos);
+    }
 }
--- a/networkDevices/WifiDevice.h
+++ b/networkDevices/WifiDevice.h
@@ -5,6 +5,7 @@
 #include <Preferences.h>
 #include "NetworkDevice.h"
 #include "WiFiManager.h"
+#include "espMqttClient.h"

 class WifiDevice : public NetworkDevice
 {
@@ -22,7 +23,25 @@ public:

    int8_t signalStrength() override;

-    MqttClientSetup *mqttClient() override;
+    void mqttSetClientId(const char *clientId) override;
+
+    void mqttSetCleanSession(bool cleanSession) override;
+
+    uint16_t mqttPublish(const char *topic, uint8_t qos, bool retain, const char *payload) override;
+
+    uint16_t mqttPublish(const char *topic, uint8_t qos, bool retain, const uint8_t *payload, size_t length) override;
+
+    bool mqttConnected() const override;
+
+    void mqttSetServer(const char *host, uint16_t port) override;
+
+    bool mqttConnect() override;
+
+    void mqttSetCredentials(const char *username, const char *password) override;
+
+    void mqttOnMessage(espMqttClientTypes::OnMessageCallback callback) override;
+
+    uint16_t mqttSubscribe(const char *topic, uint8_t qos) override;

 private:
    static void clearRtcInitVar(WiFiManager*);
@@ -30,13 +49,13 @@ private:
    void onDisconnected();

    WiFiManager _wm;
-    WiFiClient* _wifiClient = nullptr;
-    WiFiClientSecure* _wifiClientSecure = nullptr;
-    MqttClientSetup* _mqttClient = nullptr;
-//    SpiffsCookie _cookie;
+    espMqttClient* _mqttClient = nullptr;
+    espMqttClientSecure* _mqttClientSecure = nullptr;
+
    bool _restartOnDisconnect = false;
    bool _startAp = false;
    char* _path;
+    bool _useEncryption = false;

    char _ca[TLS_CA_MAX_SIZE];
    char _cert[TLS_CERT_MAX_SIZE];
--- a/networkDevices/espMqttClientEthernet.cpp
+++ b/networkDevices/espMqttClientEthernet.cpp
@@ -0,0 +1,8 @@
+#include "espMqttClientEthernet.h"
+
+espMqttClientEthernet::espMqttClientEthernet(uint8_t priority, uint8_t core)
+: MqttClientSetup(true, priority, core),
+  _client()
+{
+    _transport = &_client;
+}
--- a/networkDevices/espMqttClientEthernet.h
+++ b/networkDevices/espMqttClientEthernet.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "MqttClientSetup.h"
+#include "ClientSyncEthernet.h"
+
+class espMqttClientEthernet : public MqttClientSetup<espMqttClientEthernet> {
+public:
+#if defined(ARDUINO_ARCH_ESP32)
+    explicit espMqttClientEthernet(uint8_t priority = 1, uint8_t core = 1);
+#else
+    espMqttClient();
+#endif
+
+protected:
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+    espMqttClientInternals::ClientSyncEthernet _client;
+#elif defined(__linux__)
+    espMqttClientInternals::ClientPosix _client;
+#endif
+};