RDK-61440: Implementation of handling PowerMode Change in NM plugin

plugin/CMakeLists.txt

@@ -81,7 +81,8 @@ add_library(${MODULE_IMPL_NAME} SHARED
                             NetworkManagerConnectivity.cpp
                             NetworkManagerStunClient.cpp
                             NetworkManagerLogger.cpp
-                            Module.cpp)
+                            Module.cpp
+                            NetworkManagerPowerClient.cpp)
 
 if(ENABLE_GNOME_NETWORKMANAGER)
     if(ENABLE_GNOME_GDBUS)

plugin/NetworkManagerImplementation.cpp

@@ -54,6 +54,8 @@ namespace WPEFramework
             m_wlanConnected.store(false);
             m_ethEnabled.store(false);
             m_wlanEnabled.store(false);
+            m_ethDisconnectedForSleep.store(false);
+            m_wlanDisconnectedForSleep.store(false);
 
             /* Set NetworkManager Out-Process name to be NWMgrPlugin */
             Core::ProcessInfo().Name("NWMgrPlugin");
@@ -71,6 +73,7 @@ namespace WPEFramework
         NetworkManagerImplementation::~NetworkManagerImplementation()
         {
             NMLOG_INFO("NetworkManager Out-Of-Process Shutdown/Cleanup");
+            _powerClient.reset();
             connectivityMonitor.stopConnectivityMonitor();
             _instance = nullptr;
             platform_deinit();
@@ -199,6 +202,7 @@ namespace WPEFramework
             NetworkManagerImplementation::platform_init();
             /* change gnome networkmanager or netsrvmgr logg level */
             NetworkManagerImplementation::platform_logging(static_cast <NetworkManagerLogger::LogLevel>(config.loglevel.Value()));
+            _powerClient.reset(new NetworkManagerPowerClient(*this));
             return(Core::ERROR_NONE);
         }
 
@@ -1184,5 +1188,132 @@ namespace WPEFramework
             }
 #endif
         }
+
+        void NetworkManagerImplementation::OnPowerModePreChange(
+            const Exchange::IPowerManager::PowerState currentState,
+            const Exchange::IPowerManager::PowerState newState,
+            std::function<void()> sendAck)
+        {
+            // Called from NetworkManagerPowerClient's power thread.
+            NMLOG_INFO("OnPowerModePreChange: current=%d new=%d",
+                       static_cast<int>(currentState), static_cast<int>(newState));
+
+            using PowerState = Exchange::IPowerManager::PowerState;
+
+            if (newState == PowerState::POWER_STATE_STANDBY_DEEP_SLEEP)
+            {
+                if (m_wlanEnabled.load() && m_wlanConnected.load())
+                {
+                    NMLOG_INFO("OnPowerModePreChange: going to DeepSleep — disconnecting WiFi");
+
+                    uint32_t rcWifiDown = WiFiDisconnect();
+                    if (rcWifiDown == Core::ERROR_NONE)
+                    {
+                        m_wlanDisconnectedForSleep.store(true);
+                    }
+                    else
+                    {
+                        NMLOG_WARNING("OnPowerModePreChange: WiFiDisconnect failed (rc=%u), will not reconnect on wakeup", rcWifiDown);
+                    }
+                }
+                else
+                {
+                    NMLOG_WARNING("OnPowerModePreChange: going to DeepSleep — WiFi not connected, skipping disconnect");
+                }
+
+                if (m_ethEnabled.load() && m_ethConnected.load())
+                {
+                    NMLOG_INFO("OnPowerModePreChange: going to DeepSleep — deactivating Ethernet");
+
+                    uint32_t rcEthDown = EthernetDeactivate();
+                    if (rcEthDown == Core::ERROR_NONE)
+                    {
+                        m_ethDisconnectedForSleep.store(true);
+                    }
+                    else
+                    {
+                        NMLOG_WARNING("OnPowerModePreChange: EthernetDeactivate failed (rc=%u), will not activate on wakeup", rcEthDown);
+                    }
+                }
+                else
+                {
+                    NMLOG_WARNING("OnPowerModePreChange: going to DeepSleep — Ethernet not activated, skipping deactivate");
+                }
+            }
+            else if (currentState == PowerState::POWER_STATE_STANDBY_DEEP_SLEEP)
+            {
+                if (m_wlanDisconnectedForSleep.load())
+                {
+                    if (!m_lastConnectedSSID.empty())
+                    {
+                        NMLOG_INFO("OnPowerModePreChange: waking from DeepSleep — reconnecting to '%s'",
+                               m_lastConnectedSSID.c_str());
+                        m_wlanDisconnectedForSleep.store(false);
+                        uint32_t rcWifiUp = ConnectToKnownSSID(m_lastConnectedSSID);
+                        if (rcWifiUp != Core::ERROR_NONE)
+                            NMLOG_WARNING("OnPowerModePreChange: ConnectToKnownSSID failed (rc=%u)", rcWifiUp);
+                    }
+                    else
+                    {
+                        NMLOG_WARNING("OnPowerModePreChange: waking from DeepSleep — no last SSID, skipping reconnect");
+                    }
+                }
+                else
+                {
+                    NMLOG_INFO("OnPowerModePreChange: waking from DeepSleep — WiFi was not connected or was already down before sleep, skipping reconnect");
+                }
+
+                if (m_ethDisconnectedForSleep.load())
+                {
+                    m_ethDisconnectedForSleep.store(false);
+                    NMLOG_INFO("OnPowerModePreChange: waking from DeepSleep — activating Ethernet");
+                    uint32_t rcEthUp = EthernetActivate();
+                    if (rcEthUp != Core::ERROR_NONE)
+                        NMLOG_WARNING("OnPowerModePreChange: EthernetActivate failed (rc=%u)", rcEthUp);
+                }
+                else
+                {
+                    NMLOG_INFO("OnPowerModePreChange: waking from DeepSleep — Ethernet was not activated or was already deactivated before sleep, skipping activate");
+                }
+            }
+            sendAck();
+        }
+
+        void NetworkManagerImplementation::OnPowerModeChanged(
+            const Exchange::IPowerManager::PowerState currentState,
+            const Exchange::IPowerManager::PowerState newState)
+        {
+            NMLOG_INFO("OnPowerModeChanged: current=%d new=%d",
+                       static_cast<int>(currentState), static_cast<int>(newState));
+            if (currentState == Exchange::IPowerManager::POWER_STATE_STANDBY_DEEP_SLEEP) {
+
+                if (m_wlanEnabled.load() && m_wlanConnected.load())
+                {
+                    // Waking from DeepSleep with Network Standby ON: the AP may have
+                    // changed channel while the device slept (802.11 CSA).  Trigger an
+                    // active scan so the driver discovers the AP on its new channel.
+                    NMLOG_INFO("OnPowerModeChanged: waking from DeepSleep, triggering active WiFi scan");
+                    if (StartWiFiScan("", nullptr) != Core::ERROR_NONE)
+                    {
+                        NMLOG_WARNING("OnPowerModeChanged: StartWiFiScan failed");
+                    }
+
+                    NMLOG_INFO("OnPowerModeChanged: waking from DeepSleep, requesting DHCP lease on wlan0");
+                    if (RequestDHCPLease("wlan0") != Core::ERROR_NONE)
+                    {
+                        NMLOG_WARNING("OnPowerModeChanged: RequestDHCPLease(wlan0) failed");
+                    }
+                }
+
+                if (m_ethEnabled.load() && m_ethConnected.load())
+                {
+                    NMLOG_INFO("OnPowerModeChanged: waking from DeepSleep, requesting DHCP lease on eth0");
+                    if (RequestDHCPLease("eth0") != Core::ERROR_NONE)
+                    {
+                        NMLOG_WARNING("OnPowerModeChanged: RequestDHCPLease(eth0) failed");
+                    }
+                }
+            }
+        }
     }
 }

