Make function pointer containing connection handler event callbacks private and access them via one generalised execCallback function

aentinger · aentinger · commit a33784d2a835 · 2020-03-09T13:54:56.000+01:00
diff --git a/src/Arduino_ConnectionHandler.cpp b/src/Arduino_ConnectionHandler.cpp
@@ -47,9 +47,18 @@ void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) {
   _on_error_event_callback = callback;
 }
 
-void ConnectionHandler::execNetworkEventCallback(OnNetworkEventCallback & callback, void * callback_arg) {
-  if (callback) {
-    (*callback)(callback_arg);
+/******************************************************************************
+   PRIVATE MEMBER FUNCTIONS
+ ******************************************************************************/
+
+void ConnectionHandler::execCallback(NetworkConnectionEvent const event, void * callback_arg) {
+  switch (event) {
+    case NetworkConnectionEvent::CONNECTED:       if(_on_connect_event_callback)    _on_connect_event_callback   (callback_arg); break;
+    case NetworkConnectionEvent::DISCONNECTED:    if(_on_disconnect_event_callback) _on_disconnect_event_callback(callback_arg); break;
+    case NetworkConnectionEvent::ERROR:           if(_on_error_event_callback)      _on_error_event_callback     (callback_arg); break;
+    case NetworkConnectionEvent::INIT:                                                                                           break;
+    case NetworkConnectionEvent::CONNECTING:                                                                                     break;
+    case NetworkConnectionEvent::DISCONNECTING:                                                                                  break;
+    case NetworkConnectionEvent::CLOSED:                                                                                         break;
   }
 }
-
diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h
@@ -162,14 +162,16 @@ class ConnectionHandler {
     void addErrorCallback(OnNetworkEventCallback callback) __attribute__((deprecated));
 
   protected:
-    OnNetworkEventCallback  _on_connect_event_callback = NULL,
-                            _on_disconnect_event_callback = NULL,
-                            _on_error_event_callback = NULL;
 
     NetworkConnectionState netConnectionState = NetworkConnectionState::INIT;
 
-    static void execNetworkEventCallback(OnNetworkEventCallback & callback, void * callback_arg);
+    void execCallback(NetworkConnectionEvent const event, void * callback_arg);
+
+  private:
 
+    OnNetworkEventCallback  _on_connect_event_callback = NULL,
+                            _on_disconnect_event_callback = NULL,
+                            _on_error_event_callback = NULL;
 };
 
 #if defined(BOARD_HAS_WIFI)
diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp
@@ -151,7 +151,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat
       }
       break;
     case NetworkConnectionState::CONNECTED: {
-        execNetworkEventCallback(_on_connect_event_callback, 0);
+        execCallback(NetworkConnectionEvent::CONNECTED, 0);
         newInterval = CHECK_INTERVAL_CONNECTED;
       }
       break;
@@ -164,7 +164,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat
       }
     case NetworkConnectionState::DISCONNECTED: {
         if (netConnectionState == NetworkConnectionState::CONNECTED) {
-          execNetworkEventCallback(_on_disconnect_event_callback, 0);
+          execCallback(NetworkConnectionEvent::DISCONNECTED, 0);
           Debug.print(DBG_ERROR, "Disconnected from Cellular Network");
           Debug.print(DBG_ERROR, "Attempting reconnection");
           if (keepAlive) {
@@ -175,7 +175,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat
       }
       break;
     case NetworkConnectionState::ERROR: {
-        execNetworkEventCallback(_on_error_event_callback, 0);
+        execCallback(NetworkConnectionEvent::ERROR, 0);
         Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board.");
       }
       break;
diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp
@@ -133,7 +133,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleInit() {
   Debug.print(DBG_VERBOSE, "::INIT");
   if (!modem.begin(band)) {
     Debug.print(DBG_VERBOSE, "Failed to start module");
-    execNetworkEventCallback(_on_error_event_callback, 0);
+    execCallback(NetworkConnectionEvent::ERROR, 0);
     Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry.");
   };
   //A delay is required between modem.begin(band) and modem.joinOTAA(appeui, appkey) in order to let the chip to be correctly initialized before the connection attempt
@@ -149,14 +149,14 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnecting() {
   Debug.print(DBG_VERBOSE, "::CONNECTING");
   bool networkStatus = modem.joinOTAA(appeui, appkey);
   if (networkStatus != true) {
-    execNetworkEventCallback(_on_error_event_callback, 0);
+    execCallback(NetworkConnectionEvent::ERROR, 0);
     Debug.print(DBG_ERROR, "Something went wrong; are you indoor? Move near a window, then reset and retry.");
     return NetworkConnectionState::ERROR;
   }
 
   Debug.print(DBG_INFO, "Connected to the network");
   connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED;
-  execNetworkEventCallback(_on_connect_event_callback, 0);
+  execCallback(NetworkConnectionEvent::CONNECTED, 0);
   return NetworkConnectionState::CONNECTED;
 }
 
@@ -165,7 +165,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() {
   bool networkStatus = modem.connected();
   Debug.print(DBG_VERBOSE, "Connection state: %d", networkStatus);
   if (networkStatus != true) {
-    execNetworkEventCallback(_on_disconnect_event_callback, 0);
+    execCallback(NetworkConnectionEvent::DISCONNECTED, 0);
 
     Debug.print(DBG_ERROR, "Connection to the network lost.");
     if (keepAlive) {
@@ -180,7 +180,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected() {
 }
 
 NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting() {
-  execNetworkEventCallback(_on_disconnect_event_callback, 0);
+  execCallback(NetworkConnectionEvent::DISCONNECTED, 0);
 
   Debug.print(DBG_ERROR, "Connection to the network lost.");
   if (keepAlive) {
diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp
@@ -159,7 +159,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState
       }
       break;
     case NetworkConnectionState::CONNECTED: {
-        execNetworkEventCallback(_on_connect_event_callback, 0);
+        execCallback(NetworkConnectionEvent::CONNECTED, 0);
         newInterval = CHECK_INTERVAL_CONNECTED;
       }
       break;
@@ -172,7 +172,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState
       }
     case NetworkConnectionState::DISCONNECTED: {
         if (netConnectionState == NetworkConnectionState::CONNECTED) {
-          execNetworkEventCallback(_on_disconnect_event_callback, 0);
+          execCallback(NetworkConnectionEvent::DISCONNECTED, 0);
           Debug.print(DBG_ERROR, "Disconnected from Cellular Network");
           Debug.print(DBG_ERROR, "Attempting reconnection");
           if (keepAlive) {
@@ -183,7 +183,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState
       }
       break;
     case NetworkConnectionState::ERROR: {
-        execNetworkEventCallback(_on_error_event_callback, 0);
+        execCallback(NetworkConnectionEvent::ERROR, 0);
         Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board.");
       }
       break;
diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp
@@ -96,7 +96,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit() {
 #ifndef BOARD_ESP8266
   Debug.print(DBG_INFO, "WiFi.status(): %d", WiFi.status());
   if (WiFi.status() == NETWORK_HARDWARE_ERROR) {
-    execNetworkEventCallback(_on_error_event_callback, 0);
+    execCallback(NetworkConnectionEvent::ERROR, 0);
     Debug.print(DBG_ERROR, "WiFi Hardware failure.\nMake sure you are using a WiFi enabled board/shield.");
     Debug.print(DBG_ERROR, "Then reset and retry.");
     return NetworkConnectionState::ERROR;
@@ -138,7 +138,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting() {
   }
   else {
     Debug.print(DBG_INFO, "Connected to \"%s\"", ssid);
-    execNetworkEventCallback(_on_connect_event_callback, 0);
+    execCallback(NetworkConnectionEvent::CONNECTED, 0);
     connectionTickTimeInterval = CHECK_INTERVAL_CONNECTED;
     return NetworkConnectionState::GETTIME;
   }
@@ -149,7 +149,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected() {
   Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status());
   if (WiFi.status() != WL_CONNECTED)
   {
-    execNetworkEventCallback(_on_disconnect_event_callback, 0);
+    execCallback(NetworkConnectionEvent::DISCONNECTED, 0);
    
     Debug.print(DBG_VERBOSE, "WiFi.status(): %d", WiFi.status());
     Debug.print(DBG_ERROR, "Connection to \"%s\" lost.", ssid);

Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat`
`151`	`151`	`}`
`152`	`152`	`break;`
`153`	`153`	`case NetworkConnectionState::CONNECTED: {`
`154`		`- execNetworkEventCallback(_on_connect_event_callback, 0);`
	`154`	`+ execCallback(NetworkConnectionEvent::CONNECTED, 0);`
`155`	`155`	`newInterval = CHECK_INTERVAL_CONNECTED;`
`156`	`156`	`}`
`157`	`157`	`break;`
`@@ -164,7 +164,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat`
`164`	`164`	`}`
`165`	`165`	`case NetworkConnectionState::DISCONNECTED: {`
`166`	`166`	`if (netConnectionState == NetworkConnectionState::CONNECTED) {`
`167`		`- execNetworkEventCallback(_on_disconnect_event_callback, 0);`
	`167`	`+ execCallback(NetworkConnectionEvent::DISCONNECTED, 0);`
`168`	`168`	`Debug.print(DBG_ERROR, "Disconnected from Cellular Network");`
`169`	`169`	`Debug.print(DBG_ERROR, "Attempting reconnection");`
`170`	`170`	`if (keepAlive) {`
`@@ -175,7 +175,7 @@ void GSMConnectionHandler::changeConnectionState(NetworkConnectionState _newStat`
`175`	`175`	`}`
`176`	`176`	`break;`
`177`	`177`	`case NetworkConnectionState::ERROR: {`
`178`		`- execNetworkEventCallback(_on_error_event_callback, 0);`
	`178`	`+ execCallback(NetworkConnectionEvent::ERROR, 0);`
`179`	`179`	`Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board.");`
`180`	`180`	`}`
`181`	`181`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState`
`159`	`159`	`}`
`160`	`160`	`break;`
`161`	`161`	`case NetworkConnectionState::CONNECTED: {`
`162`		`- execNetworkEventCallback(_on_connect_event_callback, 0);`
	`162`	`+ execCallback(NetworkConnectionEvent::CONNECTED, 0);`
`163`	`163`	`newInterval = CHECK_INTERVAL_CONNECTED;`
`164`	`164`	`}`
`165`	`165`	`break;`
`@@ -172,7 +172,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState`
`172`	`172`	`}`
`173`	`173`	`case NetworkConnectionState::DISCONNECTED: {`
`174`	`174`	`if (netConnectionState == NetworkConnectionState::CONNECTED) {`
`175`		`- execNetworkEventCallback(_on_disconnect_event_callback, 0);`
	`175`	`+ execCallback(NetworkConnectionEvent::DISCONNECTED, 0);`
`176`	`176`	`Debug.print(DBG_ERROR, "Disconnected from Cellular Network");`
`177`	`177`	`Debug.print(DBG_ERROR, "Attempting reconnection");`
`178`	`178`	`if (keepAlive) {`
`@@ -183,7 +183,7 @@ void NBConnectionHandler::changeConnectionState(NetworkConnectionState _newState`
`183`	`183`	`}`
`184`	`184`	`break;`
`185`	`185`	`case NetworkConnectionState::ERROR: {`
`186`		`- execNetworkEventCallback(_on_error_event_callback, 0);`
	`186`	`+ execCallback(NetworkConnectionEvent::ERROR, 0);`
`187`	`187`	`Debug.print(DBG_ERROR, "GPRS attach failed\n\rMake sure the antenna is connected and reset your board.");`
`188`	`188`	`}`
`189`	`189`	`break;`