Function 'check()' directly returns the NetworkConnectionState which eliminates the need to query the member variable NetConnectionStatus via 'getStatus()'

aentinger · aentinger · commit 93a7b3c01b24 · 2020-03-04T08:33:59.000+01:00
diff --git a/src/Arduino_ConnectionHandler.h b/src/Arduino_ConnectionHandler.h
@@ -137,7 +137,7 @@ typedef void (*OnNetworkEventCallback)(void * /* arg */);
 class ConnectionHandler {
   public:
     virtual void init() = 0;
-    virtual void check() = 0;
+    virtual NetworkConnectionState check() = 0;
 
     #if defined(BOARD_HAS_WIFI) || defined(BOARD_HAS_GSM) || defined(BOARD_HAS_NB)
       virtual unsigned long getTime() = 0;
diff --git a/src/Arduino_GSMConnectionHandler.cpp b/src/Arduino_GSMConnectionHandler.cpp
@@ -71,7 +71,7 @@ unsigned long GSMConnectionHandler::getTime() {
   return gsmAccess.getTime();
 }
 
-void GSMConnectionHandler::check() {
+NetworkConnectionState GSMConnectionHandler::check() {
   unsigned long const now = millis();
   int gsmAccessAlive;
   if (now - lastConnectionTickTime > connectionTickTimeInterval) {
@@ -89,7 +89,7 @@ void GSMConnectionHandler::check() {
           if (networkStatus == GSM3_NetworkStatus_t::ERROR) {
             // NO FURTHER ACTION WILL FOLLOW THIS
             changeConnectionState(NetworkConnectionState::ERROR);
-            return;
+            return netConnectionState;
           }
           Debug.print(DBG_INFO, "Sending PING to outer space...");
           int pingResult;
@@ -98,11 +98,11 @@ void GSMConnectionHandler::check() {
           if (pingResult < 0) {
             Debug.print(DBG_ERROR, "PING failed");
             Debug.print(DBG_INFO, "Retrying in  \"%d\" milliseconds", connectionTickTimeInterval);
-            return;
+            return netConnectionState;
           } else {
             Debug.print(DBG_INFO, "Connected to GPRS Network");
             changeConnectionState(NetworkConnectionState::CONNECTED);
-            return;
+            return netConnectionState;
           }
         }
         break;
@@ -111,7 +111,7 @@ void GSMConnectionHandler::check() {
           Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", gsmAccessAlive);
           if (gsmAccessAlive != 1) {
             changeConnectionState(NetworkConnectionState::DISCONNECTED);
-            return;
+            return netConnectionState;
           }
           Debug.print(DBG_VERBOSE, "Connected to Cellular Network");
         }
@@ -130,6 +130,8 @@ void GSMConnectionHandler::check() {
     }
     lastConnectionTickTime = now;
   }
+
+  return netConnectionState;
 }
 
 /******************************************************************************
diff --git a/src/Arduino_GSMConnectionHandler.h b/src/Arduino_GSMConnectionHandler.h
@@ -37,7 +37,7 @@ class GSMConnectionHandler : public TcpIpConnectionHandler {
 
     virtual void init();
     virtual unsigned long getTime();
-    virtual void check();
+    virtual NetworkConnectionState check();
     virtual Client &getClient() {
       return networkClient;
     };
diff --git a/src/Arduino_LPWANConnectionHandler.h b/src/Arduino_LPWANConnectionHandler.h
@@ -32,7 +32,7 @@
 class LPWANConnectionHandler : public ConnectionHandler {
   public:
     virtual void init() = 0;
-    virtual void check();
+    virtual NetworkConnectionState check();
     virtual unsigned long getTime() = 0;
 
     virtual int write(const uint8_t *buf, size_t size) = 0;
diff --git a/src/Arduino_LoRaConnectionHandler.cpp b/src/Arduino_LoRaConnectionHandler.cpp
@@ -104,7 +104,7 @@ bool LoRaConnectionHandler::available() {
   return modem.available();
 }
 
-void LoRaConnectionHandler::check() {
+NetworkConnectionState LoRaConnectionHandler::check() {
 
   unsigned long const now = millis();
   int networkStatus = 0;
@@ -121,6 +121,8 @@ void LoRaConnectionHandler::check() {
       case NetworkConnectionState::CLOSED:                                                           break;
     }
   }
+
+  return netConnectionState;
 }
 
 /******************************************************************************
diff --git a/src/Arduino_LoRaConnectionHandler.h b/src/Arduino_LoRaConnectionHandler.h
@@ -46,7 +46,7 @@ class LoRaConnectionHandler : public LPWANConnectionHandler {
 
     void init();
     unsigned long getTime();
-    void check();
+    NetworkConnectionState check();
 
     int write(const uint8_t *buf, size_t size);
     int read();
diff --git a/src/Arduino_NBConnectionHandler.cpp b/src/Arduino_NBConnectionHandler.cpp
@@ -78,7 +78,7 @@ unsigned long NBConnectionHandler::getTime() {
   return nbAccess.getTime();
 }
 
-void NBConnectionHandler::check() {
+NetworkConnectionState NBConnectionHandler::check() {
   unsigned long const now = millis();
   int nbAccessAlive;
   if (now - lastConnectionTickTime > connectionTickTimeInterval) {
@@ -96,7 +96,7 @@ void NBConnectionHandler::check() {
           if (networkStatus == NB_NetworkStatus_t::ERROR) {
             // NO FURTHER ACTION WILL FOLLOW THIS
             changeConnectionState(NetworkConnectionState::ERROR);
-            return;
+            return netConnectionState;
           }
           Debug.print(DBG_INFO, "Sending PING to outer space...");
           int pingResult;
@@ -106,11 +106,11 @@ void NBConnectionHandler::check() {
           if (pingResult < 0) {
             Debug.print(DBG_ERROR, "PING failed");
             Debug.print(DBG_INFO, "Retrying in  \"%d\" milliseconds", connectionTickTimeInterval);
-            return;
+            return netConnectionState;
           } else {
             Debug.print(DBG_INFO, "Connected to GPRS Network");
             changeConnectionState(NetworkConnectionState::CONNECTED);
-            return;
+            return netConnectionState;
           }
         }
         break;
@@ -119,7 +119,7 @@ void NBConnectionHandler::check() {
           Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nbAccessAlive);
           if (nbAccessAlive != 1) {
             changeConnectionState(NetworkConnectionState::DISCONNECTED);
-            return;
+            return netConnectionState;
           }
           Debug.print(DBG_VERBOSE, "Connected to Cellular Network");
         }
@@ -138,6 +138,8 @@ void NBConnectionHandler::check() {
     }
     lastConnectionTickTime = now;
   }
+
+  return netConnectionState;
 }
 
 /******************************************************************************
diff --git a/src/Arduino_NBConnectionHandler.h b/src/Arduino_NBConnectionHandler.h
@@ -38,7 +38,7 @@ class NBConnectionHandler : public TcpIpConnectionHandler {
 
     virtual void init();
     virtual unsigned long getTime();
-    virtual void check();
+    virtual NetworkConnectionState check();
     virtual Client &getClient() {
       return networkClient;
     };
diff --git a/src/Arduino_TcpIpConnectionHandler.h b/src/Arduino_TcpIpConnectionHandler.h
@@ -35,7 +35,7 @@
 class TcpIpConnectionHandler : public ConnectionHandler {
   public:
     virtual void init() = 0;
-    virtual void check() = 0;
+    virtual NetworkConnectionState check() = 0;
     virtual unsigned long getTime() = 0;
     virtual Client &getClient() = 0;
     virtual UDP &getUDP() = 0;
diff --git a/src/Arduino_WiFiConnectionHandler.cpp b/src/Arduino_WiFiConnectionHandler.cpp
@@ -50,7 +50,7 @@ unsigned long WiFiConnectionHandler::getTime() {
 #endif
 }
 
-void WiFiConnectionHandler::check() {
+NetworkConnectionState WiFiConnectionHandler::check() {
 
   unsigned long const now = millis();
   if((now - lastConnectionTickTime) > connectionTickTimeInterval)
@@ -68,6 +68,8 @@ void WiFiConnectionHandler::check() {
       case NetworkConnectionState::CLOSED:                                                           break;
     }
   }
+
+  return netConnectionState;
 }
 
 /******************************************************************************
diff --git a/src/Arduino_WiFiConnectionHandler.h b/src/Arduino_WiFiConnectionHandler.h
@@ -36,7 +36,7 @@ class WiFiConnectionHandler : public TcpIpConnectionHandler {
 
     virtual void init();
     virtual unsigned long getTime();
-    virtual void check();
+    virtual NetworkConnectionState check();
     virtual Client &getClient() {
       return wifiClient;
     };

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ unsigned long GSMConnectionHandler::getTime() {`
`71`	`71`	`return gsmAccess.getTime();`
`72`	`72`	`}`
`73`	`73`
`74`		`-void GSMConnectionHandler::check() {`
	`74`	`+NetworkConnectionState GSMConnectionHandler::check() {`
`75`	`75`	`unsigned long const now = millis();`
`76`	`76`	`int gsmAccessAlive;`
`77`	`77`	`if (now - lastConnectionTickTime > connectionTickTimeInterval) {`
`@@ -89,7 +89,7 @@ void GSMConnectionHandler::check() {`
`89`	`89`	`if (networkStatus == GSM3_NetworkStatus_t::ERROR) {`
`90`	`90`	`// NO FURTHER ACTION WILL FOLLOW THIS`
`91`	`91`	`changeConnectionState(NetworkConnectionState::ERROR);`
`92`		`- return;`
	`92`	`+ return netConnectionState;`
`93`	`93`	`}`
`94`	`94`	`Debug.print(DBG_INFO, "Sending PING to outer space...");`
`95`	`95`	`int pingResult;`
`@@ -98,11 +98,11 @@ void GSMConnectionHandler::check() {`
`98`	`98`	`if (pingResult < 0) {`
`99`	`99`	`Debug.print(DBG_ERROR, "PING failed");`
`100`	`100`	`Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval);`
`101`		`- return;`
	`101`	`+ return netConnectionState;`
`102`	`102`	`} else {`
`103`	`103`	`Debug.print(DBG_INFO, "Connected to GPRS Network");`
`104`	`104`	`changeConnectionState(NetworkConnectionState::CONNECTED);`
`105`		`- return;`
	`105`	`+ return netConnectionState;`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`break;`
`@@ -111,7 +111,7 @@ void GSMConnectionHandler::check() {`
`111`	`111`	`Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", gsmAccessAlive);`
`112`	`112`	`if (gsmAccessAlive != 1) {`
`113`	`113`	`changeConnectionState(NetworkConnectionState::DISCONNECTED);`
`114`		`- return;`
	`114`	`+ return netConnectionState;`
`115`	`115`	`}`
`116`	`116`	`Debug.print(DBG_VERBOSE, "Connected to Cellular Network");`
`117`	`117`	`}`
`@@ -130,6 +130,8 @@ void GSMConnectionHandler::check() {`
`130`	`130`	`}`
`131`	`131`	`lastConnectionTickTime = now;`
`132`	`132`	`}`
	`133`	`+`
	`134`	`+ return netConnectionState;`
`133`	`135`	`}`
`134`	`136`
`135`	`137`	`/******************************************************************************`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ bool LoRaConnectionHandler::available() {`
`104`	`104`	`return modem.available();`
`105`	`105`	`}`
`106`	`106`
`107`		`-void LoRaConnectionHandler::check() {`
	`107`	`+NetworkConnectionState LoRaConnectionHandler::check() {`
`108`	`108`
`109`	`109`	`unsigned long const now = millis();`
`110`	`110`	`int networkStatus = 0;`
`@@ -121,6 +121,8 @@ void LoRaConnectionHandler::check() {`
`121`	`121`	`case NetworkConnectionState::CLOSED: break;`
`122`	`122`	`}`
`123`	`123`	`}`
	`124`	`+`
	`125`	`+ return netConnectionState;`
`124`	`126`	`}`
`125`	`127`
`126`	`128`	`/******************************************************************************`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ unsigned long NBConnectionHandler::getTime() {`
`78`	`78`	`return nbAccess.getTime();`
`79`	`79`	`}`
`80`	`80`
`81`		`-void NBConnectionHandler::check() {`
	`81`	`+NetworkConnectionState NBConnectionHandler::check() {`
`82`	`82`	`unsigned long const now = millis();`
`83`	`83`	`int nbAccessAlive;`
`84`	`84`	`if (now - lastConnectionTickTime > connectionTickTimeInterval) {`
`@@ -96,7 +96,7 @@ void NBConnectionHandler::check() {`
`96`	`96`	`if (networkStatus == NB_NetworkStatus_t::ERROR) {`
`97`	`97`	`// NO FURTHER ACTION WILL FOLLOW THIS`
`98`	`98`	`changeConnectionState(NetworkConnectionState::ERROR);`
`99`		`- return;`
	`99`	`+ return netConnectionState;`
`100`	`100`	`}`
`101`	`101`	`Debug.print(DBG_INFO, "Sending PING to outer space...");`
`102`	`102`	`int pingResult;`
`@@ -106,11 +106,11 @@ void NBConnectionHandler::check() {`
`106`	`106`	`if (pingResult < 0) {`
`107`	`107`	`Debug.print(DBG_ERROR, "PING failed");`
`108`	`108`	`Debug.print(DBG_INFO, "Retrying in \"%d\" milliseconds", connectionTickTimeInterval);`
`109`		`- return;`
	`109`	`+ return netConnectionState;`
`110`	`110`	`} else {`
`111`	`111`	`Debug.print(DBG_INFO, "Connected to GPRS Network");`
`112`	`112`	`changeConnectionState(NetworkConnectionState::CONNECTED);`
`113`		`- return;`
	`113`	`+ return netConnectionState;`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`	`break;`
`@@ -119,7 +119,7 @@ void NBConnectionHandler::check() {`
`119`	`119`	`Debug.print(DBG_VERBOSE, "GPRS.isAccessAlive(): %d", nbAccessAlive);`
`120`	`120`	`if (nbAccessAlive != 1) {`
`121`	`121`	`changeConnectionState(NetworkConnectionState::DISCONNECTED);`
`122`		`- return;`
	`122`	`+ return netConnectionState;`
`123`	`123`	`}`
`124`	`124`	`Debug.print(DBG_VERBOSE, "Connected to Cellular Network");`
`125`	`125`	`}`
`@@ -138,6 +138,8 @@ void NBConnectionHandler::check() {`
`138`	`138`	`}`
`139`	`139`	`lastConnectionTickTime = now;`
`140`	`140`	`}`
	`141`	`+`
	`142`	`+ return netConnectionState;`
`141`	`143`	`}`
`142`	`144`
`143`	`145`	`/******************************************************************************`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ unsigned long WiFiConnectionHandler::getTime() {`
`50`	`50`	`#endif`
`51`	`51`	`}`
`52`	`52`
`53`		`-void WiFiConnectionHandler::check() {`
	`53`	`+NetworkConnectionState WiFiConnectionHandler::check() {`
`54`	`54`
`55`	`55`	`unsigned long const now = millis();`
`56`	`56`	`if((now - lastConnectionTickTime) > connectionTickTimeInterval)`
`@@ -68,6 +68,8 @@ void WiFiConnectionHandler::check() {`
`68`	`68`	`case NetworkConnectionState::CLOSED: break;`
`69`	`69`	`}`
`70`	`70`	`}`
	`71`	`+`
	`72`	`+ return netConnectionState;`
`71`	`73`	`}`
`72`	`74`
`73`	`75`	`/******************************************************************************`