impr: monitor checks if connected before _read

impr: tcp_client protect flags and initialization methods
minor readability/optimization

Author: eigen-value

src/monitor.h

@@ -94,13 +94,12 @@ class BridgeMonitor: public Stream {
 
     int peek() override {
         k_mutex_lock(&monitor_mutex, K_FOREVER);
+        int out = -1;
         if (temp_buffer.available()) {
-            int c = temp_buffer.peek();
-            k_mutex_unlock(&monitor_mutex);
-            return c;
+            out = temp_buffer.peek();
         }
         k_mutex_unlock(&monitor_mutex);
-        return -1;
+        return out;
     }
 
     size_t write(uint8_t c) override {
@@ -117,11 +116,8 @@ class BridgeMonitor: public Stream {
 
         size_t written;
         const bool ret = bridge->call(MON_WRITE_METHOD, send_buffer).result(written);
-        if (ret) {
-            return written;
-        }
 
-        return 0;
+        return ret? written : 0;
     }
 
     bool reset() {
@@ -138,24 +134,23 @@ class BridgeMonitor: public Stream {
 
         if (size == 0) return;
 
+        k_mutex_lock(&monitor_mutex, K_FOREVER);
+
         MsgPack::arr_t<uint8_t> message;
         RpcResult async_rpc = bridge->call(MON_READ_METHOD, size);
-
-        const bool ret = async_rpc.result(message);
+        const bool ret = _connected && async_rpc.result(message);
 
         if (ret) {
-            k_mutex_lock(&monitor_mutex, K_FOREVER);
             for (size_t i = 0; i < message.size(); ++i) {
                 temp_buffer.store_char(static_cast<char>(message[i]));
             }
-            k_mutex_unlock(&monitor_mutex);
         }
 
         // if (async_rpc.error.code > NO_ERR) {
-        //     k_mutex_lock(&monitor_mutex, K_FOREVER);
         //     _connected = false;
-        //     k_mutex_unlock(&monitor_mutex);
         // }
+
+        k_mutex_unlock(&monitor_mutex);
     }
 
 };

src/tcp_client.h

@@ -55,73 +55,55 @@ class BridgeTCPClient : public Client {
 
     int connect(const char *host, uint16_t port) override {
 
-        if (_connected) return 0;
-
-        String hostname = host;
-
         k_mutex_lock(&client_mutex, K_FOREVER);
 
-        const bool resp = bridge->call(TCP_CONNECT_METHOD, hostname, port).result(connection_id);
-
-        if (!resp) {
-            _connected = false;
-            k_mutex_unlock(&client_mutex);
-            return -1;
-        }
-        _connected = true;
+        String hostname = host;
+        const bool ok = _connected || bridge->call(TCP_CONNECT_METHOD, hostname, port).result(connection_id);
+        _connected = ok;
 
         k_mutex_unlock(&client_mutex);
 
-        return 0;
+        return ok? 0 : -1;
     }
 
     int connectSSL(const char *host, uint16_t port, const char *ca_cert) {
 
-        if (_connected) return 0;
+        k_mutex_lock(&client_mutex, K_FOREVER);
 
         String hostname = host;
         String ca_cert_str = ca_cert;
 
-        k_mutex_lock(&client_mutex, K_FOREVER);
-
-        const bool resp = bridge->call(TCP_CONNECT_SSL_METHOD, hostname, port, ca_cert_str).result(connection_id);
-
-        if (!resp) {
-            _connected = false;
-            k_mutex_unlock(&client_mutex);
-            return -1;
-        }
-        _connected = true;
-
+        const bool ok = _connected || bridge->call(TCP_CONNECT_SSL_METHOD, hostname, port, ca_cert_str).result(connection_id);
+        _connected = ok;
         k_mutex_unlock(&client_mutex);
-        return 0;
+
+        return ok? 0 : -1;
     }
 
-    uint32_t getId() const {
-        return connection_id;
+    uint32_t getId() {
+        k_mutex_lock(&client_mutex, K_FOREVER);
+        const uint32_t out = connection_id;
+        k_mutex_unlock(&client_mutex);
+        return out;
     }
 
     size_t write(uint8_t c) override {
         return write(&c, 1);
     }
 
-    size_t write(const uint8_t *buf, size_t size) override {
+    size_t write(const uint8_t *buffer, size_t size) override {
 
-        if (!_connected) return 0;
+        if (!connected()) return 0;
 
         MsgPack::arr_t<uint8_t> payload;
 
         for (size_t i = 0; i < size; ++i) {
-            payload.push_back(buf[i]);
+            payload.push_back(buffer[i]);
         }
 
         size_t written;
-        const bool ret = bridge->call(TCP_WRITE_METHOD, connection_id, payload).result(written);
-        if (ret) {
-            return written;
-        }
-
-        return 0;
+        const bool ok = bridge->call(TCP_WRITE_METHOD, connection_id, payload).result(written);
+        return ok? written : 0;
     }
 
     int available() override {
@@ -151,12 +133,12 @@ class BridgeTCPClient : public Client {
 
     int peek() override {
         k_mutex_lock(&client_mutex, K_FOREVER);
+        int out = -1;
         if (temp_buffer.available()) {
-            k_mutex_unlock(&client_mutex);
-            return temp_buffer.peek();
+            out = temp_buffer.peek();
         }
         k_mutex_unlock(&client_mutex);
-        return -1;
+        return out;
     }
 
     void flush() override {
@@ -170,37 +152,35 @@ class BridgeTCPClient : public Client {
     void stop() override {
         k_mutex_lock(&client_mutex, K_FOREVER);
         String msg;
-        const bool resp = bridge->call(TCP_CLOSE_METHOD, connection_id).result(msg);
-        if (resp) {
-            _connected = false;
+        if (_connected) {
+            _connected = !bridge->call(TCP_CLOSE_METHOD, connection_id).result(msg);
         }
         k_mutex_unlock(&client_mutex);
     }
 
     uint8_t connected() override {
-        if (_connected) return 1;
-        return 0;
+        k_mutex_lock(&client_mutex, K_FOREVER);
+        const uint8_t out = _connected? 1 : 0;
+        k_mutex_unlock(&client_mutex);
+        return out;
     }
 
     operator bool() override {
         return available() || connected();
     }
 
-    //friend class BridgeTCPServer;
-
     using Print::write;
 
 private:
     void _read(size_t size) {
 
-        if (size == 0 || !_connected) return;
+        if (size == 0) return;
 
         k_mutex_lock(&client_mutex, K_FOREVER);
 
         MsgPack::arr_t<uint8_t> message;
         RpcResult async_rpc = bridge->call(TCP_READ_METHOD, connection_id, size);
-
-        const bool ret = async_rpc.result(message);
+        const bool ret = _connected && async_rpc.result(message);
 
         if (ret) {
             for (size_t i = 0; i < message.size(); ++i) {

src/tcp_server.h

@@ -91,13 +91,12 @@ class BridgeTCPServer final: public Server {
         if (!client) return 0;
 
         k_mutex_lock(&server_mutex, K_FOREVER);
+        size_t written = 0;
         if (_connected) {
-            size_t written = client.write(buf, size);
-            k_mutex_unlock(&server_mutex);
-            return written;
+            written = client.write(buf, size);
         }
         k_mutex_unlock(&server_mutex);
-        return 0;
+        return written;
     }
 
     void close() {