Clean-up of connection handler for better maintainability.

.github/workflows/compile-examples.yml

@@ -5,7 +5,7 @@ jobs:
    runs-on: ubuntu-latest
 
    env:
-     LIBRARIES: Arduino_DebugUtils WiFi101 WiFiNINA MKRGSM MKRNB
+     LIBRARIES: Arduino_DebugUtils WiFi101 WiFiNINA MKRGSM MKRNB MKRWAN
    strategy:
      matrix:
        fqbn: [
@@ -14,6 +14,8 @@ jobs:
          "arduino:samd:nano_33_iot",
          "arduino:samd:mkrgsm1400",
          "arduino:samd:mkrnb1500",
+         "arduino:samd:mkrwan1300",
+         "arduino:samd:mkrwan1310",
          '"esp8266:esp8266:huzzah" "https://arduino.esp8266.com/stable/package_esp8266com_index.json"'
        ]
 

examples/ConnectionHandlerDemo/ConnectionHandlerDemo.ino

@@ -26,6 +26,8 @@ WiFiConnectionHandler conMan(SECRET_SSID, SECRET_PASS);
 GSMConnectionHandler conMan(SECRET_APN, SECRET_PIN, SECRET_GSM_USER, SECRET_GSM_PASS);
 #elif defined(BOARD_HAS_NB)
 NBConnectionHandler conMan(SECRET_PIN);
