splitting check() method into updateConnectionState() and updateCallback()

Author: andreagilardoni

src/ConnectionHandlerInterface.cpp

@@ -46,49 +46,69 @@ NetworkConnectionState ConnectionHandler::check()
   if((now - _lastConnectionTickTime) > connectionTickTimeInterval)
   {
     _lastConnectionTickTime = now;
-    NetworkConnectionState next_net_connection_state = _current_net_connection_state;
 
-    /* While the state machine is implemented here, the concrete implementation of the
-     * states is done in the derived connection handlers.
-     */
-    switch (_current_net_connection_state)
-    {
-      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;
-      case NetworkConnectionState::DISCONNECTING: next_net_connection_state = update_handleDisconnecting(); break;
-      case NetworkConnectionState::DISCONNECTED:  next_net_connection_state = update_handleDisconnected (); break;
-      case NetworkConnectionState::ERROR:                                                                   break;
-      case NetworkConnectionState::CLOSED:                                                                  break;
-    }
+    NetworkConnectionState old_net_connection_state = _current_net_connection_state;
+    NetworkConnectionState next_net_connection_state = updateConnectionState();
 
     /* Here we are determining whether a state transition from one state to the next has
      * occurred - and if it has, we call eventually registered callbacks.
      */
-    if(next_net_connection_state != _current_net_connection_state)
-    {
-      /* Check the next state to determine the kind of state conversion which has occurred (and call the appropriate callback) */
-      if(next_net_connection_state == NetworkConnectionState::CONNECTED)
-      {
-        if(_on_connect_event_callback) _on_connect_event_callback();
-      }
-      if(next_net_connection_state == NetworkConnectionState::DISCONNECTED)
-      {
-        if(_on_disconnect_event_callback) _on_disconnect_event_callback();
-      }
-      if(next_net_connection_state == NetworkConnectionState::ERROR)
-      {
-        if(_on_error_event_callback) _on_error_event_callback();
-      }
-
-      /* Assign new state to the member variable holding the state */
+
+    if(old_net_connection_state != next_net_connection_state) {
+      updateCallback(next_net_connection_state);
+
+      /* It may happen that the local _current_net_connection_state
+       * is not updated by the updateConnectionState() call. This is the case for GenericConnection handler
+       * where the call of updateConnectionState() is replaced by the inner ConnectionHandler call
+       * that updates its state, but not the outer one. For this reason it is required to perform this call twice
+       */
       _current_net_connection_state = next_net_connection_state;
     }
   }
 
   return _current_net_connection_state;
 }
 
+NetworkConnectionState ConnectionHandler::updateConnectionState() {
+  NetworkConnectionState next_net_connection_state = _current_net_connection_state;
+
+  /* While the state machine is implemented here, the concrete implementation of the
+   * states is done in the derived connection handlers.
+   */
+  switch (_current_net_connection_state)
+  {
+    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;
+    case NetworkConnectionState::DISCONNECTING: next_net_connection_state = update_handleDisconnecting(); break;
+    case NetworkConnectionState::DISCONNECTED:  next_net_connection_state = update_handleDisconnected (); break;
+    case NetworkConnectionState::ERROR:                                                                   break;
+    case NetworkConnectionState::CLOSED:                                                                  break;
+  }
+
+  /* Assign new state to the member variable holding the state */
+  _current_net_connection_state = next_net_connection_state;
+
+  return next_net_connection_state;
+}
+
+void ConnectionHandler::updateCallback(NetworkConnectionState next_net_connection_state) {
+
+  /* Check the next state to determine the kind of state conversion which has occurred (and call the appropriate callback) */
+  if(next_net_connection_state == NetworkConnectionState::CONNECTED)
+  {
+    if(_on_connect_event_callback) _on_connect_event_callback();
+  }
+  if(next_net_connection_state == NetworkConnectionState::DISCONNECTED)
+  {
+    if(_on_disconnect_event_callback) _on_disconnect_event_callback();
+  }
+  if(next_net_connection_state == NetworkConnectionState::ERROR)
+  {
+    if(_on_error_event_callback) _on_error_event_callback();
+  }
+}
+
 void ConnectionHandler::connect()
 {
   if (_current_net_connection_state != NetworkConnectionState::INIT && _current_net_connection_state != NetworkConnectionState::CONNECTING)

src/ConnectionHandlerInterface.h

@@ -102,6 +102,9 @@ class ConnectionHandler {
 
   protected:
 
+    virtual NetworkConnectionState updateConnectionState();
+    virtual void updateCallback(NetworkConnectionState next_net_connection_state);
+
     bool _keep_alive;
     NetworkAdapter _interface;