[WiFi][Shell] Wifi Shell updates to improve shell commands.

- "wifi connect" command was improved to work with preset credentials or with credentials entered after
- "wifi add" command was created to add network credentials
- "wifi remove" command was created to remove network credentials
- "wifi disconnect" command was created to disconnect from connected WiFi network
- "wifi scan" command was added to provide the user the available WiFi networks

Author: mihai-ignat

src/include/platform/ConnectivityManager.h

@@ -30,6 +30,7 @@
 #include <lib/support/CodeUtils.h>
 #include <platform/CHIPDeviceConfig.h>
 #include <platform/CHIPDeviceEvent.h>
+#include <platform/NetworkCommissioning.h>
 
 #include <app/util/basic-types.h>
 
@@ -162,6 +163,9 @@ class ConnectivityManager
     void SetDelegate(ConnectivityManagerDelegate * delegate) { mDelegate = delegate; }
     ConnectivityManagerDelegate * GetDelegate() const { return mDelegate; }
 
+    void SetDriver(chip::DeviceLayer::NetworkCommissioning::WiFiDriver * driver) { mDriver = driver; }
+    chip::DeviceLayer::NetworkCommissioning::WiFiDriver * GetDriver() const { return mDriver; }
+
     chip::Inet::EndPointManager<Inet::UDPEndPoint> & UDPEndPointManager();
 
 #if INET_CONFIG_ENABLE_TCP_ENDPOINT
@@ -190,6 +194,10 @@ class ConnectivityManager
     void MaintainOnDemandWiFiAP();
     System::Clock::Timeout GetWiFiAPIdleTimeout();
     void SetWiFiAPIdleTimeout(System::Clock::Timeout val);
+    CHIP_ERROR GetNetworkSSID(char * ssid);
+    CHIP_ERROR GetNetworkPassword(char * credentials);
+    CHIP_ERROR DisconnectNetwork(void);
+
 
     // Thread Methods
     ThreadMode GetThreadMode();
@@ -236,7 +244,8 @@ class ConnectivityManager
     static const char * CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode);
 
 private:
-    ConnectivityManagerDelegate * mDelegate = nullptr;
+    ConnectivityManagerDelegate * mDelegate                       = nullptr;
+    chip::DeviceLayer::NetworkCommissioning::WiFiDriver * mDriver = nullptr;
 
     // ===== Members for internal use by the following friends.
 
@@ -606,5 +615,20 @@ inline void ConnectivityManager::OnWiFiStationProvisionChange()
     static_cast<ImplClass *>(this)->_OnWiFiStationProvisionChange();
 }
 
+inline CHIP_ERROR ConnectivityManager::GetNetworkSSID(char * ssid)
+{
+    return static_cast<ImplClass *>(this)->_GetNetworkSSID(ssid);
+}
+
+inline CHIP_ERROR ConnectivityManager::GetNetworkPassword(char * credentials)
+{
+    return static_cast<ImplClass *>(this)->_GetNetworkPassword(credentials);
+}
+
+inline CHIP_ERROR ConnectivityManager::DisconnectNetwork(void)
+{
+    return static_cast<ImplClass *>(this)->_DisconnectNetwork();
+}
+
 } // namespace DeviceLayer
 } // namespace chip

src/include/platform/internal/GenericConnectivityManagerImpl_NoWiFi.h

@@ -74,6 +74,9 @@ class GenericConnectivityManagerImpl_NoWiFi
     bool _CanStartWiFiScan();
     void _OnWiFiScanDone();
     void _OnWiFiStationProvisionChange();
+    CHIP_ERROR _GetNetworkSSID(char * ssid);
+    CHIP_ERROR _GetNetworkPassword(char * credentials);
+    CHIP_ERROR _DisconnectNetwork(void);
     static const char * _WiFiStationModeToStr(ConnectivityManager::WiFiStationMode mode);
     static const char * _WiFiAPModeToStr(ConnectivityManager::WiFiAPMode mode);
     static const char * _WiFiStationStateToStr(ConnectivityManager::WiFiStationState state);
@@ -221,6 +224,24 @@ inline const char * GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_WiFiAPSta
     return nullptr;
 }
 
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_GetNetworkSSID(char * ssid)
+{
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+}
+
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_GetNetworkPassword(char * credentials)
+{
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+}
+
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_DisconnectNetwork(void)
+{
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+}
+
 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace chip

src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h

@@ -80,6 +80,9 @@ class GenericConnectivityManagerImpl_WiFi
 #if CHIP_CONFIG_ENABLE_ICD_SERVER && !CHIP_DEVICE_CONFIG_ENABLE_THREAD
     CHIP_ERROR _SetPollingInterval(System::Clock::Milliseconds32 pollingInterval);
 #endif
+    CHIP_ERROR _GetNetworkSSID(char * ssid);
+    CHIP_ERROR _GetNetworkPassword(char * credentials);
+    CHIP_ERROR _DisconnectNetwork(void);
     static const char * _WiFiStationModeToStr(ConnectivityManager::WiFiStationMode mode);
     static const char * _WiFiAPModeToStr(ConnectivityManager::WiFiAPMode mode);
     static const char * _WiFiStationStateToStr(ConnectivityManager::WiFiStationState state);
@@ -193,6 +196,24 @@ inline CHIP_ERROR GenericConnectivityManagerImpl_WiFi<ImplClass>::_SetPollingInt
 }
 #endif
 
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl_WiFi<ImplClass>::_GetNetworkSSID(char * ssid)
+{
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+}
+
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl_WiFi<ImplClass>::_GetNetworkPassword(char * credentials)
+{
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+}
+
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl_WiFi<ImplClass>::_DisconnectNetwork(void)
+{
+    return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
+}
+
 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace chip

src/lib/shell/commands/WiFi.cpp

@@ -19,11 +19,14 @@
 #include <lib/shell/Engine.h>
 #include <lib/shell/commands/Help.h>
 #include <lib/shell/streamer.h>
+#include <lib/support/Span.h>
 #include <platform/CHIPDeviceLayer.h>
 #include <platform/ConnectivityManager.h>
+#include <platform/NetworkCommissioning.h>
 
 using chip::DeviceLayer::ConnectivityManager;
 using chip::DeviceLayer::ConnectivityMgr;
+using namespace chip::DeviceLayer::NetworkCommissioning;
 
 namespace chip {
 namespace Shell {
@@ -102,15 +105,172 @@ static CHIP_ERROR WiFiModeHandler(int argc, char ** argv)
     return SetWiFiMode(argv[0]);
 }
 
+static CHIP_ERROR WifiAddNetwork(char * ssid, char * password)
+{
+    if (ConnectivityMgr().GetDriver() == nullptr)
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
+
+    uint8_t networkIndex;
+    chip::MutableCharSpan debugText;
+    chip::ByteSpan ssidSpan;
+    chip::ByteSpan passwordSpan;
+
+    ssidSpan     = chip::ByteSpan(reinterpret_cast<const uint8_t *>(ssid), strlen(ssid));
+    passwordSpan = chip::ByteSpan(reinterpret_cast<const uint8_t *>(password), strlen(password));
+
+    if (IsSpanUsable(ssidSpan) && IsSpanUsable(passwordSpan))
+    {
+        ChipLogProgress(DeviceLayer, "[Shell] Adding/Updating network %s", ssidSpan.data());
+
+        /* AddOrUpdateNetwork() checks ssid length and password length. The network info is not persistent. */
+        ConnectivityMgr().GetDriver()->AddOrUpdateNetwork(ssidSpan, passwordSpan, debugText, networkIndex);
+
+        return CHIP_NO_ERROR;
+    }
+    else
+    {
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+}
+
 static CHIP_ERROR WiFiConnectHandler(int argc, char ** argv)
+{
+    if (ConnectivityMgr().GetDriver() == nullptr)
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
+
+    /* Command accepts running either without arguments or either with SSID and password */
+    /* Running without arguments implies that "wifi add ssid password" was executed before */
+    if ((argc != 0) && (argc != 2))
+    {
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    chip::ByteSpan ssidSpan;
+    bool connectToNetwork = false;
+
+    if (argc == 0)
+    {
+        /* Retrieve previously added SSID */
+        char ssid[DeviceLayer::Internal::kMaxWiFiSSIDLength] = { 0 };
+
+        ConnectivityMgr().GetNetworkSSID((char *) &ssid);
+        ssidSpan = chip::ByteSpan(reinterpret_cast<const uint8_t *>(ssid), strlen(ssid));
+
+        if (IsSpanUsable(ssidSpan))
+        {
+            connectToNetwork = true;
+        }
+        else
+        {
+            ChipLogError(
+                DeviceLayer,
+                "[Shell] No network credentials found! Please add using <wifi add ssid password> or <wifi connect ssid password>");
+            return CHIP_ERROR_INVALID_ARGUMENT;
+        }
+    }
+    else if (argc == 2)
+    {
+        ssidSpan = chip::ByteSpan(reinterpret_cast<const uint8_t *>(argv[0]), strlen(argv[0]));
+
+        if ((IsSpanUsable(ssidSpan)) && (WifiAddNetwork(argv[0], argv[1]) == CHIP_NO_ERROR))
+        {
+            connectToNetwork = true;
+        }
+        else
+        {
+            ChipLogError(DeviceLayer, "[Shell] Failed to add network credentials!");
+            return CHIP_ERROR_INVALID_ARGUMENT;
+        }
+    }
+
+    if (connectToNetwork == true)
+    {
+        ChipLogProgress(DeviceLayer, "[Shell] Progress: Connecting to network");
+        /* Connection event will be returned in OnWiFiConnectivityChange from DeviceCallbacks.cpp */
+        ConnectivityMgr().GetDriver()->ConnectNetwork(ssidSpan, nullptr);
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+static CHIP_ERROR WiFiDisconnectHandler(int argc, char ** argv)
+{
+    if (argc != 0)
+    {
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    return ConnectivityMgr().DisconnectNetwork();
+}
+
+static CHIP_ERROR WiFiAddNwkHandler(int argc, char ** argv)
 {
     if (argc != 2)
     {
         return CHIP_ERROR_INVALID_ARGUMENT;
     }
 
-    // TODO:Provision WiFi using WirelessDriver
-    return CHIP_ERROR_NOT_IMPLEMENTED;
+    return WifiAddNetwork(argv[0], argv[1]);
+}
+
+static CHIP_ERROR WiFiRemoveNwkHandler(int argc, char ** argv)
+{
+    if (ConnectivityMgr().GetDriver() == nullptr)
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
+
+    chip::DeviceLayer::NetworkCommissioning::Status status;
+    uint8_t networkIndex;
+    chip::ByteSpan ssidSpan;
+    char ssid[DeviceLayer::Internal::kMaxWiFiSSIDLength] = { 0 };
+    chip::MutableCharSpan debugText;
+
+    ConnectivityMgr().GetNetworkSSID((char *) &ssid);
+    ssidSpan = chip::ByteSpan(reinterpret_cast<const uint8_t *>(ssid), strlen(ssid));
+
+    status = ConnectivityMgr().GetDriver()->RemoveNetwork(ssidSpan, debugText, networkIndex);
+
+    if (status != chip::DeviceLayer::NetworkCommissioning::Status::kSuccess)
+    {
+        ChipLogError(DeviceLayer, "[Shell] Error: RemoveNetwork: %u", (uint8_t) status);
+    }
+
+    return CHIP_NO_ERROR;
+}
+
+static CHIP_ERROR WiFiScanHandler(int argc, char ** argv)
+{
+    if (ConnectivityMgr().GetDriver() == nullptr)
+    {
+        return CHIP_ERROR_NOT_IMPLEMENTED;
+    }
+
+    /* Command accepts running either without arguments or either with ssid */
+    /* Running with argument ssid shall restrict the scan to the interested ssid */
+    if ((argc != 0) && (argc != 1))
+    {
+        return CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    chip::ByteSpan ssidSpan;
+
+    if (argc == 0)
+    {
+        ssidSpan = chip::ByteSpan();
+    }
+    else if (argc == 1)
+    {
+        ssidSpan = chip::ByteSpan(reinterpret_cast<const uint8_t *>(argv[0]), strlen(argv[0]));
+    }
+
+    ConnectivityMgr().GetDriver()->ScanNetworks(ssidSpan, nullptr);
+
+    return CHIP_NO_ERROR;
 }
 
 static CHIP_ERROR WiFiDispatch(int argc, char ** argv)
@@ -127,8 +287,12 @@ void RegisterWiFiCommands()
     /// Subcommands for root command: `device <subcommand>`
     static const shell_command_t sWiFiSubCommands[] = {
         { &WiFiHelpHandler, "help", "" },
-        { &WiFiModeHandler, "mode", "Get/Set wifi mode. Usage: wifi mode [disable|ap|sta]." },
-        { &WiFiConnectHandler, "connect", "Connect to AP. Usage: wifi connect ssid psk." },
+        { &WiFiModeHandler, "mode", "Get/Set wifi mode. Usage: wifi mode [disable|ap|sta]" },
+        { &WiFiConnectHandler, "connect", "Connect to AP. Usage: wifi connect <ssid> <psk>. ssid and psk are optional." },
+        { &WiFiDisconnectHandler, "disconnect", "Disconnect device from AP. Usage: wifi disconnect" },
+        { &WiFiAddNwkHandler, "add", "Add credentials for Wi-Fi network. Usage: wifi add <ssid> <psk>" },
+        { &WiFiRemoveNwkHandler, "remove", "Remove credentials for Wi-Fi network. Usage: wifi remove <ssid>" },
+        { &WiFiScanHandler, "scan", "Scan for Wi-Fi networks. Usage: wifi scan <ssid>. ssid is optional." },
     };
     static const shell_command_t sWiFiCommand = { &WiFiDispatch, "wifi", "Usage: wifi <subcommand>" };