+#elif defined(BOARD_HAS_LORA)
+LoRaConnectionHandler conMan(SECRET_APP_EUI, SECRET_APP_KEY);
 #endif
 
 void setup() {
@@ -35,10 +37,9 @@ void setup() {
 
   setDebugMessageLevel(DBG_INFO);
 
-  /* Register a function to be called upon connection to a network */
-  conMan.addConnectCallback(onNetworkConnect);
-  /* Register a function to be called upon disconnection from a network */
-  conMan.addDisconnectCallback(onNetworkDisconnect);
+  conMan.addCallback(NetworkConnectionEvent::CONNECTED, onNetworkConnect);
+  conMan.addCallback(NetworkConnectionEvent::DISCONNECTED, onNetworkDisconnect);
+  conMan.addCallback(NetworkConnectionEvent::ERROR, onNetworkError);
 }
 
 void loop() {
@@ -54,10 +55,14 @@ void loop() {
   conMan.check();
 }
 
-void onNetworkConnect(void *_arg) {
+void onNetworkConnect() {
   Serial.println(">>>> CONNECTED to network");
 }
 
-void onNetworkDisconnect(void *_arg) {
+void onNetworkDisconnect() {
   Serial.println(">>>> DISCONNECTED from network");
 }
+
+void onNetworkError() {
+  Serial.println(">>>> ERROR");
+}

examples/ConnectionHandlerDemo/arduino_secrets.h

@@ -4,4 +4,7 @@ const char SECRET_PASS[] = "NETWORK PASSWORD";
 const char SECRET_APN[] 		= "MOBILE PROVIDER APN ADDRESS";
 const char SECRET_PIN[] 		= "0000";
 const char SECRET_GSM_USER[] 	= "GSM USERNAME";
-const char SECRET_GSM_PASS[]	= "GSM PASSWORD";
+const char SECRET_GSM_PASS[]	= "GSM PASSWORD";
+
+const char SECRET_APP_EUI[]  = "APP_EUI";
+const char SECRET_APP_KEY[]  = "APP_KEY";

keywords.txt

@@ -5,19 +5,24 @@
 ####################################################
 # Datatypes (KEYWORD1)
 ####################################################
-Client	KEYWORD1
 ConnectionHandler	KEYWORD1
 WiFiConnectionHandler	KEYWORD1
 GSMConnectionHandler	KEYWORD1
 NBConnectionHandler	KEYWORD1
-EthernetConnectionHandler	KEYWORD1
+LoRaConnectionHandler	KEYWORD1
 
 ####################################################
 # Methods and Functions (KEYWORD2)
 ####################################################
 
 ConnectionHandler	KEYWORD2
-begin	KEYWORD2
+check	KEYWORD2
+connect	KEYWORD2
+disconnect	KEYWORD2
+addCallback	KEYWORD2
+getTime	KEYWORD2
+getClient	KEYWORD2
+getUDP	KEYWORD2
 
 ####################################################
 # Constants (LITERAL1)

src/Arduino_ConnectionHandler.cpp

@@ -21,19 +21,95 @@
 
 #include "Arduino_ConnectionHandler.h"
 
+/******************************************************************************
+   CONSTRUCTOR/DESTRUCTOR
+ ******************************************************************************/
+
+ConnectionHandler::ConnectionHandler(bool const keep_alive)
+: _keep_alive{keep_alive}
+, _current_net_connection_state{NetworkConnectionState::INIT}
+, _lastConnectionTickTime{millis()}
+{
+
+}
+
 /******************************************************************************
    PUBLIC MEMBER FUNCTIONS
  ******************************************************************************/
 
-void ConnectionHandler::addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback) {
-  switch (event) {
-    case NetworkConnectionEvent::CONNECTED:       _on_connect_event_callback       = callback; break;
-    case NetworkConnectionEvent::DISCONNECTED:    _on_disconnect_event_callback    = callback; break;
-    case NetworkConnectionEvent::ERROR:           _on_error_event_callback         = callback; break;
-    case NetworkConnectionEvent::INIT:                                                       ; break;
-    case NetworkConnectionEvent::CONNECTING:                                                 ; break;
-    case NetworkConnectionEvent::DISCONNECTING:                                              ; break;
-    case NetworkConnectionEvent::CLOSED:                                                     ; break;
+NetworkConnectionState ConnectionHandler::check()
+{
+  unsigned long const now = millis();
+  unsigned int const connectionTickTimeInterval = CHECK_INTERVAL_TABLE[static_cast<unsigned int>(_current_net_connection_state)];
+
+  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;
+    }
+
+    /* 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 */
+      _current_net_connection_state = next_net_connection_state;
+    }
+  }
+
+  return _current_net_connection_state;
+}
+
+void ConnectionHandler::connect()
+{
+  if (_current_net_connection_state != NetworkConnectionState::INIT && _current_net_connection_state != NetworkConnectionState::CONNECTING)
+  {
+    _keep_alive = true;
+    _current_net_connection_state = NetworkConnectionState::INIT;
+  }
+}
+
+void ConnectionHandler::disconnect()
+{
+  _keep_alive = false;
+  _current_net_connection_state = NetworkConnectionState::DISCONNECTING;
+}
+
+void ConnectionHandler::addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback)
+{
+  switch (event)
+  {
+    case NetworkConnectionEvent::CONNECTED:    _on_connect_event_callback    = callback; break;
+    case NetworkConnectionEvent::DISCONNECTED: _on_disconnect_event_callback = callback; break;
+    case NetworkConnectionEvent::ERROR:        _on_error_event_callback      = callback; break;
   }
 }
 
@@ -46,10 +122,3 @@ void ConnectionHandler::addDisconnectCallback(OnNetworkEventCallback callback) {
 void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) {
   _on_error_event_callback = callback;
 }
-
-void ConnectionHandler::execNetworkEventCallback(OnNetworkEventCallback & callback, void * callback_arg) {
-  if (callback) {
-    (*callback)(callback_arg);
-  }
-}
-

src/Arduino_ConnectionHandler.h

@@ -113,31 +113,50 @@
    TYPEDEFS
  ******************************************************************************/
 
-enum class NetworkConnectionState {
-  INIT,
-  CONNECTING,
+enum class NetworkConnectionState : unsigned int {
+  INIT          = 0,
+  CONNECTING    = 1,
+  CONNECTED     = 2,
+  DISCONNECTING = 3,
+  DISCONNECTED  = 4,
+  CLOSED        = 5,
+  ERROR         = 6
+};
+
+enum class NetworkConnectionEvent {
   CONNECTED,
-  GETTIME,
-  DISCONNECTING,
   DISCONNECTED,
-  CLOSED,
   ERROR
 };
 
-enum class NetworkConnectionEvent {
-  INIT, CONNECTING, CONNECTED, DISCONNECTING, DISCONNECTED, CLOSED, ERROR
-};
+typedef void (*OnNetworkEventCallback)();
 
-typedef void (*OnNetworkEventCallback)(void * /* arg */);
+/******************************************************************************
+   CONSTANTS
+ ******************************************************************************/
+
+static unsigned int const CHECK_INTERVAL_TABLE[] =
+{
+  /* INIT          */ 100,
+  /* CONNECTING    */ 500,
+  /* CONNECTED     */ 10000,
+  /* DISCONNECTING */ 100,
+  /* DISCONNECTED  */ 1000,
+  /* CLOSED        */ 1000,
+  /* ERROR         */ 1000
+};
 
 /******************************************************************************
    CLASS DECLARATION
  ******************************************************************************/
 
 class ConnectionHandler {
   public:
-    virtual void init() = 0;
-    virtual NetworkConnectionState check() = 0;
+
+    ConnectionHandler(bool const keep_alive);
+
+
+    NetworkConnectionState check();
 
     #if defined(BOARD_HAS_WIFI) || defined(BOARD_HAS_GSM) || defined(BOARD_HAS_NB)
       virtual unsigned long getTime() = 0;
@@ -151,26 +170,36 @@ class ConnectionHandler {
       virtual bool available() = 0;
     #endif
 
-    virtual NetworkConnectionState getStatus() __attribute__((deprecated)) {
-      return netConnectionState;
+    NetworkConnectionState getStatus() __attribute__((deprecated)) {
+      return _current_net_connection_state;
     }
-    virtual void connect() = 0;
-    virtual void disconnect() = 0;
+
+    void connect();
+    void disconnect();
+
     void addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback);
-    void addConnectCallback(OnNetworkEventCallback callback);
-    void addDisconnectCallback(OnNetworkEventCallback callback);
-    void addErrorCallback(OnNetworkEventCallback callback);
+    void addConnectCallback(OnNetworkEventCallback callback) __attribute__((deprecated));
+    void addDisconnectCallback(OnNetworkEventCallback callback) __attribute__((deprecated));
+    void addErrorCallback(OnNetworkEventCallback callback) __attribute__((deprecated));
 
   protected:
-    OnNetworkEventCallback  _on_connect_event_callback = NULL,
-                            _on_disconnect_event_callback = NULL,
-                            _on_error_event_callback = NULL;
 
-    unsigned long lastValidTimestamp = 0;   /*  UNUSED  */
-    NetworkConnectionState netConnectionState = NetworkConnectionState::INIT;
+    bool _keep_alive;
 
-    static void execNetworkEventCallback(OnNetworkEventCallback & callback, void * callback_arg);
+    virtual NetworkConnectionState update_handleInit         () = 0;
+    virtual NetworkConnectionState update_handleConnecting   () = 0;
+    virtual NetworkConnectionState update_handleConnected    () = 0;
+    virtual NetworkConnectionState update_handleDisconnecting() = 0;
+    virtual NetworkConnectionState update_handleDisconnected () = 0;
 
+
+  private:
+
+    unsigned long _lastConnectionTickTime;
+    NetworkConnectionState _current_net_connection_state;
+    OnNetworkEventCallback  _on_connect_event_callback = NULL,
+                            _on_disconnect_event_callback = NULL,
+                            _on_error_event_callback = NULL;
 };
 
 #if defined(BOARD_HAS_WIFI)