Updated Network Telementry Manager APIs Implementation.

src/adaptations/device-layer/ESP32/ConnectivityManagerImpl.cpp

@@ -50,11 +50,9 @@
 #error "WiFi AP support must be enabled when building for ESP32"
 #endif
 
-#if WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
 #include <Weave/Support/TraitEventUtils.h>
 #include <nest/trait/network/TelemetryNetworkTrait.h>
 #include <nest/trait/network/TelemetryNetworkWifiTrait.h>
-#endif
 
 using namespace ::nl;
 using namespace ::nl::Weave;

src/adaptations/device-layer/NetworkTelemetryManager.cpp

@@ -39,122 +39,77 @@
 #include <weave/trait/telemetry/tunnel/TelemetryTunnelTrait.h>
 #endif
 
-using namespace nl::Weave::DeviceLayer;
 using namespace nl::Weave::DeviceLayer::Internal;
 
-WeaveTelemetryBase::WeaveTelemetryBase()
-{
-}
-
-void WeaveTelemetryBase::Init(uint32_t aIntervalMsec)
-{
-    SetPollingInterval(aIntervalMsec);
-    Enable();
-}
+namespace nl {
+namespace Weave {
+namespace DeviceLayer {
 
-void WeaveTelemetryBase::Enable(void)
-{
-    mEnabled = true;
-    StartPollingTimer();
-}
+NetworkTelemetryManager NetworkTelemetryManager::sInstance;
 
-void WeaveTelemetryBase::Disable(void)
-{
-    mEnabled = false;
-    StopPollingTimer();
-}
-
-void WeaveTelemetryBase::StartPollingTimer(void)
+NetworkTelemetryManager::NetworkTelemetryManager(void)
 {
-    SystemLayer.StartTimer(mInterval, sHandleTimer, this);
 }
 
-void WeaveTelemetryBase::StopPollingTimer(void)
+void NetworkTelemetryManager::Init(void)
 {
-    SystemLayer.CancelTimer(sHandleTimer, this);
+    SetPollingInterval(WEAVE_DEVICE_CONFIG_DEFAULT_TELEMETRY_INTERVAL_MS);
+    EnableTimer();
 }
 
-void WeaveTelemetryBase::HandleTimer(void)
+void NetworkTelemetryManager::EnableTimer(void)
 {
-    GetTelemetryStatsAndLogEvent();
-
+    mTimerEnabled = true;
     StartPollingTimer();
 }
 
-NetworkTelemetryManager::NetworkTelemetryManager(void)
+void NetworkTelemetryManager::DisableTimer(void)
 {
+    mTimerEnabled = false;
+    StopPollingTimer();
 }
 
-WEAVE_ERROR NetworkTelemetryManager::Init(void)
+void NetworkTelemetryManager::HandleTimer(void)
 {
-    WEAVE_ERROR err = WEAVE_NO_ERROR;
-
-    WeaveLogProgress(DeviceLayer, "Initiating Network Telemetry & Topology\n");
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
-    mWiFiTelemetry.Init(WEAVE_DEVICE_CONFIG_DEFAULT_TELEMETRY_INTERVAL_MS);
-#endif
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY
-    mThreadTelemetry.Init(WEAVE_DEVICE_CONFIG_DEFAULT_TELEMETRY_INTERVAL_MS);
-    mThreadTopology.Init(WEAVE_DEVICE_CONFIG_DEFAULT_TELEMETRY_INTERVAL_MS);
-#endif
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
-    mTunnelTelemetry.Init(WEAVE_DEVICE_CONFIG_DEFAULT_TUNNEL_TELEMETRY_INTERVAL_MS);
-#endif
-
-    return err;
+    GetAndLogNetworkTelemetry();
+    StartPollingTimer();
 }
 
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
-void WiFiTelemetry::GetTelemetryStatsAndLogEvent(void)
+void NetworkTelemetryManager::GetAndLogNetworkTelemetry(void)
 {
     WEAVE_ERROR err;
 
+#if WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
     err = ConnectivityMgr().GetAndLogWifiStatsCounters();
     SuccessOrExit(err);
-
-exit:
-    return;
-}
-#endif // WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
-
+#endif
 
 #if WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY
-void ThreadTelemetry::GetTelemetryStatsAndLogEvent(void)
-{
-    WEAVE_ERROR err;
-
     err = ThreadStackMgr().GetAndLogThreadStatsCounters();
     SuccessOrExit(err);
 
-exit:
-    return;
-}
-
-void ThreadTopology::GetTelemetryStatsAndLogEvent(void)
-{
-    WEAVE_ERROR err;
-
 #if WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY_FULL
     err = ThreadStackMgr().GetAndLogThreadTopologyFull();
     SuccessOrExit(err);
 #else
     err = ThreadStackMgr().GetAndLogThreadTopologyMinimal();
     SuccessOrExit(err);
 #endif
+#endif // WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY
+
+#if WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
+    err = GetAndLogTunnelTelemetryStats();
+    SuccessOrExit(err);
+#endif
 
 exit:
     return;
 }
-#endif // WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY
-
 
 #if WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
-void TunnelTelemetry::GetTelemetryStatsAndLogEvent(void)
+WEAVE_ERROR NetworkTelemetryManager::GetAndLogTunnelTelemetryStats(void)
 {
+    WEAVE_ERROR err = WEAVE_NO_ERROR;
     nl::Weave::Profiles::DataManagement_Current::event_id_t eventId;
     nl::Weave::Profiles::WeaveTunnel::WeaveTunnelStatistics tunnelStats;
     Schema::Weave::Trait::Telemetry::Tunnel::TelemetryTunnelTrait::TelemetryTunnelStatsEvent statsEvent;
@@ -231,8 +186,12 @@ void TunnelTelemetry::GetTelemetryStatsAndLogEvent(void)
     eventId = nl::LogEvent(&statsEvent);
     WeaveLogProgress(DeviceLayer, "Weave Tunnel Tolopoly Stats Event Id: %u\n", eventId);
 
-    return;
+    return err;
 }
 #endif // WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
 
+} // namespace DeviceLayer
+} // namespace Weave
+} // namespace nl
+
 #endif // WEAVE_DEVICE_CONFIG_ENABLE_NETWORK_TELEMETRY

