Check internet availability

src/CatM1ConnectionHandler.cpp

@@ -64,11 +64,7 @@ NetworkConnectionState CatM1ConnectionHandler::update_handleInit()
   pinMode(ON_MKR2, OUTPUT);
   digitalWrite(ON_MKR2, HIGH);
 #endif
-  return NetworkConnectionState::CONNECTING;
-}
 
-NetworkConnectionState CatM1ConnectionHandler::update_handleConnecting()
-{
   if(!GSM.begin(
     _settings.catm1.pin,
     _settings.catm1.apn,
@@ -80,8 +76,33 @@ NetworkConnectionState CatM1ConnectionHandler::update_handleConnecting()
     Debug.print(DBG_ERROR, F("The board was not able to register to the network..."));
     return NetworkConnectionState::ERROR;
   }
-  Debug.print(DBG_INFO, F("Connected to Network"));
-  return NetworkConnectionState::CONNECTED;
+  return NetworkConnectionState::CONNECTING;
+}
+
+NetworkConnectionState CatM1ConnectionHandler::update_handleConnecting()
+{
+  if (!GSM.isConnected())
+  {
+    return NetworkConnectionState::INIT;
+  }
+
+  if(!_check_internet_availability){
+    return NetworkConnectionState::CONNECTED;
+  }
+
+  int ping_result = GSM.ping("time.arduino.cc");
+  Debug.print(DBG_INFO, F("GSM.ping(): %d"), ping_result);
+  if (ping_result < 0)
+  {
+    Debug.print(DBG_ERROR, F("Internet check failed"));
+    Debug.print(DBG_INFO, F("Retrying in  \"%d\" milliseconds"), CHECK_INTERVAL_TABLE[static_cast<unsigned int>(NetworkConnectionState::CONNECTING)]);
+    return NetworkConnectionState::CONNECTING;
+  }
+  else
+  {
+    Debug.print(DBG_INFO, F("Connected to Internet"));
+    return NetworkConnectionState::CONNECTED;
+  }
 }
 
 NetworkConnectionState CatM1ConnectionHandler::update_handleConnected()

src/CellularConnectionHandler.cpp

@@ -62,16 +62,31 @@ NetworkConnectionState CellularConnectionHandler::update_handleInit()
     Debug.print(DBG_ERROR, F("SIM not present or wrong PIN"));
     return NetworkConnectionState::ERROR;
   }
-  return NetworkConnectionState::CONNECTING;
-}
 
-NetworkConnectionState CellularConnectionHandler::update_handleConnecting()
-{
   if (!_cellular.connect(String(_settings.cell.apn), String(_settings.cell.login), String(_settings.cell.pass))) {
     Debug.print(DBG_ERROR, F("The board was not able to register to the network..."));
     return NetworkConnectionState::ERROR;
   }
   Debug.print(DBG_INFO, F("Connected to Network"));
+  return NetworkConnectionState::CONNECTING;
+}
+
+NetworkConnectionState CellularConnectionHandler::update_handleConnecting()
+{
+  if (!_cellular.isConnectedToInternet()) {
+    return NetworkConnectionState::INIT;
+  }
+
+  if (!_check_internet_availability) {
+    return NetworkConnectionState::CONNECTED;
+  }
+
+  if(getTime() == 0){
+    Debug.print(DBG_ERROR, F("Internet check failed"));
+    Debug.print(DBG_INFO, F("Retrying in  \"%d\" milliseconds"), CHECK_INTERVAL_TABLE[static_cast<unsigned int>(NetworkConnectionState::CONNECTING)]);
+    return NetworkConnectionState::CONNECTING;
+  }
+
   return NetworkConnectionState::CONNECTED;
 }
 

src/ConnectionHandlerDefinitions.h

