Added check state into ConnectionHandler

the objective of the check state is to validate the configuration of the
connection handler before going into the init state. For the time being
the only valid check is to wait for settings to be provided if required.

WiFiConnectionHandler splits the init state into check and init

Author: andreagilardoni

src/ConnectionHandlerDefinitions.h

@@ -163,13 +163,14 @@
  ******************************************************************************/
 
 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

@@ -23,7 +23,7 @@ ConnectionHandler::ConnectionHandler(bool const keep_alive, NetworkAdapter inter
 : _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;
@@ -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

@@ -90,7 +90,7 @@ 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;
@@ -125,6 +125,7 @@ class ConnectionHandler {
 
     NetworkAdapter _interface;
 
+    virtual NetworkConnectionState update_handleCheck        ();
     virtual NetworkConnectionState update_handleInit         () = 0;
     virtual NetworkConnectionState update_handleConnecting   () = 0;
     virtual NetworkConnectionState update_handleConnected    () = 0;

src/GenericConnectionHandler.cpp

@@ -21,10 +21,10 @@ GenericConnectionHandler::GenericConnectionHandler(bool const keep_alive)
 : ConnectionHandler(keep_alive, NetworkAdapter::NONE, true), _ch(nullptr) { }
 
 bool GenericConnectionHandler::updateSetting(const models::NetworkSetting& s) {
-    if(_ch != nullptr && _ch->_current_net_connection_state != NetworkConnectionState::INIT) {
+    if(_ch != nullptr && _ch->_current_net_connection_state > NetworkConnectionState::INIT) {
         // If the internal connection handler is already being used and not in INIT phase we cannot update the settings
         return false;
-    } else if(_ch != nullptr && _ch->_current_net_connection_state == NetworkConnectionState::INIT && _interface != s.type) {
+    } else if(_ch != nullptr && _ch->_current_net_connection_state <= NetworkConnectionState::INIT && _interface != s.type) {
         // If the internal connection handler is already being used and in INIT phase and the interface type is being changed
         // -> we need to deallocate the previously allocated handler
 
@@ -57,27 +57,31 @@ void GenericConnectionHandler::getSetting(models::NetworkSetting& s) {
 }
 
 NetworkConnectionState GenericConnectionHandler::updateConnectionState() {
-    return _ch != nullptr ? _ch->updateConnectionState() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->updateConnectionState() : NetworkConnectionState::CHECK;
+}
+
+NetworkConnectionState GenericConnectionHandler::update_handleCheck() {
+    return _ch != nullptr ? _ch->update_handleCheck() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleInit() {
-    return _ch != nullptr ? _ch->update_handleInit() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleInit() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleConnecting() {
-    return _ch != nullptr ? _ch->update_handleConnecting() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleConnecting() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleConnected() {
-    return _ch != nullptr ? _ch->update_handleConnected() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleConnected() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleDisconnecting() {
-    return _ch != nullptr ? _ch->update_handleDisconnecting() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleDisconnecting() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleDisconnected() {
-    return _ch != nullptr ? _ch->update_handleDisconnected() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleDisconnected() : NetworkConnectionState::CHECK;
 }
 
 #if not (defined(BOARD_HAS_LORA) or defined(BOARD_HAS_NOTECARD))

src/GenericConnectionHandler.h

@@ -60,6 +60,7 @@ class GenericConnectionHandler : public ConnectionHandler
 
     NetworkConnectionState updateConnectionState() override;
 
+    NetworkConnectionState update_handleCheck        () override;
     NetworkConnectionState update_handleInit         () override;
     NetworkConnectionState update_handleConnecting   () override;
     NetworkConnectionState update_handleConnected    () override;

src/WiFiConnectionHandler.cpp

@@ -57,7 +57,7 @@ unsigned long WiFiConnectionHandler::getTime()
   PROTECTED MEMBER FUNCTIONS
  ******************************************************************************/
 
-NetworkConnectionState WiFiConnectionHandler::update_handleInit()
+NetworkConnectionState WiFiConnectionHandler::update_handleCheck()
 {
 #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32)
   if (WiFi.status() == NETWORK_HARDWARE_ERROR)
@@ -82,7 +82,14 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit()
   WiFi.mode(WIFI_STA);
 #endif /* #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32) */
 
+  return ConnectionHandler::update_handleCheck();
+}
+
+NetworkConnectionState WiFiConnectionHandler::update_handleInit()
+{
   DEBUG_INFO(F("WiFi.status(): %d"), WiFi.status());
+
+  if (WiFi.status() != WL_CONNECTED && _flags.settings_provided)
   {
     WiFi.begin(_settings.wifi.ssid, _settings.wifi.pwd);
 #if defined(ARDUINO_ARCH_ESP8266)

src/WiFiConnectionHandler.h

@@ -66,6 +66,7 @@ class WiFiConnectionHandler : public ConnectionHandler
 
   protected:
 
+    NetworkConnectionState update_handleCheck        () override;
     NetworkConnectionState update_handleInit         () override;
     NetworkConnectionState update_handleConnecting   () override;
     NetworkConnectionState update_handleConnected    () override;