plugin/NetworkManagerImplementation.h

@@ -34,6 +34,7 @@ using namespace std;
 #include "NetworkManagerLogger.h"
 #include "NetworkManagerConnectivity.h"
 #include "NetworkManagerStunClient.h"
+#include "NetworkManagerPowerClient.h"
 
 /* Forward declarations to avoid pulling GLib/libnm headers into this header */
 typedef struct _NMClient    NMClient;
@@ -63,6 +64,7 @@ namespace WPEFramework
     namespace Plugin
     {
         class NetworkManagerImplementation : public Exchange::INetworkManager
+                                           , public INetworkPowerCallback
         {
             enum NetworkEvents
             {
@@ -226,6 +228,9 @@ namespace WPEFramework
 
                 uint32_t WiFiConnect(const WiFiConnectTo& ssid /* @in */) override;
                 uint32_t WiFiDisconnect(void) override;
+                uint32_t EthernetDeactivate(void);
+                uint32_t EthernetActivate(void);
+                uint32_t RequestDHCPLease(const string& iface);
                 uint32_t GetConnectedSSID(WiFiSSIDInfo&  ssidInfo /* @out */) override;
 
                 uint32_t StartWPS(const WiFiWPS& method /* @in */, const string& wps_pin /* @in */) override;
@@ -277,6 +282,13 @@ namespace WPEFramework
                 void ReportWiFiSignalQualityChange(const string ssid, const int strength, const int noise, const int snr, const Exchange::INetworkManager::WiFiSignalQuality quality);
                 void logTelemetry(const std::string& eventName, const std::string& message);
 
+                // INetworkPowerCallback overrides
+                void OnPowerModePreChange(const Exchange::IPowerManager::PowerState currentState,
+                                          const Exchange::IPowerManager::PowerState newState,
+                                          std::function<void()> sendAck) override;
+                void OnPowerModeChanged(const Exchange::IPowerManager::PowerState currentState,
+                                        const Exchange::IPowerManager::PowerState newState) override;
+
             private:
                 void platform_init(void);
                 void platform_deinit(void);
@@ -314,6 +326,7 @@ namespace WPEFramework
                 std::atomic<bool> m_stopThread{false};
                 std::mutex m_condVariableMutex;
                 std::condition_variable m_condVariable;
+                std::unique_ptr<NetworkManagerPowerClient> _powerClient;
             public:
                 IPAddress m_ethIPv4Address;
                 IPAddress m_wlanIPv4Address;
@@ -323,6 +336,8 @@ namespace WPEFramework
                 std::atomic<bool> m_wlanConnected;
                 std::atomic<bool> m_ethEnabled;
                 std::atomic<bool> m_wlanEnabled;
+                std::atomic<bool> m_ethDisconnectedForSleep;
+                std::atomic<bool> m_wlanDisconnectedForSleep;
                 std::string m_lastConnectedSSID;
                 NMClient *m_nmClient{nullptr};          /* proxy NMClient — bound to m_nmContext */
                 GMainContext *m_nmContext{nullptr};     /* isolated context, not the global default */