Settings validation

src/CatM1ConnectionHandler.cpp

@@ -22,23 +22,25 @@
  ******************************************************************************/
 
 CatM1ConnectionHandler::CatM1ConnectionHandler()
-: ConnectionHandler(true, NetworkAdapter::CATM1) { }
+: ConnectionHandler(true, NetworkAdapter::CATM1, true) { }
 
 CatM1ConnectionHandler::CatM1ConnectionHandler(
   const char * pin, const char * apn, const char * login, const char * pass,
   RadioAccessTechnologyType rat, uint32_t band, bool const keep_alive)
-: ConnectionHandler{keep_alive, NetworkAdapter::CATM1}
+: ConnectionHandler{keep_alive, NetworkAdapter::CATM1, true}
 {
   _settings.type = NetworkAdapter::CATM1;
   // To keep the backward compatibility, the user can call enableCheckInternetAvailability(false) for disabling the check
-  _check_internet_availability = true;
+  _flags.check_internet_availability = true;
   strncpy(_settings.catm1.pin, pin, sizeof(_settings.catm1.pin)-1);
   strncpy(_settings.catm1.apn, apn, sizeof(_settings.catm1.apn)-1);
   strncpy(_settings.catm1.login, login, sizeof(_settings.catm1.login)-1);
   strncpy(_settings.catm1.pass, pass, sizeof(_settings.catm1.pass)-1);
   _settings.catm1.rat  = static_cast<uint8_t>(rat);
   _settings.catm1.band = band;
   _reset = false;
+
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -90,7 +92,7 @@ NetworkConnectionState CatM1ConnectionHandler::update_handleConnecting()
     return NetworkConnectionState::DISCONNECTED;
   }
 
-  if(!_check_internet_availability){
+  if(!_flags.check_internet_availability){
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -130,7 +132,7 @@ NetworkConnectionState CatM1ConnectionHandler::update_handleDisconnecting()
 NetworkConnectionState CatM1ConnectionHandler::update_handleDisconnected()
 {
   GSM.end();
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }

src/CatM1ConnectionHandler.h

@@ -37,18 +37,18 @@ class CatM1ConnectionHandler : public ConnectionHandler
     CatM1ConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, RadioAccessTechnologyType rat = CATM1, uint32_t band = BAND_3 | BAND_20 | BAND_19, bool const keep_alive = true);
 
 
-    virtual unsigned long getTime() override;
-    virtual Client & getClient() override { return _gsm_client; };
-    virtual UDP & getUDP() override { return _gsm_udp; };
+    unsigned long getTime() override;
+    Client & getClient() override { return _gsm_client; };
+    UDP & getUDP() override { return _gsm_udp; };
 
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
 
   private:

src/CellularConnectionHandler.cpp

@@ -22,17 +22,18 @@
   CTOR/DTOR
  ******************************************************************************/
 CellularConnectionHandler::CellularConnectionHandler()
-: ConnectionHandler(true, NetworkAdapter::CELL) {}
+: ConnectionHandler(true, NetworkAdapter::CELL, true) { }
 
 CellularConnectionHandler::CellularConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive)
-: ConnectionHandler{keep_alive, NetworkAdapter::CELL}
+: ConnectionHandler{keep_alive, NetworkAdapter::CELL, true}
 {
   _settings.type = NetworkAdapter::CELL;
   strncpy(_settings.cell.pin, pin, sizeof(_settings.cell.pin)-1);
   strncpy(_settings.cell.apn, apn, sizeof(_settings.cell.apn)-1);
   strncpy(_settings.cell.login, login, sizeof(_settings.cell.login)-1);
   strncpy(_settings.cell.pass, pass, sizeof(_settings.cell.pass)-1);
 
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -77,7 +78,7 @@ NetworkConnectionState CellularConnectionHandler::update_handleConnecting()
     return NetworkConnectionState::INIT;
   }
 
