[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

@@ -181,6 +181,7 @@ class ConnectivityManager
     void MaintainOnDemandWiFiAP();
     System::Clock::Timeout GetWiFiAPIdleTimeout();
     void SetWiFiAPIdleTimeout(System::Clock::Timeout val);
+    CHIP_ERROR DisconnectNetwork();
 
     // Thread Methods
     bool IsThreadEnabled();
@@ -559,5 +560,10 @@ inline void ConnectivityManager::OnWiFiStationProvisionChange()
     static_cast<ImplClass *>(this)->_OnWiFiStationProvisionChange();
 }
 
+inline CHIP_ERROR ConnectivityManager::DisconnectNetwork()
+{
+    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();
 
 private:
     ImplClass * Impl() { return static_cast<ImplClass *>(this); }
@@ -71,6 +72,12 @@ template <class ImplClass>
 inline void GenericConnectivityManagerImpl<ImplClass>::_SetUserSelectedModeTimeout(uint16_t val)
 {}
 
+template <class ImplClass>
+inline CHIP_ERROR GenericConnectivityManagerImpl<ImplClass>::_DisconnectNetwork()
+{
+    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,59 @@ 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, CHIP_ERROR_NOT_IMPLEMENTED);
+
+    /* Command accepts running with SSID and password as parameters */
+    VerifyOrReturnError((argc == 2), 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]));
+
+    VerifyOrReturnError(IsSpanUsable(ssidSpan) && IsSpanUsable(passwordSpan), CHIP_ERROR_INVALID_ARGUMENT);
+
+    ChipLogProgress(Shell, "Adding/Updating network %s", argv[0]);
+
+    /* AddOrUpdateNetwork() checks ssid length and password length. The network info is not persistent. */
+    GetWiFiDriver()->AddOrUpdateNetwork(ssidSpan, passwordSpan, debugText, networkIndex);
+
+    ChipLogProgress(Shell, "Connecting to network");
+    /* Connection event will be returned in OnWiFiConnectivityChange from DeviceCallbacks.cpp */
+    GetWiFiDriver()->ConnectNetwork(ssidSpan, nullptr);
+
+    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 == 1)
     {
-        return CHIP_ERROR_INVALID_ARGUMENT;
+        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 +173,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(DeviceLayer::NetworkCommissioning::WiFiDriver * driver);
+DeviceLayer::NetworkCommissioning::WiFiDriver * GetWiFiDriver();
+
+} // namespace Shell
+} // namespace chip