RDK-61444 : Network Manager Plugin to support Scan Specific SSID

definition/NetworkManager.json

@@ -854,9 +854,12 @@
                 "type": "object",
                 "properties": {
                     "frequency": {
-                        "summary": "The frequency to scan. An empty or `null` value scans all frequencies.",
-                        "type": "string",
-                        "example": "5"
+                        "summary": "Frequency bands to scan. Array values: 1=2.4GHz, 2=5GHz, 3=6GHz. Omit this field or pass an empty array to scan all frequencies.",
+                        "type": "array",
+                        "items": {
+                            "type": "integer"
+                        },
+                        "example": [1, 2]
                     },
                     "ssids": {
                         "summary": "The list of SSIDs to be scanned.",

docs/NetworkManagerPlugin.md

@@ -1006,7 +1006,7 @@ Traces the specified endpoint with the specified number of packets using `tracer
 <a name="method.StartWiFiScan"></a>
 ## *StartWiFiScan [<sup>method</sup>](#head.Methods)*
 
-Initiates WiFi scaning. This method supports scanning for specific range of frequency like 2.4GHz only or 5GHz only or 6GHz only or ALL. When no input passed about the frequency to be scanned, it scans for all. When list of SSIDs to be scanned specifically, it can be passed as input. It publishes 'onAvailableSSIDs' event upon completion.
+Initiates WiFi scaning. This method supports scanning specific frequencies (2.4GHz, 5GHz, 6GHz). When no input is passed for frequency, it scans all supported frequencies. When list of SSIDs to be scanned specifically, it can be passed as input. It publishes 'onAvailableSSIDs' event upon completion.
 
 Also see: [onAvailableSSIDs](#event.onAvailableSSIDs)
 
@@ -1015,7 +1015,8 @@ Also see: [onAvailableSSIDs](#event.onAvailableSSIDs)
 | Name | Type | Description |
 | :-------- | :-------- | :-------- |
 | params | object |  |
-| params?.frequency | string | <sup>*(optional)*</sup> The frequency to scan. An empty or `null` value scans all frequencies |
+| params?.frequency | array | <sup>*(optional)*</sup> The frequency list to scan. Supported values are `1` (2.4GHz), `2` (5GHz), `3` (6GHz) |
+| params?.frequency[#] | integer | <sup>*(optional)*</sup> Frequency enum value |
 | params?.ssids | array | <sup>*(optional)*</sup> The list of SSIDs to be scanned |
 | params?.ssids[#] | string | <sup>*(optional)*</sup> The SSID to scan |
 
@@ -1036,7 +1037,9 @@ Also see: [onAvailableSSIDs](#event.onAvailableSSIDs)
   "id": 42,
   "method": "org.rdk.NetworkManager.1.StartWiFiScan",
   "params": {
-    "frequency": "5",
+    "frequency": [
+      2
+    ],
     "ssids": [
       "Xfinity Mobile"
     ]

interface/INetworkManager.h

@@ -30,7 +30,8 @@ namespace WPEFramework
             ID_NETWORKMANAGER                               = 0x800004E0,
             ID_NETWORKMANAGER_NOTIFICATION                  = ID_NETWORKMANAGER + 1,
             ID_NETWORKMANAGER_INTERFACE_DETAILS_ITERATOR    = ID_NETWORKMANAGER + 2,
-            ID_NETWORKMANAGER_WIFI_SECURITY_MODE_ITERATOR   = ID_NETWORKMANAGER + 3
+            ID_NETWORKMANAGER_WIFI_SECURITY_MODE_ITERATOR   = ID_NETWORKMANAGER + 3,
+            ID_NETWORKMANAGER_WIFI_FREQUENCY_ITERATOR       = ID_NETWORKMANAGER + 4
         };
 
         /* @json @text:keep */
@@ -202,6 +203,7 @@ namespace WPEFramework
             using IInterfaceDetailsIterator = RPC::IIteratorType<InterfaceDetails,     ID_NETWORKMANAGER_INTERFACE_DETAILS_ITERATOR>;
             using ISecurityModeIterator     = RPC::IIteratorType<WIFISecurityModeInfo, ID_NETWORKMANAGER_WIFI_SECURITY_MODE_ITERATOR>;
             using IStringIterator           = RPC::IIteratorType<string,               RPC::ID_STRINGITERATOR>;
+            using IWIFIFrequencyIterator    = RPC::IIteratorType<WIFIFrequency,        ID_NETWORKMANAGER_WIFI_FREQUENCY_ITERATOR>;
 
             /* @brief Get all the Available Interfaces */
             virtual uint32_t GetAvailableInterfaces (IInterfaceDetailsIterator*& interfaces/* @out */) = 0;
@@ -248,7 +250,7 @@ namespace WPEFramework
 
             // WiFi Specific Methods
             /* @brief Initiate a WIFI Scan; This is Async method and returns the scan results as Event */
-            virtual uint32_t StartWiFiScan(const string& frequency /* @in */, IStringIterator* const ssids/* @in */) = 0;
+            virtual uint32_t StartWiFiScan(IWIFIFrequencyIterator* const frequencies /* @in */, IStringIterator* const ssids/* @in */) = 0;
             virtual uint32_t StopWiFiScan(void) = 0;
 
             virtual uint32_t GetKnownSSIDs(IStringIterator*& ssids /* @out */) = 0;

plugin/NetworkManagerImplementation.cpp

@@ -589,26 +589,39 @@ namespace WPEFramework
             }
             return;
         }
-
+
+        namespace {
+            Exchange::INetworkManager::WIFIFrequency GetFrequencyFromMHz(const double frequencyMHz)
+            {
+                // Normalize frequency to MHz even if reported in GHz (2.4/5/6) or report MHz (2412/5180/5955).
+                const double normalizedMHz = (frequencyMHz > 0.0 && frequencyMHz < 100.0)
+                    ? (frequencyMHz * 1000.0)
+                    : frequencyMHz;
+
+                if ((normalizedMHz >= 2400.0) && (normalizedMHz < 2500.0)) {
+                    return Exchange::INetworkManager::WIFI_FREQUENCY_2_4_GHZ;
+                } else if ((normalizedMHz >= 4900.0) && (normalizedMHz < 5925.0)) {
+                    return Exchange::INetworkManager::WIFI_FREQUENCY_5_GHZ;
+                } else if ((normalizedMHz >= 5925.0) && (normalizedMHz < 7125.0)) {
+                    return Exchange::INetworkManager::WIFI_FREQUENCY_6_GHZ;
+                } else {
+                    return Exchange::INetworkManager::WIFI_FREQUENCY_NONE;
+                }
+            }
+        }
 
         void NetworkManagerImplementation::filterScanResults(JsonArray &ssids)
         {
             JsonArray result;
-            double filterFreq = 0.0;
             std::unordered_set<std::string> scanForSsidsSet(m_filterSsidslist.begin(), m_filterSsidslist.end());
 
             // If neither SSID list nor frequency is provided, exit
-            if (m_filterSsidslist.empty() && m_filterfrequency.empty())
+            if (m_filterSsidslist.empty() && m_filterFrequencies.empty())
             {
                 NMLOG_DEBUG("Neither SSID nor Frequency is provided. Exiting function.");
                 return;
             }
 
-            if (!m_filterfrequency.empty())
-            {
-                filterFreq = std::stod(m_filterfrequency);
-            }
-
             for (int i = 0; i < ssids.Length(); i++)
             {
                 JsonObject object = ssids[i].Object();
@@ -618,7 +631,19 @@ namespace WPEFramework
 
                 double frequencyValue = std::stod(frequency);
                 bool ssidMatches = scanForSsidsSet.empty() || scanForSsidsSet.find(ssid) != scanForSsidsSet.end();
-                bool freqMatches = m_filterfrequency.empty() || (filterFreq == frequencyValue);
+                bool freqMatches = m_filterFrequencies.empty();
+                if (!freqMatches)
+                {
+                    const auto ssidFrequencyBand = GetFrequencyFromMHz(frequencyValue);
+                    for (const auto selectedFrequency : m_filterFrequencies)
+                    {
+                        if (selectedFrequency == ssidFrequencyBand)
+                        {
+                            freqMatches = true;
+                            break;
+                        }
+                    }
+                }
 
                 if (ssidMatches && freqMatches)
                     result.Add(object);

plugin/NetworkManagerImplementation.h

@@ -216,7 +216,7 @@ namespace WPEFramework
 
                 // WiFi Specific Methods
                 /* @brief Initiate a WIFI Scan; This is Async method and returns the scan results as Event */
-                uint32_t StartWiFiScan(const string& frequency /* @in */, IStringIterator* const ssids/* @in */) override;
+                uint32_t StartWiFiScan(IWIFIFrequencyIterator* const frequencies /* @in */, IStringIterator* const ssids/* @in */) override;
                 uint32_t StopWiFiScan(void) override;
 
                 uint32_t GetKnownSSIDs(IStringIterator*& ssids /* @out */) override;
@@ -301,7 +301,7 @@ namespace WPEFramework
                 uint16_t m_stunBindTimeout;
                 uint16_t m_stunCacheTimeout;
                 std::thread m_registrationThread;
-                string m_filterfrequency;
+                std::vector<WIFIFrequency> m_filterFrequencies;
                 std::vector<std::string> m_filterSsidslist;
                 std::thread m_monitorThread;
 

plugin/NetworkManagerJsonRpc.cpp

@@ -642,19 +642,50 @@ namespace WPEFramework
         {
             LOG_INPARAM();
             uint32_t rc = Core::ERROR_GENERAL;
-	    string frequency{};
-	    Exchange::INetworkManager::IStringIterator* ssids = NULL;
-
-	    if (parameters.HasLabel("frequency"))
-                frequency = parameters["frequency"].String();
-
-            if (parameters.HasLabel("ssids"))
+	    	Exchange::INetworkManager::IWIFIFrequencyIterator* frequencies = nullptr;
+	    	Exchange::INetworkManager::IStringIterator* ssids = NULL;
+
+		    if (parameters.HasLabel("frequency"))
+			{
+				std::vector<Exchange::INetworkManager::WIFIFrequency> frequencyList;
+				JsonArray array = parameters["frequency"].Array();
+	            JsonArray::Iterator index(array.Elements());
+				while (index.Next() == true)
+				{
+					if (Core::JSON::Variant::type::NUMBER == index.Current().Content())
+					{
+						const int freq = index.Current().Number();
+						if (freq < static_cast<int>(Exchange::INetworkManager::WIFI_FREQUENCY_NONE)
+							|| freq > static_cast<int>(Exchange::INetworkManager::WIFI_FREQUENCY_6_GHZ)) 
+						{
+							NMLOG_ERROR("Invalid frequency value in array");
+							return Core::ERROR_BAD_REQUEST;
+							returnJson(rc);
+						}
+						frequencyList.push_back(static_cast<Exchange::INetworkManager::WIFIFrequency>(freq));
+					}
+					else
+					{
+						NMLOG_ERROR("Unexpected variant type in frequency array.");
+	                    returnJson(rc);
+					}
+				}
+			}
+			if (!frequencyList.empty()) {
+				using FrequencyIterator = RPC::IteratorType<Exchange::INetworkManager::IWIFIFrequencyIterator>;
+				frequencies = Core::Service<FrequencyIterator>::Create<Exchange::INetworkManager::IWIFIFrequencyIterator>(frequencyList);
+				if (frequencies == nullptr) {
+					returnJson(rc);
+				}
+			}
+
+        	if (parameters.HasLabel("ssids"))
             {
                 JsonArray array = parameters["ssids"].Array();
                 std::vector<std::string> ssidslist;
-	        JsonArray::Iterator index(array.Elements());
+	        	JsonArray::Iterator index(array.Elements());
 
-		while (index.Next() == true)
+				while (index.Next() == true)
                 {
                     if (Core::JSON::Variant::type::STRING == index.Current().Content())
                     {
@@ -673,10 +704,13 @@ namespace WPEFramework
             }
 
             if (_networkManager)
-                rc = _networkManager->StartWiFiScan(frequency, ssids);
+                rc = _networkManager->StartWiFiScan(frequencies, ssids);
             else
                 rc = Core::ERROR_UNAVAILABLE;
 
+			if (frequencies)
+                frequencies->Release();
+
             if (ssids)
                 ssids->Release();
 

plugin/gnome/NetworkManagerGnomeProxy.cpp

@@ -986,32 +986,46 @@ namespace WPEFramework
             return rc;
         }
 
-        uint32_t NetworkManagerImplementation::StartWiFiScan(const string& frequency /* @in */, IStringIterator* const ssids/* @in */)
+        uint32_t NetworkManagerImplementation::StartWiFiScan(IWIFIFrequencyIterator* const frequencies /* @in */, IStringIterator* const ssids/* @in */)
         {
             uint32_t rc = Core::ERROR_RPC_CALL_FAILED;
 
             //Cleared the Existing Store filterred SSID list
             m_filterSsidslist.clear();
-            m_filterfrequency.clear();
+            m_filterFrequencies.clear();
 
             if(ssids)
             {
                 string tmpssidlist{};
                 while (ssids->Next(tmpssidlist) == true)
                 {
-                    m_filterSsidslist.push_back(tmpssidlist.c_str());
-                    NMLOG_DEBUG("%s added to SSID filtering", tmpssidlist.c_str());
+                    if (!tmpssidlist.empty())
+                    {
+                        m_filterSsidslist.push_back(tmpssidlist.c_str());
+                        NMLOG_DEBUG("%s added to SSID filtering", tmpssidlist.c_str());
+                    }
+                    else 
+                    {
+                        NMLOG_DEBUG("Empty SSID encountered in input list; skipping.");
+                    }
                 }
             }
 
-            if (!frequency.empty())
+            if (frequencies)
             {
-                m_filterfrequency = frequency;
-                NMLOG_DEBUG("Scan SSIDs of frequency %s", m_filterfrequency.c_str());
+                Exchange::INetworkManager::WIFIFrequency frequency = Exchange::INetworkManager::WIFI_FREQUENCY_NONE;
+                while (frequencies->Next(frequency) == true)
+                {
+                    if (frequency != Exchange::INetworkManager::WIFI_FREQUENCY_NONE)
+                    {
+                        m_filterFrequencies.push_back(frequency);
+                        NMLOG_DEBUG("Frequency %u added to scan filtering", static_cast<uint32_t>(frequency));
+                    }
+                }
             }
 
             nmEvent->setwifiScanOptions(true);
-            if(wifi->wifiScanRequest(m_filterSsidslist.size() == 1 ? m_filterSsidslist[0] : ""))
+            if(wifi->wifiScanRequest(m_filterSsidslist))
                 rc = Core::ERROR_NONE;
             return rc;
         }

plugin/gnome/NetworkManagerGnomeWIFI.cpp

@@ -1685,7 +1685,7 @@ namespace WPEFramework
             g_main_loop_quit(_wifiManager->m_loop);
         }
 
-        bool wifiManager::wifiScanRequest(std::string ssidReq)
+        bool wifiManager::wifiScanRequest(const std::vector<std::string>& ssidsToFilter)
         {
             if(!createClientNewConnection())
                 return false;
@@ -1696,23 +1696,25 @@ namespace WPEFramework
                 return false;
             }
             m_isSuccess = false;
-            if(!ssidReq.empty())
+            if(!ssidsToFilter.empty())
             {
-                NMLOG_INFO("starting wifi scanning .. %s", ssidReq.c_str());
+                NMLOG_INFO("Starting wifi scanning for %d SSIDs:",static_cast<int>(ssidsToFilter.size()));
                 GVariantBuilder builder, array_builder;
                 GVariant *options;
                 g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
                 g_variant_builder_init(&array_builder, G_VARIANT_TYPE("aay"));
-                g_variant_builder_add(&array_builder, "@ay",
-                                    g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, (const guint8 *) ssidReq.c_str(), ssidReq.length(), 1)
-                                    );
+                for (const auto& ssid : ssidsToFilter) {
+                    g_variant_builder_add(&array_builder, "@ay",
+                                        g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, (const guint8 *) ssid.c_str(), ssid.length(), 1)
+                                        );
+                }
                 g_variant_builder_add(&builder, "{sv}", "ssids", g_variant_builder_end(&array_builder));
                 options = g_variant_builder_end(&builder);
                 nm_device_wifi_request_scan_options_async(wifiDevice, options, m_cancellable, wifiScanCb, this);
                 g_variant_unref(options); // Unreference the GVariant after passing it to the async function
             }
             else {
-                NMLOG_INFO("staring normal wifi scanning ..");
+                NMLOG_INFO("Starting normal wifi scanning ..");
                 nm_device_wifi_request_scan_async(wifiDevice, m_cancellable, wifiScanCb, this);
             }
             wait(m_loop);

plugin/gnome/NetworkManagerGnomeWIFI.h

@@ -31,6 +31,7 @@
 #include <string.h>
 #include <atomic>
 #include <mutex>
+#include <vector>
 
 #define WPS_RETRY_WAIT_IN_MS        10 // 10 sec
 #define WPS_RETRY_COUNT             10
@@ -54,7 +55,7 @@ namespace WPEFramework
             bool activateKnownConnection(std::string iface, std::string knowConnectionID="");
             bool wifiConnectedSSIDInfo(Exchange::INetworkManager::WiFiSSIDInfo &ssidinfo);
             bool wifiConnect(const Exchange::INetworkManager::WiFiConnectTo &ssidInfo);
-            bool wifiScanRequest(std::string ssidReq = "");
+            bool wifiScanRequest(const std::vector<std::string>& ssidsToFilter = {});
             bool isWifiScannedRecently(int timelimitInSec = 5); // default 5 sec as shotest scanning interval
             bool getKnownSSIDs(std::list<string>& ssids);
             bool addToKnownSSIDs(const Exchange::INetworkManager::WiFiConnectTo &ssidinfo);

tools/plugincli/NetworkManagerLibnmTest.cpp

@@ -220,7 +220,8 @@ int main()
 
                 NMLOG_INFO("Sending WiFi scan request%s", ssid.empty() ? " (all SSIDs)" : (" for SSID: " + ssid).c_str());
 
-                if (wifiMgr->wifiScanRequest(ssid)) {
+                bool scanRequestSent = ssid.empty() ? wifiMgr->wifiScanRequest() : wifiMgr->wifiScanRequest({ssid});
+                if (scanRequestSent) {
                     NMLOG_INFO("WiFi scan request sent successfully.");
                 } else {
                     NMLOG_ERROR("Failed to send WiFi scan request.");