src/adaptations/device-layer/include/Weave/DeviceLayer/NetworkTelemetryManager.h

@@ -23,6 +23,7 @@
  */
 
 #include <Weave/DeviceLayer/WeaveDeviceConfig.h>
+#include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
 
 #if WEAVE_DEVICE_CONFIG_ENABLE_NETWORK_TELEMETRY
 
@@ -32,115 +33,93 @@
 namespace nl {
 namespace Weave {
 namespace DeviceLayer {
-namespace Internal {
 
-#include <SystemLayer/SystemLayer.h>
+extern nl::Weave::System::Layer SystemLayer;
+
+namespace Internal {
+template<class> class GenericPlatformManagerImpl;
+}
 
 /**
- * This is a base class that handles network telemetry functions
- * for different networks.
+ * Manages network telemetry logging for a Weave device.
  */
-class WeaveTelemetryBase
+class NetworkTelemetryManager final
 {
 public:
-    WeaveTelemetryBase();
-
-    void Init(uint32_t aIntervalMsec);
+    NetworkTelemetryManager(void);
 
-    void Enable(void);
-    void Disable(void);
-    bool IsEnabled(void) const;
+    void EnableTimer(void);
+    void DisableTimer(void);
+    bool IsTimerEnabled(void) const;
     void SetPollingInterval(uint32_t aIntervalMsec);
     uint32_t GetPollingInterval(void) const;
 
+    void GetAndLogNetworkTelemetry(void);
+
 private:
+
+    // ===== Members for internal use by the following friends.
+
+    template<class> friend class Internal::GenericPlatformManagerImpl;
+    friend NetworkTelemetryManager & NetworkTelemetryMgr(void);
+
+    static NetworkTelemetryManager sInstance;
+
+    void Init(void);
+
+    // ===== Private members for use by this class only.
+
+    bool mTimerEnabled;
+    uint32_t mPollingInterval;
+
     void StartPollingTimer(void);
     void StopPollingTimer(void);
     void HandleTimer(void);
     static void sHandleTimer(nl::Weave::System::Layer * aLayer, void * aAppState, WEAVE_ERROR aError);
-    virtual void GetTelemetryStatsAndLogEvent(void) = 0;
 
-private:
-    bool mEnabled;
-    uint32_t mInterval;
+#if WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
+    WEAVE_ERROR GetAndLogTunnelTelemetryStats(void);
+#endif
 };
 
-inline bool WeaveTelemetryBase::IsEnabled(void) const
+inline bool NetworkTelemetryManager::IsTimerEnabled(void) const
 {
-    return mEnabled;
+    return mTimerEnabled;
 }
 
-inline void WeaveTelemetryBase::SetPollingInterval(uint32_t aIntervalMsec)
+inline void NetworkTelemetryManager::SetPollingInterval(uint32_t aIntervalMsec)
 {
-    mInterval = aIntervalMsec;
+    mPollingInterval = aIntervalMsec;
 }
 
-inline uint32_t WeaveTelemetryBase::GetPollingInterval(void) const
+inline uint32_t NetworkTelemetryManager::GetPollingInterval(void) const
 {
-    return mInterval;
+    return mPollingInterval;
 }
 
-inline void WeaveTelemetryBase::sHandleTimer(nl::Weave::System::Layer * aLayer, void * aAppState, WEAVE_ERROR aError)
+inline void NetworkTelemetryManager::StartPollingTimer(void)
 {
-    static_cast<WeaveTelemetryBase *>(aAppState)->HandleTimer();
+    nl::Weave::DeviceLayer::SystemLayer.StartTimer(mPollingInterval, sHandleTimer, this);
 }
 
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
-class WiFiTelemetry : public WeaveTelemetryBase
-{
-protected:
-    virtual void GetTelemetryStatsAndLogEvent(void);
-};
-#endif // WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
-
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY
-class ThreadTelemetry : public WeaveTelemetryBase
-{
-protected:
-    virtual void GetTelemetryStatsAndLogEvent(void);
-};
-
-class ThreadTopology : public WeaveTelemetryBase
+inline void NetworkTelemetryManager::StopPollingTimer(void)
 {
-protected:
-    virtual void GetTelemetryStatsAndLogEvent(void);
-};
-#endif // WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY
-
+    nl::Weave::DeviceLayer::SystemLayer.CancelTimer(sHandleTimer, this);
+}
 
-#if WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
-class TunnelTelemetry : public WeaveTelemetryBase
+inline void NetworkTelemetryManager::sHandleTimer(nl::Weave::System::Layer * aLayer, void * aAppState, WEAVE_ERROR aError)
 {
-protected:
-    virtual void GetTelemetryStatsAndLogEvent(void);
-};
-#endif // WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
-
+    static_cast<NetworkTelemetryManager *>(aAppState)->HandleTimer();
+}
 
-class NetworkTelemetryManager
+/**
+ * Returns a reference to the NetworkTelemetryManager singleton object.
+ */
+inline NetworkTelemetryManager & NetworkTelemetryMgr(void)
 {
-public:
-    NetworkTelemetryManager(void);
-
-    WEAVE_ERROR Init(void);
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_WIFI_TELEMETRY
-    WiFiTelemetry mWiFiTelemetry;
-#endif
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_THREAD_TELEMETRY
-    ThreadTelemetry mThreadTelemetry;
-    ThreadTopology mThreadTopology;
-#endif
-
-#if WEAVE_DEVICE_CONFIG_ENABLE_TUNNEL_TELEMETRY
-    TunnelTelemetry mTunnelTelemetry;
-#endif
-};
+    return NetworkTelemetryManager::sInstance;
+}
 
-} // namespace Internal
 } // namespace DeviceLayer
 } // namespace Weave
 } // namespace nl

