[nrf noup] Fix various Wi-Fi issues with error code handling

LuDuda · markaj-nordic · commit 1e9f9b28141f · 2024-03-08T11:18:35.000+01:00
This commit handles a few issues with Wi-Fi connection or scanning:
 - Use wifi_status structure instead of incompatible WiFiRequestStatus
 - On connect error value &gt; 2 do not report success
 - On scan error value &gt; 1 do not report success
 - Provide value of mandatory LastConnectErrorValue attribute

Signed-off-by: Łukasz Duda &lt;lukasz.duda@nordicsemi.no&gt;
diff --git a/src/platform/nrfconnect/wifi/NrfWiFiDriver.cpp b/src/platform/nrfconnect/wifi/NrfWiFiDriver.cpp
@@ -103,8 +103,7 @@ CHIP_ERROR NrfWiFiDriver::Init(NetworkStatusChangeCallback * networkStatusChange
 
     if (mStagingNetwork.IsConfigured())
     {
-        WiFiManager::ConnectionHandling handling{ [] { Instance().OnNetworkStatusChanged(Status::kSuccess); },
-                                                  [] { Instance().OnNetworkStatusChanged(Status::kUnknownError); },
+        WiFiManager::ConnectionHandling handling{ [](int connStatus) { Instance().OnNetworkStatusChanged(connStatus); },
                                                   System::Clock::Seconds32{ kWiFiConnectNetworkTimeoutSeconds } };
         ReturnErrorOnFailure(
             WiFiManager::Instance().Connect(mStagingNetwork.GetSsidSpan(), mStagingNetwork.GetPassSpan(), handling));
@@ -113,8 +112,10 @@ CHIP_ERROR NrfWiFiDriver::Init(NetworkStatusChangeCallback * networkStatusChange
     return CHIP_NO_ERROR;
 }
 
-void NrfWiFiDriver::OnNetworkStatusChanged(Status status)
+void NrfWiFiDriver::OnNetworkStatusChanged(int connStatus)
 {
+    Status status = connStatus ? Status::kUnknownError : Status::kSuccess;
+
     if (status == Status::kSuccess)
     {
         ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Enabled);
@@ -127,7 +128,8 @@ void NrfWiFiDriver::OnNetworkStatusChanged(Status status)
         if (CHIP_NO_ERROR == WiFiManager::Instance().GetWiFiInfo(wifiInfo))
         {
             mpNetworkStatusChangeCallback->OnNetworkingStatusChange(status,
-                MakeOptional(ByteSpan(wifiInfo.mSsid, wifiInfo.mSsidLen)), NullOptional);
+                MakeOptional(ByteSpan(wifiInfo.mSsid, wifiInfo.mSsidLen)),
+                connStatus ? MakeOptional(connStatus) : NullOptional);
         }
     }
 
@@ -170,8 +172,7 @@ CHIP_ERROR NrfWiFiDriver::RevertConfiguration()
 
     if (mStagingNetwork.IsConfigured())
     {
-        WiFiManager::ConnectionHandling handling{ [] { Instance().OnNetworkStatusChanged(Status::kSuccess); },
-                                                  [] { Instance().OnNetworkStatusChanged(Status::kUnknownError); },
+        WiFiManager::ConnectionHandling handling{ [](int connStatus) { Instance().OnNetworkStatusChanged(connStatus); },
                                                   System::Clock::Seconds32{ kWiFiConnectNetworkTimeoutSeconds } };
         ReturnErrorOnFailure(
             WiFiManager::Instance().Connect(mStagingNetwork.GetSsidSpan(), mStagingNetwork.GetPassSpan(), handling));
@@ -224,8 +225,7 @@ Status NrfWiFiDriver::ReorderNetwork(ByteSpan networkId, uint8_t index, MutableC
 void NrfWiFiDriver::ConnectNetwork(ByteSpan networkId, ConnectCallback * callback)
 {
     Status status = Status::kSuccess;
-    WiFiManager::ConnectionHandling handling{ [] { Instance().OnNetworkStatusChanged(Status::kSuccess); },
-                                              [] { Instance().OnNetworkStatusChanged(Status::kUnknownError); },
+    WiFiManager::ConnectionHandling handling{ [](int connStatus) { Instance().OnNetworkStatusChanged(connStatus); },
                                               System::Clock::Seconds32{ kWiFiConnectNetworkTimeoutSeconds } };
 
     VerifyOrExit(mpConnectCallback == nullptr, status = Status::kUnknownError);
@@ -255,10 +255,10 @@ void NrfWiFiDriver::LoadFromStorage()
     mStagingNetwork = network;
 }
 
-void NrfWiFiDriver::OnScanWiFiNetworkDone(WiFiManager::WiFiRequestStatus status)
+void NrfWiFiDriver::OnScanWiFiNetworkDone(const wifi_status & status)
 {
     VerifyOrReturn(mScanCallback != nullptr);
-    mScanCallback->OnFinished(status == WiFiManager::WiFiRequestStatus::SUCCESS ? Status::kSuccess : Status::kUnknownError,
+    mScanCallback->OnFinished(status.status ? Status::kUnknownError : Status::kSuccess,
                               CharSpan(), &mScanResponseIterator);
     mScanCallback = nullptr;
 }
@@ -273,7 +273,7 @@ void NrfWiFiDriver::ScanNetworks(ByteSpan ssid, WiFiDriver::ScanCallback * callb
     mScanCallback    = callback;
     CHIP_ERROR error = WiFiManager::Instance().Scan(
         ssid, [](const WiFiScanResponse & response) { Instance().OnScanWiFiNetworkResult(response); },
-        [](WiFiManager::WiFiRequestStatus status) { Instance().OnScanWiFiNetworkDone(status); });
+        [](const wifi_status & status) { Instance().OnScanWiFiNetworkDone(status); });
 
     if (error != CHIP_NO_ERROR)
     {
diff --git a/src/platform/nrfconnect/wifi/NrfWiFiDriver.h b/src/platform/nrfconnect/wifi/NrfWiFiDriver.h
@@ -93,9 +93,9 @@ class NrfWiFiDriver final : public WiFiDriver
         return sInstance;
     }
 
-    void OnNetworkStatusChanged(Status status);
+    void OnNetworkStatusChanged(int status);
     void OnScanWiFiNetworkResult(const WiFiScanResponse & result);
-    void OnScanWiFiNetworkDone(WiFiManager::WiFiRequestStatus status);
+    void OnScanWiFiNetworkDone(const wifi_status & status);
 
 private:
     void LoadFromStorage();
diff --git a/src/platform/nrfconnect/wifi/WiFiManager.cpp b/src/platform/nrfconnect/wifi/WiFiManager.cpp
@@ -210,9 +210,8 @@ CHIP_ERROR WiFiManager::Connect(const ByteSpan & ssid, const ByteSpan & credenti
 {
     ChipLogDetail(DeviceLayer, "Connecting to WiFi network: %*s", ssid.size(), ssid.data());
 
-    mHandling.mOnConnectionSuccess = handling.mOnConnectionSuccess;
-    mHandling.mOnConnectionFailed  = handling.mOnConnectionFailed;
-    mHandling.mConnectionTimeout   = handling.mConnectionTimeout;
+    mHandling.mOnConnectionDone  = handling.mOnConnectionDone;
+    mHandling.mConnectionTimeout = handling.mConnectionTimeout;
 
     mWiFiState = WIFI_STATE_ASSOCIATING;
 
@@ -343,11 +342,10 @@ void WiFiManager::ScanDoneHandler(Platform::UniquePtr<uint8_t> data)
 {
     CHIP_ERROR err = SystemLayer().ScheduleLambda([capturedData = data.get()] {
         Platform::UniquePtr<uint8_t> safePtr(capturedData);
-        uint8_t * rawData               = safePtr.get();
-        const wifi_status * status      = reinterpret_cast<const wifi_status *>(rawData);
-        WiFiRequestStatus requestStatus = static_cast<WiFiRequestStatus>(status->status);
+        uint8_t * rawData          = safePtr.get();
+        const wifi_status * status = reinterpret_cast<const wifi_status *>(rawData);
 
-        if (requestStatus == WiFiRequestStatus::FAILURE)
+        if (status->status)
         {
             ChipLogError(DeviceLayer, "Wi-Fi scan finalization failure (%d)", status->status);
         }
@@ -358,7 +356,7 @@ void WiFiManager::ScanDoneHandler(Platform::UniquePtr<uint8_t> data)
 
         if (Instance().mScanDoneCallback && !Instance().mInternalScan)
         {
-            Instance().mScanDoneCallback(requestStatus);
+            Instance().mScanDoneCallback(*status);
             // restore the connection state from before the scan request was issued
             Instance().mWiFiState = Instance().mCachedWiFiState;
             return;
@@ -379,13 +377,13 @@ void WiFiManager::ScanDoneHandler(Platform::UniquePtr<uint8_t> data)
 
             Instance().mWiFiState = WIFI_STATE_ASSOCIATING;
 
-            if (net_mgmt(NET_REQUEST_WIFI_CONNECT, Instance().mNetIf, &(Instance().mWiFiParams.mParams),
-                         sizeof(wifi_connect_req_params)))
+            if (int connStatus = net_mgmt(NET_REQUEST_WIFI_CONNECT, Instance().mNetIf, &(Instance().mWiFiParams.mParams),
+                                          sizeof(wifi_connect_req_params)))
             {
                 ChipLogError(DeviceLayer, "Connection request failed");
-                if (Instance().mHandling.mOnConnectionFailed)
+                if (Instance().mHandling.mOnConnectionDone)
                 {
-                    Instance().mHandling.mOnConnectionFailed();
+                    Instance().mHandling.mOnConnectionDone(connStatus);
                 }
                 Instance().mWiFiState = WIFI_STATE_DISCONNECTED;
                 return;
@@ -424,15 +422,14 @@ void WiFiManager::ConnectHandler(Platform::UniquePtr<uint8_t> data)
         Platform::UniquePtr<uint8_t> safePtr(capturedData);
         uint8_t * rawData               = safePtr.get();
         const wifi_status * status      = reinterpret_cast<const wifi_status *>(rawData);
-        WiFiRequestStatus requestStatus = static_cast<WiFiRequestStatus>(status->status);
 
-        if (requestStatus == WiFiRequestStatus::FAILURE || requestStatus == WiFiRequestStatus::TERMINATED)
+        if (status->status)
         {
             ChipLogProgress(DeviceLayer, "Connection to WiFi network failed or was terminated by another request");
             Instance().mWiFiState = WIFI_STATE_DISCONNECTED;
-            if (Instance().mHandling.mOnConnectionFailed)
+            if (Instance().mHandling.mOnConnectionDone)
             {
-                Instance().mHandling.mOnConnectionFailed();
+                Instance().mHandling.mOnConnectionDone(status->status);
             }
         }
         else // The connection has been established successfully.
@@ -444,9 +441,9 @@ void WiFiManager::ConnectHandler(Platform::UniquePtr<uint8_t> data)
 
             ChipLogProgress(DeviceLayer, "Connected to WiFi network");
             Instance().mWiFiState = WIFI_STATE_COMPLETED;
-            if (Instance().mHandling.mOnConnectionSuccess)
+            if (Instance().mHandling.mOnConnectionDone)
             {
-                Instance().mHandling.mOnConnectionSuccess();
+                Instance().mHandling.mOnConnectionDone(status->status);
             }
             Instance().PostConnectivityStatusChange(kConnectivity_Established);
 
diff --git a/src/platform/nrfconnect/wifi/WiFiManager.h b/src/platform/nrfconnect/wifi/WiFiManager.h
@@ -88,16 +88,9 @@ class Map
 class WiFiManager
 {
 public:
-    enum WiFiRequestStatus : int
-    {
-        SUCCESS    = 0,
-        FAILURE    = 1,
-        TERMINATED = 2
-    };
-
     using ScanResultCallback = void (*)(const NetworkCommissioning::WiFiScanResponse &);
-    using ScanDoneCallback   = void (*)(WiFiRequestStatus);
-    using ConnectionCallback = void (*)();
+    using ScanDoneCallback   = void (*)(const wifi_status &);
+    using ConnectionCallback = void (*)(int);
 
     enum class StationStatus : uint8_t
     {
@@ -120,8 +113,7 @@ class WiFiManager
 
     struct ConnectionHandling
     {
-        ConnectionCallback mOnConnectionSuccess{};
-        ConnectionCallback mOnConnectionFailed{};
+        ConnectionCallback mOnConnectionDone{};
         System::Clock::Seconds32 mConnectionTimeout{};
     };
 

Original file line number	Diff line number	Diff line change
`@@ -103,8 +103,7 @@ CHIP_ERROR NrfWiFiDriver::Init(NetworkStatusChangeCallback * networkStatusChange`
`103`	`103`
`104`	`104`	`if (mStagingNetwork.IsConfigured())`
`105`	`105`	`{`
`106`		`- WiFiManager::ConnectionHandling handling{ [] { Instance().OnNetworkStatusChanged(Status::kSuccess); },`
`107`		`- [] { Instance().OnNetworkStatusChanged(Status::kUnknownError); },`
	`106`	`+ WiFiManager::ConnectionHandling handling{ [](int connStatus) { Instance().OnNetworkStatusChanged(connStatus); },`
`108`	`107`	`System::Clock::Seconds32{ kWiFiConnectNetworkTimeoutSeconds } };`
`109`	`108`	`ReturnErrorOnFailure(`
`110`	`109`	`WiFiManager::Instance().Connect(mStagingNetwork.GetSsidSpan(), mStagingNetwork.GetPassSpan(), handling));`
`@@ -113,8 +112,10 @@ CHIP_ERROR NrfWiFiDriver::Init(NetworkStatusChangeCallback * networkStatusChange`
`113`	`112`	`return CHIP_NO_ERROR;`
`114`	`113`	`}`
`115`	`114`
`116`		`-void NrfWiFiDriver::OnNetworkStatusChanged(Status status)`
	`115`	`+void NrfWiFiDriver::OnNetworkStatusChanged(int connStatus)`
`117`	`116`	`{`
	`117`	`+ Status status = connStatus ? Status::kUnknownError : Status::kSuccess;`
	`118`	`+`
`118`	`119`	`if (status == Status::kSuccess)`
`119`	`120`	`{`
`120`	`121`	`ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Enabled);`
`@@ -127,7 +128,8 @@ void NrfWiFiDriver::OnNetworkStatusChanged(Status status)`
`127`	`128`	`if (CHIP_NO_ERROR == WiFiManager::Instance().GetWiFiInfo(wifiInfo))`
`128`	`129`	`{`
`129`	`130`	`mpNetworkStatusChangeCallback->OnNetworkingStatusChange(status,`
`130`		`- MakeOptional(ByteSpan(wifiInfo.mSsid, wifiInfo.mSsidLen)), NullOptional);`
	`131`	`+ MakeOptional(ByteSpan(wifiInfo.mSsid, wifiInfo.mSsidLen)),`
	`132`	`+ connStatus ? MakeOptional(connStatus) : NullOptional);`
`131`	`133`	`}`
`132`	`134`	`}`
`133`	`135`
`@@ -170,8 +172,7 @@ CHIP_ERROR NrfWiFiDriver::RevertConfiguration()`
`170`	`172`
`171`	`173`	`if (mStagingNetwork.IsConfigured())`
`172`	`174`	`{`
`173`		`- WiFiManager::ConnectionHandling handling{ [] { Instance().OnNetworkStatusChanged(Status::kSuccess); },`
`174`		`- [] { Instance().OnNetworkStatusChanged(Status::kUnknownError); },`
	`175`	`+ WiFiManager::ConnectionHandling handling{ [](int connStatus) { Instance().OnNetworkStatusChanged(connStatus); },`
`175`	`176`	`System::Clock::Seconds32{ kWiFiConnectNetworkTimeoutSeconds } };`
`176`	`177`	`ReturnErrorOnFailure(`
`177`	`178`	`WiFiManager::Instance().Connect(mStagingNetwork.GetSsidSpan(), mStagingNetwork.GetPassSpan(), handling));`
`@@ -224,8 +225,7 @@ Status NrfWiFiDriver::ReorderNetwork(ByteSpan networkId, uint8_t index, MutableC`
`224`	`225`	`void NrfWiFiDriver::ConnectNetwork(ByteSpan networkId, ConnectCallback * callback)`
`225`	`226`	`{`
`226`	`227`	`Status status = Status::kSuccess;`
`227`		`- WiFiManager::ConnectionHandling handling{ [] { Instance().OnNetworkStatusChanged(Status::kSuccess); },`
`228`		`- [] { Instance().OnNetworkStatusChanged(Status::kUnknownError); },`
	`228`	`+ WiFiManager::ConnectionHandling handling{ [](int connStatus) { Instance().OnNetworkStatusChanged(connStatus); },`
`229`	`229`	`System::Clock::Seconds32{ kWiFiConnectNetworkTimeoutSeconds } };`
`230`	`230`
`231`	`231`	`VerifyOrExit(mpConnectCallback == nullptr, status = Status::kUnknownError);`
`@@ -255,10 +255,10 @@ void NrfWiFiDriver::LoadFromStorage()`
`255`	`255`	`mStagingNetwork = network;`
`256`	`256`	`}`
`257`	`257`
`258`		`-void NrfWiFiDriver::OnScanWiFiNetworkDone(WiFiManager::WiFiRequestStatus status)`
	`258`	`+void NrfWiFiDriver::OnScanWiFiNetworkDone(const wifi_status & status)`
`259`	`259`	`{`
`260`	`260`	`VerifyOrReturn(mScanCallback != nullptr);`
`261`		`- mScanCallback->OnFinished(status == WiFiManager::WiFiRequestStatus::SUCCESS ? Status::kSuccess : Status::kUnknownError,`
	`261`	`+ mScanCallback->OnFinished(status.status ? Status::kUnknownError : Status::kSuccess,`
`262`	`262`	`CharSpan(), &mScanResponseIterator);`
`263`	`263`	`mScanCallback = nullptr;`
`264`	`264`	`}`
`@@ -273,7 +273,7 @@ void NrfWiFiDriver::ScanNetworks(ByteSpan ssid, WiFiDriver::ScanCallback * callb`
`273`	`273`	`mScanCallback = callback;`
`274`	`274`	`CHIP_ERROR error = WiFiManager::Instance().Scan(`
`275`	`275`	`ssid, [](const WiFiScanResponse & response) { Instance().OnScanWiFiNetworkResult(response); },`
`276`		`- [](WiFiManager::WiFiRequestStatus status) { Instance().OnScanWiFiNetworkDone(status); });`
	`276`	`+ [](const wifi_status & status) { Instance().OnScanWiFiNetworkDone(status); });`
`277`	`277`
`278`	`278`	`if (error != CHIP_NO_ERROR)`
`279`	`279`	`{`
Original file line number	Diff line number	Diff line change
`@@ -210,9 +210,8 @@ CHIP_ERROR WiFiManager::Connect(const ByteSpan & ssid, const ByteSpan & credenti`
`210`	`210`	`{`
`211`	`211`	`ChipLogDetail(DeviceLayer, "Connecting to WiFi network: %*s", ssid.size(), ssid.data());`
`212`	`212`
`213`		`- mHandling.mOnConnectionSuccess = handling.mOnConnectionSuccess;`
`214`		`- mHandling.mOnConnectionFailed = handling.mOnConnectionFailed;`
`215`		`- mHandling.mConnectionTimeout = handling.mConnectionTimeout;`
	`213`	`+ mHandling.mOnConnectionDone = handling.mOnConnectionDone;`
	`214`	`+ mHandling.mConnectionTimeout = handling.mConnectionTimeout;`
`216`	`215`
`217`	`216`	`mWiFiState = WIFI_STATE_ASSOCIATING;`
`218`	`217`
`@@ -343,11 +342,10 @@ void WiFiManager::ScanDoneHandler(Platform::UniquePtr<uint8_t> data)`
`343`	`342`	`{`
`344`	`343`	`CHIP_ERROR err = SystemLayer().ScheduleLambda([capturedData = data.get()] {`
`345`	`344`	`Platform::UniquePtr<uint8_t> safePtr(capturedData);`
`346`		`- uint8_t * rawData = safePtr.get();`
`347`		`- const wifi_status * status = reinterpret_cast<const wifi_status *>(rawData);`
`348`		`- WiFiRequestStatus requestStatus = static_cast<WiFiRequestStatus>(status->status);`
	`345`	`+ uint8_t * rawData = safePtr.get();`
	`346`	`+ const wifi_status * status = reinterpret_cast<const wifi_status *>(rawData);`
`349`	`347`
`350`		`- if (requestStatus == WiFiRequestStatus::FAILURE)`
	`348`	`+ if (status->status)`
`351`	`349`	`{`
`352`	`350`	`ChipLogError(DeviceLayer, "Wi-Fi scan finalization failure (%d)", status->status);`
`353`	`351`	`}`
`@@ -358,7 +356,7 @@ void WiFiManager::ScanDoneHandler(Platform::UniquePtr<uint8_t> data)`
`358`	`356`
`359`	`357`	`if (Instance().mScanDoneCallback && !Instance().mInternalScan)`
`360`	`358`	`{`
`361`		`- Instance().mScanDoneCallback(requestStatus);`
	`359`	`+ Instance().mScanDoneCallback(*status);`
`362`	`360`	`// restore the connection state from before the scan request was issued`
`363`	`361`	`Instance().mWiFiState = Instance().mCachedWiFiState;`
`364`	`362`	`return;`
`@@ -379,13 +377,13 @@ void WiFiManager::ScanDoneHandler(Platform::UniquePtr<uint8_t> data)`
`379`	`377`
`380`	`378`	`Instance().mWiFiState = WIFI_STATE_ASSOCIATING;`
`381`	`379`
`382`		`- if (net_mgmt(NET_REQUEST_WIFI_CONNECT, Instance().mNetIf, &(Instance().mWiFiParams.mParams),`
`383`		`- sizeof(wifi_connect_req_params)))`
	`380`	`+ if (int connStatus = net_mgmt(NET_REQUEST_WIFI_CONNECT, Instance().mNetIf, &(Instance().mWiFiParams.mParams),`
	`381`	`+ sizeof(wifi_connect_req_params)))`
`384`	`382`	`{`
`385`	`383`	`ChipLogError(DeviceLayer, "Connection request failed");`
`386`		`- if (Instance().mHandling.mOnConnectionFailed)`
	`384`	`+ if (Instance().mHandling.mOnConnectionDone)`
`387`	`385`	`{`
`388`		`- Instance().mHandling.mOnConnectionFailed();`
	`386`	`+ Instance().mHandling.mOnConnectionDone(connStatus);`
`389`	`387`	`}`
`390`	`388`	`Instance().mWiFiState = WIFI_STATE_DISCONNECTED;`
`391`	`389`	`return;`
`@@ -424,15 +422,14 @@ void WiFiManager::ConnectHandler(Platform::UniquePtr<uint8_t> data)`
`424`	`422`	`Platform::UniquePtr<uint8_t> safePtr(capturedData);`
`425`	`423`	`uint8_t * rawData = safePtr.get();`
`426`	`424`	`const wifi_status * status = reinterpret_cast<const wifi_status *>(rawData);`
`427`		`- WiFiRequestStatus requestStatus = static_cast<WiFiRequestStatus>(status->status);`
`428`	`425`
`429`		`- if (requestStatus == WiFiRequestStatus::FAILURE \|\| requestStatus == WiFiRequestStatus::TERMINATED)`
	`426`	`+ if (status->status)`
`430`	`427`	`{`
`431`	`428`	`ChipLogProgress(DeviceLayer, "Connection to WiFi network failed or was terminated by another request");`
`432`	`429`	`Instance().mWiFiState = WIFI_STATE_DISCONNECTED;`
`433`		`- if (Instance().mHandling.mOnConnectionFailed)`
	`430`	`+ if (Instance().mHandling.mOnConnectionDone)`
`434`	`431`	`{`
`435`		`- Instance().mHandling.mOnConnectionFailed();`
	`432`	`+ Instance().mHandling.mOnConnectionDone(status->status);`
`436`	`433`	`}`
`437`	`434`	`}`
`438`	`435`	`else // The connection has been established successfully.`
`@@ -444,9 +441,9 @@ void WiFiManager::ConnectHandler(Platform::UniquePtr<uint8_t> data)`
`444`	`441`
`445`	`442`	`ChipLogProgress(DeviceLayer, "Connected to WiFi network");`
`446`	`443`	`Instance().mWiFiState = WIFI_STATE_COMPLETED;`
`447`		`- if (Instance().mHandling.mOnConnectionSuccess)`
	`444`	`+ if (Instance().mHandling.mOnConnectionDone)`
`448`	`445`	`{`
`449`		`- Instance().mHandling.mOnConnectionSuccess();`
	`446`	`+ Instance().mHandling.mOnConnectionDone(status->status);`
`450`	`447`	`}`
`451`	`448`	`Instance().PostConnectivityStatusChange(kConnectivity_Established);`
`452`	`449`