@@ -191,12 +191,12 @@ enum class NetworkAdapter {
 
 static unsigned int const CHECK_INTERVAL_TABLE[] =
 {
-  /* INIT          */ 100,
 #if defined(BOARD_HAS_NOTECARD) || defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-  /* CONNECTING    */ 4000,
+  /* INIT    */ 4000,
 #else
-  /* CONNECTING    */ 500,
+  /* INIT          */ 500,
 #endif
+  /* CONNECTING    */ 500,
   /* CONNECTED     */ 10000,
   /* DISCONNECTING */ 100,
   /* DISCONNECTED  */ 1000,

src/ConnectionHandlerInterface.cpp

@@ -29,6 +29,7 @@ ConnectionHandler::ConnectionHandler(bool const keep_alive, NetworkAdapter inter
 : _keep_alive{keep_alive}
 , _interface{interface}
 , _lastConnectionTickTime{millis()}
+, _check_internet_availability{false}
 , _current_net_connection_state{NetworkConnectionState::INIT}
 {
 

src/ConnectionHandlerInterface.h

@@ -76,6 +76,9 @@ class ConnectionHandler {
 
     virtual void connect();
     virtual void disconnect();
+    void enableCheckInternetAvailability(bool enable) {
+      _check_internet_availability = enable;
+    }
 
     virtual void addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback);
     void addConnectCallback(OnNetworkEventCallback callback) __attribute__((deprecated));
@@ -106,6 +109,7 @@ class ConnectionHandler {
     virtual void updateCallback(NetworkConnectionState next_net_connection_state);
 
     bool _keep_alive;
+    bool _check_internet_availability;
     NetworkAdapter _interface;
 
     virtual NetworkConnectionState update_handleInit         () = 0;

src/EthernetConnectionHandler.cpp

@@ -20,6 +20,7 @@
 
 #ifdef BOARD_HAS_ETHERNET /* Only compile if the board has ethernet */
 #include "EthernetConnectionHandler.h"
+#include <Udp.h>
 
 /******************************************************************************
    CTOR/DTOR
@@ -72,11 +73,6 @@ NetworkConnectionState EthernetConnectionHandler::update_handleInit()
     Debug.print(DBG_ERROR, F("Error, ethernet shield was not found."));
     return NetworkConnectionState::ERROR;
   }
-  return NetworkConnectionState::CONNECTING;
-}
-
-NetworkConnectionState EthernetConnectionHandler::update_handleConnecting()
-{
   IPAddress ip(_settings.eth.ip.type, _settings.eth.ip.bytes);
 
   // An ip address is provided -> static ip configuration
@@ -91,7 +87,7 @@ NetworkConnectionState EthernetConnectionHandler::update_handleConnecting()
       Debug.print(DBG_ERROR, F("Failed to configure Ethernet, check cable connection"));
       Debug.print(DBG_VERBOSE, "timeout: %d, response timeout: %d",
         _settings.eth.timeout, _settings.eth.response_timeout);
-      return NetworkConnectionState::CONNECTING;
+      return NetworkConnectionState::INIT;
     }
   // An ip address is not provided -> dhcp configuration
   } else {
@@ -100,11 +96,37 @@ NetworkConnectionState EthernetConnectionHandler::update_handleConnecting()
       Debug.print(DBG_VERBOSE, "timeout: %d, response timeout: %d",
         _settings.eth.timeout, _settings.eth.response_timeout);
 
-      return NetworkConnectionState::CONNECTING;
+      return NetworkConnectionState::INIT;
     }
   }
 
-  return NetworkConnectionState::CONNECTED;
+  return NetworkConnectionState::CONNECTING;
+}
+
+NetworkConnectionState EthernetConnectionHandler::update_handleConnecting()
+{
+  if (Ethernet.linkStatus() == LinkOFF) {
+    return NetworkConnectionState::INIT;
+  }
+
+  if (!_check_internet_availability) {
+    return NetworkConnectionState::CONNECTED;
+  }
+
+  int ping_result = Ethernet.ping("time.arduino.cc");
+  Debug.print(DBG_INFO, F("Ethernet.ping(): %d"), ping_result);
+  if (ping_result < 0)
+  {
+    Debug.print(DBG_ERROR, F("Internet check failed"));
+    Debug.print(DBG_INFO, F("Retrying in  \"%d\" milliseconds"), CHECK_INTERVAL_TABLE[static_cast<unsigned int>(NetworkConnectionState::CONNECTING)]);
+    return NetworkConnectionState::CONNECTING;
+  }
+  else
+  {
+    Debug.print(DBG_INFO, F("Connected to Internet"));
+    return NetworkConnectionState::CONNECTED;
+  }
+
 }
 
 NetworkConnectionState EthernetConnectionHandler::update_handleConnected()

src/GSMConnectionHandler.cpp

@@ -53,6 +53,8 @@ GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, c
 : ConnectionHandler{keep_alive, NetworkAdapter::GSM}
 {
   _settings.type = NetworkAdapter::GSM;
+  // To keep the backward compatibility, the user can call enableCheckInternetAvailability(false) for disabling the check
+  _check_internet_availability = true;
   strncpy(_settings.gsm.pin, pin, sizeof(_settings.gsm.pin)-1);
   strncpy(_settings.gsm.apn, apn, sizeof(_settings.gsm.apn)-1);
   strncpy(_settings.gsm.login, login, sizeof(_settings.gsm.login)-1);
@@ -105,6 +107,10 @@ NetworkConnectionState GSMConnectionHandler::update_handleInit()
 
 NetworkConnectionState GSMConnectionHandler::update_handleConnecting()
 {
+  if(!_check_internet_availability){
+    return NetworkConnectionState::CONNECTED;
+  }
+
   Debug.print(DBG_INFO, F("Sending PING to outer space..."));
   int const ping_result = _gprs.ping("time.arduino.cc");
   Debug.print(DBG_INFO, F("GPRS.ping(): %d"), ping_result);

src/GenericConnectionHandler.cpp

@@ -37,6 +37,7 @@ bool GenericConnectionHandler::updateSetting(const models::NetworkSetting& s) {
     if(_ch != nullptr) {
         _interface = s.type;
         _ch->setKeepAlive(_keep_alive);
+        _ch->enableCheckInternetAvailability(_check_internet_availability);
         return _ch->updateSetting(s);
     } else {
         _interface = NetworkAdapter::NONE;

src/WiFiConnectionHandler.cpp

@@ -96,11 +96,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit()
 #else
   WiFi.mode(WIFI_STA);
 #endif /* #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32) */
-  return NetworkConnectionState::CONNECTING;
-}
 
-NetworkConnectionState WiFiConnectionHandler::update_handleConnecting()
-{
   if (WiFi.status() != WL_CONNECTED)
   {
     WiFi.begin(_settings.wifi.ssid, _settings.wifi.pwd);
@@ -120,7 +116,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting()
     Debug.print(DBG_ERROR, F("Connection to \"%s\" failed"), _settings.wifi.ssid);
     Debug.print(DBG_INFO, F("Retrying in  \"%d\" milliseconds"), CHECK_INTERVAL_TABLE[static_cast<unsigned int>(NetworkConnectionState::CONNECTING)]);
 #endif
-    return NetworkConnectionState::CONNECTING;
+    return NetworkConnectionState::INIT;
   }
   else
   {
@@ -130,8 +126,33 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting()
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
   configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov");
 #endif
+    return NetworkConnectionState::CONNECTING;
+  }
+}
+
+NetworkConnectionState WiFiConnectionHandler::update_handleConnecting()
+{
+  if (WiFi.status() != WL_CONNECTED){
+    return NetworkConnectionState::INIT;
+  }
+
+  if(!_check_internet_availability){
     return NetworkConnectionState::CONNECTED;
   }
+
+  #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32)
+  int ping_result = WiFi.ping("time.arduino.cc");
+  Debug.print(DBG_INFO, F("WiFi.ping(): %d"), ping_result);
+  if (ping_result < 0)
+  {
+    Debug.print(DBG_ERROR, F("Internet check failed"));
+    Debug.print(DBG_INFO, F("Retrying in  \"%d\" milliseconds"), CHECK_INTERVAL_TABLE[static_cast<unsigned int>(NetworkConnectionState::CONNECTING)]);
+    return NetworkConnectionState::CONNECTING;
+  }
+  #endif
+  Debug.print(DBG_INFO, F("Connected to Internet"));
+  return NetworkConnectionState::CONNECTED;
+
 }
 
 NetworkConnectionState WiFiConnectionHandler::update_handleConnected()