src/adaptations/device-layer/include/Weave/DeviceLayer/WeaveDeviceLayer.h

@@ -28,6 +28,7 @@
 #include <Weave/DeviceLayer/PlatformManager.h>
 #include <Weave/DeviceLayer/ConfigurationManager.h>
 #include <Weave/DeviceLayer/ConnectivityManager.h>
+#include <Weave/DeviceLayer/NetworkTelemetryManager.h>
 #if WEAVE_DEVICE_CONFIG_ENABLE_TRAIT_MANAGER
 #include <Weave/DeviceLayer/TraitManager.h>
 #endif // WEAVE_DEVICE_CONFIG_ENABLE_TRAIT_MANAGER

src/adaptations/device-layer/include/Weave/DeviceLayer/internal/GenericPlatformManagerImpl.ipp

@@ -255,6 +255,11 @@ WEAVE_ERROR GenericPlatformManagerImpl<ImplClass>::_InitWeaveStack(void)
     SuccessOrExit(err);
 #endif // WEAVE_DEVICE_CONFIG_ENABLE_TRAIT_MANAGER
 
+    // Initialize the Network Telemetry Manager object.
+#if WEAVE_DEVICE_CONFIG_ENABLE_NETWORK_TELEMETRY
+    NetworkTelemetryMgr().Init();
+#endif
+
     // Initialize the Time Sync Manager object.
     err = TimeSyncMgr().Init();
     if (err != WEAVE_NO_ERROR)