-  if (!_check_internet_availability) {
+  if (!_flags.check_internet_availability) {
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -105,7 +106,7 @@ NetworkConnectionState CellularConnectionHandler::update_handleDisconnecting()
 
 NetworkConnectionState CellularConnectionHandler::update_handleDisconnected()
 {
-  if (_keep_alive) {
+  if (_flags.keep_alive) {
     return NetworkConnectionState::INIT;
   }
   return NetworkConnectionState::CLOSED;

src/CellularConnectionHandler.h

@@ -37,18 +37,18 @@ class CellularConnectionHandler : public ConnectionHandler
     CellularConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive = true);
 
 
-    virtual unsigned long getTime() override;
-    virtual Client & getClient() override { return _gsm_client; };
-    virtual UDP & getUDP() override;
+    unsigned long getTime() override;
+    Client & getClient() override { return _gsm_client; };
+    UDP & getUDP() override;
 
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
 
   private:

src/ConnectionHandlerDefinitions.h

@@ -136,18 +136,41 @@
   #define NETWORK_CONNECTED WL_CONNECTED
 #endif
 
+#if defined(__AVR__)
+#ifndef DEBUG_ERROR
+#  define DEBUG_ERROR(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_WARNING
+#  define DEBUG_WARNING(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_INFO
+#  define DEBUG_INFO(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_DEBUG
+#  define DEBUG_DEBUG(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_VERBOSE
+#  define DEBUG_VERBOSE(fmt, ...) (void)0
+#endif
+#endif // defined(__AVR__)
+
 /******************************************************************************
   TYPEDEFS
  ******************************************************************************/
 
 enum class NetworkConnectionState : unsigned int {
-  INIT          = 0,
-  CONNECTING    = 1,
-  CONNECTED     = 2,
-  DISCONNECTING = 3,
-  DISCONNECTED  = 4,
-  CLOSED        = 5,
-  ERROR         = 6
+  CHECK         = 0,
+  INIT          = 1,
+  CONNECTING    = 2,
+  CONNECTED     = 3,
+  DISCONNECTING = 4,
+  DISCONNECTED  = 5,
+  CLOSED        = 6,
+  ERROR         = 7
 };
 
 enum class NetworkConnectionEvent {

src/ConnectionHandlerInterface.cpp

@@ -18,12 +18,12 @@
   CONSTRUCTOR/DESTRUCTOR
  ******************************************************************************/
 
-ConnectionHandler::ConnectionHandler(bool const keep_alive, NetworkAdapter interface)
-: _keep_alive{keep_alive}
-, _check_internet_availability{false}
+ConnectionHandler::ConnectionHandler(bool const keep_alive, NetworkAdapter interface,
+  bool settings_required)
+: _flags{keep_alive, false, settings_required, false}
 , _interface{interface}
 , _lastConnectionTickTime{millis()}
-, _current_net_connection_state{NetworkConnectionState::INIT}
+, _current_net_connection_state{NetworkConnectionState::CHECK}
 , _timeoutTable(DefaultTimeoutTable)
 {
 
@@ -73,6 +73,7 @@ NetworkConnectionState ConnectionHandler::updateConnectionState() {
    */
   switch (_current_net_connection_state)
   {
+    case NetworkConnectionState::CHECK:         next_net_connection_state = update_handleCheck        (); break;
     case NetworkConnectionState::INIT:          next_net_connection_state = update_handleInit         (); break;
     case NetworkConnectionState::CONNECTING:    next_net_connection_state = update_handleConnecting   (); break;
     case NetworkConnectionState::CONNECTED:     next_net_connection_state = update_handleConnected    (); break;
@@ -109,14 +110,14 @@ void ConnectionHandler::connect()
 {
   if (_current_net_connection_state != NetworkConnectionState::INIT && _current_net_connection_state != NetworkConnectionState::CONNECTING)
   {
-    _keep_alive = true;
+    _flags.keep_alive = true;
     _current_net_connection_state = NetworkConnectionState::INIT;
   }
 }
 
 void ConnectionHandler::disconnect()
 {
-  _keep_alive = false;
+  _flags.keep_alive = false;
   _current_net_connection_state = NetworkConnectionState::DISCONNECTING;
 }
 
@@ -139,3 +140,11 @@ void ConnectionHandler::addDisconnectCallback(OnNetworkEventCallback callback) {
 void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) {
   _on_error_event_callback = callback;
 }
+
+NetworkConnectionState ConnectionHandler::update_handleCheck() {
+  if(_flags.settings_required && !_flags.settings_provided) {
+    return NetworkConnectionState::CHECK;
+  } else {
+    return NetworkConnectionState::INIT;
+  }
+}

src/ConnectionHandlerInterface.h

@@ -23,6 +23,7 @@
 #include <Udp.h>
 #include "ConnectionHandlerDefinitions.h"
 #include "connectionHandlerModels/settings.h"
+#include <stdint.h>
 
 #include <utility>
 
@@ -42,7 +43,8 @@ class GenericConnectionHandler;
 class ConnectionHandler {
   public:
 
-    ConnectionHandler(bool const keep_alive=true, NetworkAdapter interface=NetworkAdapter::NONE);
+    ConnectionHandler(bool const keep_alive=true, NetworkAdapter interface=NetworkAdapter::NONE,
+                      bool settings_required = false);
 
     virtual ~ConnectionHandler() {}
 
@@ -72,7 +74,7 @@ class ConnectionHandler {
     virtual void connect();
     virtual void disconnect();
     void enableCheckInternetAvailability(bool enable) {
-      _check_internet_availability = enable;
+      _flags.check_internet_availability = enable;
     }
 
     virtual void addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback);
@@ -88,8 +90,9 @@ class ConnectionHandler {
      * @return true if the update is successful, false otherwise
      */
     virtual bool updateSetting(const models::NetworkSetting& s) {
-      if(_current_net_connection_state == NetworkConnectionState::INIT && s.type == _interface) {
+      if(_current_net_connection_state <= NetworkConnectionState::INIT && s.type == _interface) {
         memcpy(&_settings, &s, sizeof(s));
+        _flags.settings_provided = true;
         return true;
       }
 
@@ -101,7 +104,7 @@ class ConnectionHandler {
       return;
     }
 
-    virtual void setKeepAlive(bool keep_alive=true) { this->_keep_alive = keep_alive; }
+    virtual void setKeepAlive(bool keep_alive=true) { this->_flags.keep_alive = keep_alive; }
 
     inline void updateTimeoutTable(const TimeoutTable& t) { _timeoutTable = t; }
     inline void updateTimeoutTable(TimeoutTable&& t)      { _timeoutTable = std::move(t); }
@@ -113,10 +116,16 @@ class ConnectionHandler {
     virtual NetworkConnectionState updateConnectionState();
     virtual void updateCallback(NetworkConnectionState next_net_connection_state);
 
-    bool _keep_alive;
-    bool _check_internet_availability;
+    struct Flags {
+      bool keep_alive: 1;
+      bool check_internet_availability: 1;
+      bool settings_required: 1;
+      bool settings_provided: 1;
+    } _flags;
+
     NetworkAdapter _interface;
 
+    virtual NetworkConnectionState update_handleCheck        ();
     virtual NetworkConnectionState update_handleInit         () = 0;
     virtual NetworkConnectionState update_handleConnecting   () = 0;
     virtual NetworkConnectionState update_handleConnected    () = 0;

src/EthernetConnectionHandler.cpp

@@ -44,6 +44,8 @@ EthernetConnectionHandler::EthernetConnectionHandler(
   memset(_settings.eth.netmask.dword, 0, sizeof(_settings.eth.netmask.dword));
   _settings.eth.timeout = timeout;
   _settings.eth.response_timeout = responseTimeout;
+
+  _flags.settings_provided = true;
 }
 
 EthernetConnectionHandler::EthernetConnectionHandler(
@@ -58,6 +60,8 @@ EthernetConnectionHandler::EthernetConnectionHandler(
   fromIPAddress(netmask, _settings.eth.netmask);
   _settings.eth.timeout = timeout;
   _settings.eth.response_timeout = responseTimeout;
+
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -106,7 +110,7 @@ NetworkConnectionState EthernetConnectionHandler::update_handleConnecting()
     return NetworkConnectionState::INIT;
   }
 
-  if (!_check_internet_availability) {
+  if (!_flags.check_internet_availability) {
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -130,7 +134,7 @@ NetworkConnectionState EthernetConnectionHandler::update_handleConnected()
 {
   if (Ethernet.linkStatus() == LinkOFF) {
     DEBUG_ERROR(F("Ethernet link OFF, connection lost."));
-    if (_keep_alive)
+    if (_flags.keep_alive)
     {
       DEBUG_ERROR(F("Attempting reconnection"));
     }
@@ -147,7 +151,7 @@ NetworkConnectionState EthernetConnectionHandler::update_handleDisconnecting()
 
 NetworkConnectionState EthernetConnectionHandler::update_handleDisconnected()
 {
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }

src/EthernetConnectionHandler.h

@@ -54,17 +54,17 @@ class EthernetConnectionHandler : public ConnectionHandler
       unsigned long const responseTimeout = 4000,
       bool const keep_alive = true);
 
-    virtual unsigned long getTime() override { return 0; }
-    virtual Client & getClient() override{ return _eth_client; }
-    virtual UDP & getUDP() override { return _eth_udp; }
+    unsigned long getTime() override { return 0; }
+    Client & getClient() override{ return _eth_client; }
+    UDP & getUDP() override { return _eth_udp; }
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
   private: