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

- "wifi connect" command was improved to work with credentials entered from shell
- "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

@@ -31,6 +31,7 @@
 #include <platform/CHIPDeviceEvent.h>
 
 #include <app/util/basic-types.h>
+#include <lib/support/Span.h>
 
 #if INET_CONFIG_ENABLE_TCP_ENDPOINT
 #include <inet/TCPEndPoint.h>
@@ -181,6 +182,7 @@ class ConnectivityManager
     void MaintainOnDemandWiFiAP();
     System::Clock::Timeout GetWiFiAPIdleTimeout();
     void SetWiFiAPIdleTimeout(System::Clock::Timeout val);
+    CHIP_ERROR DisconnectNetwork(void);
 
     // Thread Methods
     bool IsThreadEnabled();
@@ -223,7 +225,7 @@ class ConnectivityManager
     static const char * CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode);
 
 private:
-    ConnectivityManagerDelegate * mDelegate = nullptr;
+    ConnectivityManagerDelegate * mDelegate                       = nullptr;
 
     // ===== Members for internal use by the following friends.
 
@@ -559,5 +561,10 @@ inline void ConnectivityManager::OnWiFiStationProvisionChange()
     static_cast<ImplClass *>(this)->_OnWiFiStationProvisionChange();
 }
 
+inline CHIP_ERROR ConnectivityManager::DisconnectNetwork(void)
+{
+    return static_cast<ImplClass *>(this)->_DisconnectNetwork();
+}
+
 } // namespace DeviceLayer
 } // namespace chip

src/include/platform/internal/GenericConnectivityManagerImpl.h

@@ -46,6 +46,7 @@ class GenericConnectivityManagerImpl
     void _SetUserSelectedMode(bool val);
     uint16_t _GetUserSelectedModeTimeout();
     void _SetUserSelectedModeTimeout(uint16_t val);
+    CHIP_ERROR _DisconnectNetwork(void);
 
 private:
     ImplClass * Impl() { return static_cast<ImplClass *>(this); }
@@ -71,6 +72,10 @@ template <class ImplClass>
 inline void GenericConnectivityManagerImpl<ImplClass>::_SetUserSelectedModeTimeout(uint16_t val)
 {}
 
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl<ImplClass>::_DisconnectNetwork(void)
+{}
+
 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace chip

src/include/platform/internal/GenericConnectivityManagerImpl_NoWiFi.h

@@ -24,6 +24,8 @@
 
 #pragma once
 
+#include <lib/support/Span.h>
+
 namespace chip {
 namespace DeviceLayer {
 namespace Internal {
@@ -74,6 +76,7 @@ class GenericConnectivityManagerImpl_NoWiFi
     bool _CanStartWiFiScan();
     void _OnWiFiScanDone();
     void _OnWiFiStationProvisionChange();
+    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,12 @@ inline const char * GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_WiFiAPSta
     return nullptr;
 }
 
+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

@@ -25,6 +25,7 @@
 
 #include <app/icd/server/ICDServerConfig.h>
 #include <lib/support/logging/CHIPLogging.h>
+#include <lib/support/Span.h>
 #include <platform/ConnectivityManager.h>
 #include <platform/internal/DeviceNetworkInfo.h>
 
@@ -81,6 +82,7 @@ class GenericConnectivityManagerImpl_WiFi
 #if CHIP_CONFIG_ENABLE_ICD_SERVER && !CHIP_DEVICE_CONFIG_ENABLE_THREAD
     CHIP_ERROR _SetPollingInterval(System::Clock::Milliseconds32 pollingInterval);
 #endif
+    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);
@@ -194,6 +196,12 @@ inline CHIP_ERROR GenericConnectivityManagerImpl_WiFi<ImplClass>::_SetPollingInt
 }
 #endif
 
+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/BUILD.gn

@@ -36,7 +36,10 @@ source_set("commands") {
   }
 
   if (chip_enable_wifi) {
-    sources += [ "WiFi.cpp" ]
+    sources += [
+      "WiFi.cpp",
+      "WiFi.h",
+    ]
   }
 
   if (chip_enable_ble && chip_device_platform != "none") {

src/lib/shell/commands/WiFi.cpp

@@ -18,17 +18,22 @@
 #include <lib/shell/Commands.h>
 #include <lib/shell/Engine.h>
 #include <lib/shell/commands/Help.h>
+#include <lib/shell/commands/WiFi.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 {
 
-static chip::Shell::Engine sShellWiFiSubCommands;
+static Shell::Engine sShellWiFiSubCommands;
+static DeviceLayer::NetworkCommissioning::WiFiDriver * sDriver;
 
 static CHIP_ERROR WiFiHelpHandler(int argc, char ** argv)
 {
@@ -104,13 +109,69 @@ static CHIP_ERROR WiFiModeHandler(int argc, char ** argv)
 
 static CHIP_ERROR WiFiConnectHandler(int argc, char ** argv)
 {
-    if (argc != 2)
+    CHIP_ERROR error = CHIP_NO_ERROR;
+    uint8_t networkIndex;
+    MutableCharSpan debugText;
+    ByteSpan ssidSpan;
+    ByteSpan passwordSpan;
+
+    VerifyOrReturnError(GetWiFiDriver() != nullptr, error = CHIP_ERROR_NOT_IMPLEMENTED);
+
+    /* Command accepts running with SSID and password as parameters */
+    VerifyOrReturnError((argc == 2), error = CHIP_ERROR_INVALID_ARGUMENT);
+
+    ssidSpan     = ByteSpan(reinterpret_cast<const uint8_t *>(argv[0]), strlen(argv[0]));
+    passwordSpan = ByteSpan(reinterpret_cast<const uint8_t *>(argv[1]), strlen(argv[1]));
+
+    if (IsSpanUsable(ssidSpan) && IsSpanUsable(passwordSpan))
     {
-        return CHIP_ERROR_INVALID_ARGUMENT;
+        ChipLogProgress(DeviceLayer, "[Shell] Adding/Updating network %s", ssidSpan.data());
+
+        /* AddOrUpdateNetwork() checks ssid length and password length. The network info is not persistent. */
+        GetWiFiDriver()->AddOrUpdateNetwork(ssidSpan, passwordSpan, debugText, networkIndex);
+
+        ChipLogProgress(DeviceLayer, "[Shell] Progress: Connecting to network");
+        /* Connection event will be returned in OnWiFiConnectivityChange from DeviceCallbacks.cpp */
+        GetWiFiDriver()->ConnectNetwork(ssidSpan, nullptr);
+    }
+    else
+    {
+        ChipLogError(DeviceLayer, "[Shell] Failed to add network credentials!");
+        error = CHIP_ERROR_INVALID_ARGUMENT;
+    }
+
+    return error;
+}
+
+static CHIP_ERROR WiFiDisconnectHandler(int argc, char ** argv)
+{
+    VerifyOrReturnError((argc == 0), CHIP_ERROR_INVALID_ARGUMENT);
+
+    return ConnectivityMgr().DisconnectNetwork();
+}
+
+static CHIP_ERROR WiFiScanHandler(int argc, char ** argv)
+{
+    ByteSpan ssidSpan;
+
+    VerifyOrReturnError(GetWiFiDriver() != nullptr, 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 */
+    VerifyOrReturnError((argc == 0) || (argc == 1), CHIP_ERROR_INVALID_ARGUMENT);
+
+    if (argc == 0)
+    {
+        ssidSpan = ByteSpan();
+    }
+    else if (argc == 1)
+    {
+        ssidSpan = ByteSpan(reinterpret_cast<const uint8_t *>(argv[0]), strlen(argv[0]));
     }
 
-    // TODO:Provision WiFi using WirelessDriver
-    return CHIP_ERROR_NOT_IMPLEMENTED;
+    GetWiFiDriver()->ScanNetworks(ssidSpan, nullptr);
+
+    return CHIP_NO_ERROR;
 }
 
 static CHIP_ERROR WiFiDispatch(int argc, char ** argv)
@@ -122,13 +183,25 @@ static CHIP_ERROR WiFiDispatch(int argc, char ** argv)
     return sShellWiFiSubCommands.ExecCommand(argc, argv);
 }
 
+void SetWiFiDriver(WiFiDriver * driver)
+{
+    sDriver = driver;
+}
+
+WiFiDriver * GetWiFiDriver()
+{
+    return sDriver;
+}
+
 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>" },
+        { &WiFiDisconnectHandler, "disconnect", "Disconnect device from AP. Usage: wifi disconnect" },
+        { &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>" };
 

src/lib/shell/commands/WiFi.h

@@ -0,0 +1,35 @@
+/*
+ *
+ *    Copyright (c) 2024 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+/**
+ *    @file
+ *      Header that defines default shell commands for CHIP examples
+ */
+
+#pragma once
+
+#include <lib/shell/Engine.h>
+#include <platform/NetworkCommissioning.h>
+
+namespace chip {
+namespace Shell {
+
+void SetWiFiDriver(chip::DeviceLayer::NetworkCommissioning::WiFiDriver * driver);
+chip::DeviceLayer::NetworkCommissioning::WiFiDriver * GetWiFiDriver();
+
+} // namespace Shell
+} // namespace chip