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

@@ -89,7 +89,7 @@ NetworkManager interface methods:
 | [GetPublicIP](#method.GetPublicIP) | Gets the internet/public IP Address of the device |
 | [Ping](#method.Ping) | Pings the specified endpoint with the specified number of packets |
 | [Trace](#method.Trace) | Traces the specified endpoint with the specified number of packets using `traceroute` |
-| [StartWiFiScan](#method.StartWiFiScan) | Initiates WiFi scaning |
+| [StartWiFiScan](#method.StartWiFiScan) | Initiates WiFi scanning |
 | [StopWiFiScan](#method.StopWiFiScan) | Stops WiFi scanning |
 | [GetKnownSSIDs](#method.GetKnownSSIDs) | Gets list of saved SSIDs |
 | [AddToKnownSSIDs](#method.AddToKnownSSIDs) | Saves the SSID, passphrase, and security mode for upcoming and future sessions |
@@ -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 scanning. 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;

legacy/LegacyWiFiManagerAPIs.cpp

@@ -634,12 +634,42 @@ namespace WPEFramework
         {
             LOG_INPARAM();
             uint32_t rc = Core::ERROR_GENERAL;
-            string frequency{};
+            Exchange::INetworkManager::IWIFIFrequencyIterator* frequencies = nullptr;
             Exchange::INetworkManager::IStringIterator* ssids = NULL;
+			std::vector<Exchange::INetworkManager::WIFIFrequency> frequencyList;
 
 
             if (parameters.HasLabel("frequency"))
-                frequency = parameters["frequency"].String();
+			{
+				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");
+							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("ssid"))
             {
@@ -654,19 +684,24 @@ namespace WPEFramework
 
                 ssids = (Core::Service<RPC::StringIterator>::Create<RPC::IStringIterator>(inputSSIDlist));
                 if (ssids == nullptr) {
+					if (frequencies)
+                		frequencies->Release();
                     returnJson(rc);
                 }
             }
 
             auto _nwmgr = m_service->QueryInterfaceByCallsign<Exchange::INetworkManager>(NETWORK_MANAGER_CALLSIGN);
             if (_nwmgr)
             {
-                rc = _nwmgr->StartWiFiScan(frequency, ssids);
+                rc = _nwmgr->StartWiFiScan(frequencies, ssids);
                 _nwmgr->Release();
             }
             else
                 rc = Core::ERROR_UNAVAILABLE;
 
+			if (frequencies)
+                frequencies->Release();
+
             if (ssids)
                 ssids->Release();
 

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;
+
+			const bool hasFrequencyLabel = parameters.HasLabel("frequency");
+			std::vector<Exchange::INetworkManager::WIFIFrequency> frequencyList;
+            if (hasFrequencyLabel)
+			{
+				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");
+							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())
                     {
@@ -663,20 +694,27 @@ namespace WPEFramework
                     else
                     {
                         NMLOG_ERROR("Unexpected variant type in SSID array.");
+						if (frequencies)
+                			frequencies->Release();
                         returnJson(rc);
                     }
                 }
                 ssids = (Core::Service<RPC::StringIterator>::Create<RPC::IStringIterator>(ssidslist));
                 if(ssids == nullptr){
+					if (frequencies)
+                		frequencies->Release();
                     returnJson(rc);
                 }
             }
 
             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 && frequencies->Count() > 0)
             {
-                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;
         }