src/adaptations/device-layer/include/Weave/DeviceLayer/ConnectivityManager.h - third_party/openweave-core - Git at Google

 /*
  *
  *    Copyright (c) 2018 Nest Labs, Inc.
  *    All rights reserved.
  *
  *    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
  *          Defines the public interface for the Device Layer ConnectivityManager object.
  */

 #ifndef CONNECTIVITY_MANAGER_H
 #define CONNECTIVITY_MANAGER_H

 namespace nl {
 namespace Weave {
 namespace DeviceLayer {

 namespace Internal {
 class NetworkProvisioningServerImpl;
 template<class> class GenericNetworkProvisioningServerImpl;
 template<class> class GenericPlatformManagerImpl;
 template<class> class GenericPlatformManagerImpl_FreeRTOS;
 } // namespace Internal

 class ConnectivityManagerImpl;

 /**
  * Provides control of network connectivity for a Weave device.
  */
 class ConnectivityManager
 {
     using ImplClass = ::nl::Weave::DeviceLayer::ConnectivityManagerImpl;

 public:

     // ===== Members that define the public interface of the ConnectivityManager

     enum WiFiStationMode
     {
         kWiFiStationMode_NotSupported               = 0,
         kWiFiStationMode_ApplicationControlled      = 1,
         kWiFiStationMode_Disabled                   = 2,
         kWiFiStationMode_Enabled                    = 3,
     };

     enum WiFiAPMode
     {
         kWiFiAPMode_NotSupported                    = 0,
         kWiFiAPMode_ApplicationControlled           = 1,
         kWiFiAPMode_Disabled                        = 2,
         kWiFiAPMode_Enabled                         = 3,
         kWiFiAPMode_OnDemand                        = 4,
         kWiFiAPMode_OnDemand_NoStationProvision     = 5,
     };

     enum ThreadMode
     {
         kThreadMode_NotSupported                    = 0,
         kThreadMode_ApplicationControlled           = 1,
         kThreadMode_Disabled                        = 2,
         kThreadMode_Enabled                         = 3,
     };

     enum ServiceTunnelMode
     {
         kServiceTunnelMode_NotSupported             = 0,
         kServiceTunnelMode_Disabled                 = 1,
         kServiceTunnelMode_Enabled                  = 2,
     };

     enum WoBLEServiceMode
     {
         kWoBLEServiceMode_NotSupported              = 0,
         kWoBLEServiceMode_Enabled                   = 1,
         kWoBLEServiceMode_Disabled                  = 2,
     };

     enum ThreadDeviceType
     {
         kThreadDeviceType_NotSupported              = 0,
         kThreadDeviceType_Router                    = 1,
         kThreadDeviceType_FullEndDevice             = 2,
         kThreadDeviceType_MinimalEndDevice          = 3,
         kThreadDeviceType_SleepyEndDevice           = 4,
     };

     struct ThreadPollingConfig;

     // WiFi station methods
     WiFiStationMode GetWiFiStationMode(void);
     WEAVE_ERROR SetWiFiStationMode(WiFiStationMode val);
     bool IsWiFiStationEnabled(void);
     bool IsWiFiStationApplicationControlled(void);
     bool IsWiFiStationConnected(void);
     uint32_t GetWiFiStationReconnectIntervalMS(void);
     WEAVE_ERROR SetWiFiStationReconnectIntervalMS(uint32_t val);
     bool IsWiFiStationProvisioned(void);
     void ClearWiFiStationProvision(void);
     WEAVE_ERROR GetAndLogWifiStatsCounters(void);

     // WiFi AP methods
     WiFiAPMode GetWiFiAPMode(void);
     WEAVE_ERROR SetWiFiAPMode(WiFiAPMode val);
     bool IsWiFiAPActive(void);
     bool IsWiFiAPApplicationControlled(void);
     void DemandStartWiFiAP(void);
     void StopOnDemandWiFiAP(void);
     void MaintainOnDemandWiFiAP(void);
     uint32_t GetWiFiAPIdleTimeoutMS(void);
     void SetWiFiAPIdleTimeoutMS(uint32_t val);

     // Thread Methods
     ThreadMode GetThreadMode(void);
     WEAVE_ERROR SetThreadMode(ThreadMode val);
     bool IsThreadEnabled(void);
     bool IsThreadApplicationControlled(void);
     ThreadDeviceType GetThreadDeviceType(void);
     WEAVE_ERROR SetThreadDeviceType(ThreadDeviceType deviceType);
     void GetThreadPollingConfig(ThreadPollingConfig & pollingConfig);
     WEAVE_ERROR SetThreadPollingConfig(const ThreadPollingConfig & pollingConfig);
     bool IsThreadAttached(void);
     bool IsThreadProvisioned(void);
     void ClearThreadProvision(void);
     bool HaveServiceConnectivityViaThread(void);

     // Internet connectivity methods
     bool HaveIPv4InternetConnectivity(void);
     bool HaveIPv6InternetConnectivity(void);

     // Service tunnel methods
     ServiceTunnelMode GetServiceTunnelMode(void);
     WEAVE_ERROR SetServiceTunnelMode(ServiceTunnelMode val);
     bool IsServiceTunnelConnected(void);
     bool IsServiceTunnelRestricted(void);
     bool HaveServiceConnectivityViaTunnel(void);

     // Service connectivity methods
     bool HaveServiceConnectivity(void);

     // WoBLE service methods
     WoBLEServiceMode GetWoBLEServiceMode(void);
     WEAVE_ERROR SetWoBLEServiceMode(WoBLEServiceMode val);
     bool IsBLEAdvertisingEnabled(void);
     WEAVE_ERROR SetBLEAdvertisingEnabled(bool val);
     bool IsBLEFastAdvertisingEnabled(void);
     WEAVE_ERROR SetBLEFastAdvertisingEnabled(bool val);
     bool IsBLEAdvertising(void);
     WEAVE_ERROR GetBLEDeviceName(char * buf, size_t bufSize);
     WEAVE_ERROR SetBLEDeviceName(const char * deviceName);
     uint16_t NumBLEConnections(void);

     // User selected mode methods
     bool IsUserSelectedModeActive(void);
     void SetUserSelectedMode(bool val);
     uint16_t GetUserSelectedModeTimeout(void);
     void SetUserSelectedModeTimeout(uint16_t val);

     // Support methods
     static const char * WiFiStationModeToStr(WiFiStationMode mode);
     static const char * WiFiAPModeToStr(WiFiAPMode mode);
     static const char * ServiceTunnelModeToStr(ServiceTunnelMode mode);
     static const char * WoBLEServiceModeToStr(WoBLEServiceMode mode);

 private:

     // ===== Members for internal use by the following friends.

     friend class PlatformManagerImpl;
     template<class> friend class Internal::GenericPlatformManagerImpl;
     template<class> friend class Internal::GenericPlatformManagerImpl_FreeRTOS;
     friend class Internal::NetworkProvisioningServerImpl;
     template<class> friend class Internal::GenericNetworkProvisioningServerImpl;

     WEAVE_ERROR Init(void);
     void OnPlatformEvent(const WeaveDeviceEvent * event);
     bool CanStartWiFiScan(void);
     void OnWiFiScanDone(void);
     void OnWiFiStationProvisionChange(void);

 protected:

     // Construction/destruction limited to subclasses.
     ConnectivityManager() = default;
     ~ConnectivityManager() = default;

     // No copy, move or assignment.
     ConnectivityManager(const ConnectivityManager &) = delete;
     ConnectivityManager(const ConnectivityManager &&) = delete;
     ConnectivityManager & operator=(const ConnectivityManager &) = delete;
 };

 /**
  * Information describing the desired Thread polling behavior of a device.
  */
 struct ConnectivityManager::ThreadPollingConfig
 {
     uint32_t ActivePollingIntervalMS;                   /**< Interval at which the device polls its parent Thread router when
                                                              when there are active Weave exchanges in progress. Only meaningful
                                                              when the device is acting as a sleepy end node. */

     uint32_t InactivePollingIntervalMS;                 /**< Interval at which the device polls its parent Thread router when
                                                              when there are NO active Weave exchanges in progress. Only meaningful
                                                              when the device is acting as a sleepy end node. */

     void Clear() { memset(this, 0, sizeof(*this)); }
 };


 /**
  * Returns a reference to the public interface of the ConnectivityManager singleton object.
  *
  * Weave applications should use this to access features of the ConnectivityManager object
  * that are common to all platforms.
  */
 extern ConnectivityManager & ConnectivityMgr(void);

 /**
  * Returns the platform-specific implementation of the ConnectivityManager singleton object.
  *
  * Weave applications can use this to gain access to features of the ConnectivityManager
  * that are specific to the selected platform.
  */
 extern ConnectivityManagerImpl & ConnectivityMgrImpl(void);

 } // namespace DeviceLayer
 } // namespace Weave
 } // namespace nl


 /* Include a header file containing the implementation of the ConfigurationManager
  * object for the selected platform.
  */
 #ifdef EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
 #include EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
 #else
 #define CONNECTIVITYMANAGERIMPL_HEADER <Weave/DeviceLayer/WEAVE_DEVICE_LAYER_TARGET/ConnectivityManagerImpl.h>
 #include CONNECTIVITYMANAGERIMPL_HEADER
 #endif


 namespace nl {
 namespace Weave {
 namespace DeviceLayer {

 inline ConnectivityManager::WiFiStationMode ConnectivityManager::GetWiFiStationMode(void)
 {
     return static_cast<ImplClass*>(this)->_GetWiFiStationMode();
 }

 inline WEAVE_ERROR ConnectivityManager::SetWiFiStationMode(WiFiStationMode val)
 {
     return static_cast<ImplClass*>(this)->_SetWiFiStationMode(val);
 }

 inline bool ConnectivityManager::IsWiFiStationEnabled(void)
 {
     return static_cast<ImplClass*>(this)->_IsWiFiStationEnabled();
 }

 inline bool ConnectivityManager::IsWiFiStationApplicationControlled(void)
 {
     return static_cast<ImplClass*>(this)->_IsWiFiStationApplicationControlled();
 }

 inline bool ConnectivityManager::IsWiFiStationConnected(void)
 {
     return static_cast<ImplClass*>(this)->_IsWiFiStationConnected();
 }

 inline uint32_t ConnectivityManager::GetWiFiStationReconnectIntervalMS(void)
 {
     return static_cast<ImplClass*>(this)->_GetWiFiStationReconnectIntervalMS();
 }

 inline WEAVE_ERROR ConnectivityManager::SetWiFiStationReconnectIntervalMS(uint32_t val)
 {
     return static_cast<ImplClass*>(this)->_SetWiFiStationReconnectIntervalMS(val);
 }

 inline bool ConnectivityManager::IsWiFiStationProvisioned(void)
 {
     return static_cast<ImplClass*>(this)->_IsWiFiStationProvisioned();
 }

 inline void ConnectivityManager::ClearWiFiStationProvision(void)
 {
     static_cast<ImplClass*>(this)->_ClearWiFiStationProvision();
 }

 inline ConnectivityManager::WiFiAPMode ConnectivityManager::GetWiFiAPMode(void)
 {
     return static_cast<ImplClass*>(this)->_GetWiFiAPMode();
 }

 inline WEAVE_ERROR ConnectivityManager::SetWiFiAPMode(WiFiAPMode val)
 {
     return static_cast<ImplClass*>(this)->_SetWiFiAPMode(val);
 }

 inline bool ConnectivityManager::IsWiFiAPActive(void)
 {
     return static_cast<ImplClass*>(this)->_IsWiFiAPActive();
 }

 inline bool ConnectivityManager::IsWiFiAPApplicationControlled(void)
 {
     return static_cast<ImplClass*>(this)->_IsWiFiAPApplicationControlled();
 }

 inline void ConnectivityManager::DemandStartWiFiAP(void)
 {
     static_cast<ImplClass*>(this)->_DemandStartWiFiAP();
 }

 inline void ConnectivityManager::StopOnDemandWiFiAP(void)
 {
     static_cast<ImplClass*>(this)->_StopOnDemandWiFiAP();
 }

 inline void ConnectivityManager::MaintainOnDemandWiFiAP(void)
 {
     static_cast<ImplClass*>(this)->_MaintainOnDemandWiFiAP();
 }

 inline uint32_t ConnectivityManager::GetWiFiAPIdleTimeoutMS(void)
 {
     return static_cast<ImplClass*>(this)->_GetWiFiAPIdleTimeoutMS();
 }

 inline void ConnectivityManager::SetWiFiAPIdleTimeoutMS(uint32_t val)
 {
     static_cast<ImplClass*>(this)->_SetWiFiAPIdleTimeoutMS(val);
 }

 inline WEAVE_ERROR ConnectivityManager::GetAndLogWifiStatsCounters(void)
 {
     return static_cast<ImplClass*>(this)->_GetAndLogWifiStatsCounters();
 }

 inline bool ConnectivityManager::HaveServiceConnectivityViaTunnel(void)
 {
     return static_cast<ImplClass*>(this)->_HaveServiceConnectivityViaTunnel();
 }

 inline bool ConnectivityManager::HaveIPv4InternetConnectivity(void)
 {
     return static_cast<ImplClass*>(this)->_HaveIPv4InternetConnectivity();
 }

 inline bool ConnectivityManager::HaveIPv6InternetConnectivity(void)
 {
     return static_cast<ImplClass*>(this)->_HaveIPv6InternetConnectivity();
 }

 inline ConnectivityManager::ServiceTunnelMode ConnectivityManager::GetServiceTunnelMode(void)
 {
     return static_cast<ImplClass*>(this)->_GetServiceTunnelMode();
 }

 inline WEAVE_ERROR ConnectivityManager::SetServiceTunnelMode(ServiceTunnelMode val)
 {
     return static_cast<ImplClass*>(this)->_SetServiceTunnelMode(val);
 }

 inline bool ConnectivityManager::IsServiceTunnelConnected(void)
 {
     return static_cast<ImplClass*>(this)->_IsServiceTunnelConnected();
 }

 inline bool ConnectivityManager::IsServiceTunnelRestricted(void)
 {
     return static_cast<ImplClass*>(this)->_IsServiceTunnelRestricted();
 }

 inline bool ConnectivityManager::HaveServiceConnectivity(void)
 {
     return static_cast<ImplClass*>(this)->_HaveServiceConnectivity();
 }

 inline ConnectivityManager::ThreadMode ConnectivityManager::GetThreadMode(void)
 {
     return static_cast<ImplClass*>(this)->_GetThreadMode();
 }

 inline WEAVE_ERROR ConnectivityManager::SetThreadMode(ThreadMode val)
 {
     return static_cast<ImplClass*>(this)->_SetThreadMode(val);
 }

 inline bool ConnectivityManager::IsThreadEnabled(void)
 {
     return static_cast<ImplClass*>(this)->_IsThreadEnabled();
 }

 inline bool ConnectivityManager::IsThreadApplicationControlled(void)
 {
     return static_cast<ImplClass*>(this)->_IsThreadApplicationControlled();
 }

 inline ConnectivityManager::ThreadDeviceType ConnectivityManager::GetThreadDeviceType(void)
 {
     return static_cast<ImplClass*>(this)->_GetThreadDeviceType();
 }

 inline WEAVE_ERROR ConnectivityManager::SetThreadDeviceType(ThreadDeviceType deviceType)
 {
     return static_cast<ImplClass*>(this)->_SetThreadDeviceType(deviceType);
 }

 inline void ConnectivityManager::GetThreadPollingConfig(ThreadPollingConfig & pollingConfig)
 {
     return static_cast<ImplClass*>(this)->_GetThreadPollingConfig(pollingConfig);
 }

 inline WEAVE_ERROR ConnectivityManager::SetThreadPollingConfig(const ThreadPollingConfig & pollingConfig)
 {
     return static_cast<ImplClass*>(this)->_SetThreadPollingConfig(pollingConfig);
 }

 inline bool ConnectivityManager::IsThreadAttached(void)
 {
     return static_cast<ImplClass*>(this)->_IsThreadAttached();
 }

 inline bool ConnectivityManager::IsThreadProvisioned(void)
 {
     return static_cast<ImplClass*>(this)->_IsThreadProvisioned();
 }

 inline void ConnectivityManager::ClearThreadProvision(void)
 {
     static_cast<ImplClass*>(this)->_ClearThreadProvision();
 }

 inline bool ConnectivityManager::HaveServiceConnectivityViaThread(void)
 {
     return static_cast<ImplClass*>(this)->_HaveServiceConnectivityViaThread();
 }

 inline ConnectivityManager::WoBLEServiceMode ConnectivityManager::GetWoBLEServiceMode(void)
 {
     return static_cast<ImplClass*>(this)->_GetWoBLEServiceMode();
 }

 inline WEAVE_ERROR ConnectivityManager::SetWoBLEServiceMode(WoBLEServiceMode val)
 {
     return static_cast<ImplClass*>(this)->_SetWoBLEServiceMode(val);
 }

 inline bool ConnectivityManager::IsBLEAdvertisingEnabled(void)
 {
     return static_cast<ImplClass*>(this)->_IsBLEAdvertisingEnabled();
 }

 inline WEAVE_ERROR ConnectivityManager::SetBLEAdvertisingEnabled(bool val)
 {
     return static_cast<ImplClass*>(this)->_SetBLEAdvertisingEnabled(val);
 }

 inline bool ConnectivityManager::IsBLEFastAdvertisingEnabled(void)
 {
     return static_cast<ImplClass*>(this)->_IsBLEFastAdvertisingEnabled();
 }

 inline WEAVE_ERROR ConnectivityManager::SetBLEFastAdvertisingEnabled(bool val)
 {
     return static_cast<ImplClass*>(this)->_SetBLEFastAdvertisingEnabled(val);
 }

 inline bool ConnectivityManager::IsBLEAdvertising(void)
 {
     return static_cast<ImplClass*>(this)->_IsBLEAdvertising();
 }

 inline WEAVE_ERROR ConnectivityManager::GetBLEDeviceName(char * buf, size_t bufSize)
 {
     return static_cast<ImplClass*>(this)->_GetBLEDeviceName(buf, bufSize);
 }

 inline WEAVE_ERROR ConnectivityManager::SetBLEDeviceName(const char * deviceName)
 {
     return static_cast<ImplClass*>(this)->_SetBLEDeviceName(deviceName);
 }

 inline uint16_t ConnectivityManager::NumBLEConnections(void)
 {
     return static_cast<ImplClass*>(this)->_NumBLEConnections();
 }

 inline bool ConnectivityManager::IsUserSelectedModeActive(void)
 {
     return static_cast<ImplClass*>(this)->_IsUserSelectedModeActive();
 }

 inline void ConnectivityManager::SetUserSelectedMode(bool val)
 {
     static_cast<ImplClass*>(this)->_SetUserSelectedMode(val);
 }

 inline uint16_t ConnectivityManager::GetUserSelectedModeTimeout(void)
 {
     return static_cast<ImplClass*>(this)->_GetUserSelectedModeTimeout();
 }

 inline void ConnectivityManager::SetUserSelectedModeTimeout(uint16_t val)
 {
     static_cast<ImplClass*>(this)->_SetUserSelectedModeTimeout(val);
 }

 inline const char * ConnectivityManager::WiFiStationModeToStr(WiFiStationMode mode)
 {
     return ImplClass::_WiFiStationModeToStr(mode);
 }

 inline const char * ConnectivityManager::WiFiAPModeToStr(WiFiAPMode mode)
 {
     return ImplClass::_WiFiAPModeToStr(mode);
 }

 inline const char * ConnectivityManager::ServiceTunnelModeToStr(ServiceTunnelMode mode)
 {
     return ImplClass::_ServiceTunnelModeToStr(mode);
 }

 inline const char * ConnectivityManager::WoBLEServiceModeToStr(WoBLEServiceMode mode)
 {
     return ImplClass::_WoBLEServiceModeToStr(mode);
 }

 inline WEAVE_ERROR ConnectivityManager::Init(void)
 {
     return static_cast<ImplClass*>(this)->_Init();
 }

 inline void ConnectivityManager::OnPlatformEvent(const WeaveDeviceEvent * event)
 {
     static_cast<ImplClass*>(this)->_OnPlatformEvent(event);
 }

 inline bool ConnectivityManager::CanStartWiFiScan(void)
 {
     return static_cast<ImplClass*>(this)->_CanStartWiFiScan();
 }

 inline void ConnectivityManager::OnWiFiScanDone(void)
 {
     static_cast<ImplClass*>(this)->_OnWiFiScanDone();
 }

 inline void ConnectivityManager::OnWiFiStationProvisionChange(void)
 {
     static_cast<ImplClass*>(this)->_OnWiFiStationProvisionChange();
 }

 } // namespace DeviceLayer
 } // namespace Weave
 } // namespace nl

 #endif // CONNECTIVITY_MANAGER_H
	/*
	*
	* Copyright (c) 2018 Nest Labs, Inc.
	* All rights reserved.
	*
	* 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
	* Defines the public interface for the Device Layer ConnectivityManager object.
	*/

	#ifndef CONNECTIVITY_MANAGER_H
	#define CONNECTIVITY_MANAGER_H

	namespace nl {
	namespace Weave {
	namespace DeviceLayer {

	namespace Internal {
	class NetworkProvisioningServerImpl;
	template<class> class GenericNetworkProvisioningServerImpl;
	template<class> class GenericPlatformManagerImpl;
	template<class> class GenericPlatformManagerImpl_FreeRTOS;
	} // namespace Internal

	class ConnectivityManagerImpl;

	/**
	* Provides control of network connectivity for a Weave device.
	*/
	class ConnectivityManager
	{
	using ImplClass = ::nl::Weave::DeviceLayer::ConnectivityManagerImpl;

	public:

	// ===== Members that define the public interface of the ConnectivityManager

	enum WiFiStationMode
	{
	kWiFiStationMode_NotSupported = 0,
	kWiFiStationMode_ApplicationControlled = 1,
	kWiFiStationMode_Disabled = 2,
	kWiFiStationMode_Enabled = 3,
	};

	enum WiFiAPMode
	{
	kWiFiAPMode_NotSupported = 0,
	kWiFiAPMode_ApplicationControlled = 1,
	kWiFiAPMode_Disabled = 2,
	kWiFiAPMode_Enabled = 3,
	kWiFiAPMode_OnDemand = 4,
	kWiFiAPMode_OnDemand_NoStationProvision = 5,
	};

	enum ThreadMode
	{
	kThreadMode_NotSupported = 0,
	kThreadMode_ApplicationControlled = 1,
	kThreadMode_Disabled = 2,
	kThreadMode_Enabled = 3,
	};

	enum ServiceTunnelMode
	{
	kServiceTunnelMode_NotSupported = 0,
	kServiceTunnelMode_Disabled = 1,
	kServiceTunnelMode_Enabled = 2,
	};

	enum WoBLEServiceMode
	{
	kWoBLEServiceMode_NotSupported = 0,
	kWoBLEServiceMode_Enabled = 1,
	kWoBLEServiceMode_Disabled = 2,
	};

	enum ThreadDeviceType
	{
	kThreadDeviceType_NotSupported = 0,
	kThreadDeviceType_Router = 1,
	kThreadDeviceType_FullEndDevice = 2,
	kThreadDeviceType_MinimalEndDevice = 3,
	kThreadDeviceType_SleepyEndDevice = 4,
	};

	struct ThreadPollingConfig;

	// WiFi station methods
	WiFiStationMode GetWiFiStationMode(void);
	WEAVE_ERROR SetWiFiStationMode(WiFiStationMode val);
	bool IsWiFiStationEnabled(void);
	bool IsWiFiStationApplicationControlled(void);
	bool IsWiFiStationConnected(void);
	uint32_t GetWiFiStationReconnectIntervalMS(void);
	WEAVE_ERROR SetWiFiStationReconnectIntervalMS(uint32_t val);
	bool IsWiFiStationProvisioned(void);
	void ClearWiFiStationProvision(void);
	WEAVE_ERROR GetAndLogWifiStatsCounters(void);

	// WiFi AP methods
	WiFiAPMode GetWiFiAPMode(void);
	WEAVE_ERROR SetWiFiAPMode(WiFiAPMode val);
	bool IsWiFiAPActive(void);
	bool IsWiFiAPApplicationControlled(void);
	void DemandStartWiFiAP(void);
	void StopOnDemandWiFiAP(void);
	void MaintainOnDemandWiFiAP(void);
	uint32_t GetWiFiAPIdleTimeoutMS(void);
	void SetWiFiAPIdleTimeoutMS(uint32_t val);

	// Thread Methods
	ThreadMode GetThreadMode(void);
	WEAVE_ERROR SetThreadMode(ThreadMode val);
	bool IsThreadEnabled(void);
	bool IsThreadApplicationControlled(void);
	ThreadDeviceType GetThreadDeviceType(void);
	WEAVE_ERROR SetThreadDeviceType(ThreadDeviceType deviceType);
	void GetThreadPollingConfig(ThreadPollingConfig & pollingConfig);
	WEAVE_ERROR SetThreadPollingConfig(const ThreadPollingConfig & pollingConfig);
	bool IsThreadAttached(void);
	bool IsThreadProvisioned(void);
	void ClearThreadProvision(void);
	bool HaveServiceConnectivityViaThread(void);

	// Internet connectivity methods
	bool HaveIPv4InternetConnectivity(void);
	bool HaveIPv6InternetConnectivity(void);

	// Service tunnel methods
	ServiceTunnelMode GetServiceTunnelMode(void);
	WEAVE_ERROR SetServiceTunnelMode(ServiceTunnelMode val);
	bool IsServiceTunnelConnected(void);
	bool IsServiceTunnelRestricted(void);
	bool HaveServiceConnectivityViaTunnel(void);

	// Service connectivity methods
	bool HaveServiceConnectivity(void);

	// WoBLE service methods
	WoBLEServiceMode GetWoBLEServiceMode(void);
	WEAVE_ERROR SetWoBLEServiceMode(WoBLEServiceMode val);
	bool IsBLEAdvertisingEnabled(void);
	WEAVE_ERROR SetBLEAdvertisingEnabled(bool val);
	bool IsBLEFastAdvertisingEnabled(void);
	WEAVE_ERROR SetBLEFastAdvertisingEnabled(bool val);
	bool IsBLEAdvertising(void);
	WEAVE_ERROR GetBLEDeviceName(char * buf, size_t bufSize);
	WEAVE_ERROR SetBLEDeviceName(const char * deviceName);
	uint16_t NumBLEConnections(void);

	// User selected mode methods
	bool IsUserSelectedModeActive(void);
	void SetUserSelectedMode(bool val);
	uint16_t GetUserSelectedModeTimeout(void);
	void SetUserSelectedModeTimeout(uint16_t val);

	// Support methods
	static const char * WiFiStationModeToStr(WiFiStationMode mode);
	static const char * WiFiAPModeToStr(WiFiAPMode mode);
	static const char * ServiceTunnelModeToStr(ServiceTunnelMode mode);
	static const char * WoBLEServiceModeToStr(WoBLEServiceMode mode);

	private:

	// ===== Members for internal use by the following friends.

	friend class PlatformManagerImpl;
	template<class> friend class Internal::GenericPlatformManagerImpl;
	template<class> friend class Internal::GenericPlatformManagerImpl_FreeRTOS;
	friend class Internal::NetworkProvisioningServerImpl;
	template<class> friend class Internal::GenericNetworkProvisioningServerImpl;

	WEAVE_ERROR Init(void);
	void OnPlatformEvent(const WeaveDeviceEvent * event);
	bool CanStartWiFiScan(void);
	void OnWiFiScanDone(void);
	void OnWiFiStationProvisionChange(void);

	protected:

	// Construction/destruction limited to subclasses.
	ConnectivityManager() = default;
	~ConnectivityManager() = default;

	// No copy, move or assignment.
	ConnectivityManager(const ConnectivityManager &) = delete;
	ConnectivityManager(const ConnectivityManager &&) = delete;
	ConnectivityManager & operator=(const ConnectivityManager &) = delete;
	};

	/**
	* Information describing the desired Thread polling behavior of a device.
	*/
	struct ConnectivityManager::ThreadPollingConfig
	{
	uint32_t ActivePollingIntervalMS; /**< Interval at which the device polls its parent Thread router when
	when there are active Weave exchanges in progress. Only meaningful
	when the device is acting as a sleepy end node. */

	uint32_t InactivePollingIntervalMS; /**< Interval at which the device polls its parent Thread router when
	when there are NO active Weave exchanges in progress. Only meaningful
	when the device is acting as a sleepy end node. */

	void Clear() { memset(this, 0, sizeof(*this)); }
	};


	/**
	* Returns a reference to the public interface of the ConnectivityManager singleton object.
	*
	* Weave applications should use this to access features of the ConnectivityManager object
	* that are common to all platforms.
	*/
	extern ConnectivityManager & ConnectivityMgr(void);

	/**
	* Returns the platform-specific implementation of the ConnectivityManager singleton object.
	*
	* Weave applications can use this to gain access to features of the ConnectivityManager
	* that are specific to the selected platform.
	*/
	extern ConnectivityManagerImpl & ConnectivityMgrImpl(void);

	} // namespace DeviceLayer
	} // namespace Weave
	} // namespace nl


	/* Include a header file containing the implementation of the ConfigurationManager
	* object for the selected platform.
	*/
	#ifdef EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
	#include EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
	#else
	#define CONNECTIVITYMANAGERIMPL_HEADER <Weave/DeviceLayer/WEAVE_DEVICE_LAYER_TARGET/ConnectivityManagerImpl.h>
	#include CONNECTIVITYMANAGERIMPL_HEADER
	#endif


	namespace nl {
	namespace Weave {
	namespace DeviceLayer {

	inline ConnectivityManager::WiFiStationMode ConnectivityManager::GetWiFiStationMode(void)
	{
	return static_cast<ImplClass*>(this)->_GetWiFiStationMode();
	}

	inline WEAVE_ERROR ConnectivityManager::SetWiFiStationMode(WiFiStationMode val)
	{
	return static_cast<ImplClass*>(this)->_SetWiFiStationMode(val);
	}

	inline bool ConnectivityManager::IsWiFiStationEnabled(void)
	{
	return static_cast<ImplClass*>(this)->_IsWiFiStationEnabled();
	}

	inline bool ConnectivityManager::IsWiFiStationApplicationControlled(void)
	{
	return static_cast<ImplClass*>(this)->_IsWiFiStationApplicationControlled();
	}

	inline bool ConnectivityManager::IsWiFiStationConnected(void)
	{
	return static_cast<ImplClass*>(this)->_IsWiFiStationConnected();
	}

	inline uint32_t ConnectivityManager::GetWiFiStationReconnectIntervalMS(void)
	{
	return static_cast<ImplClass*>(this)->_GetWiFiStationReconnectIntervalMS();
	}

	inline WEAVE_ERROR ConnectivityManager::SetWiFiStationReconnectIntervalMS(uint32_t val)
	{
	return static_cast<ImplClass*>(this)->_SetWiFiStationReconnectIntervalMS(val);
	}

	inline bool ConnectivityManager::IsWiFiStationProvisioned(void)
	{
	return static_cast<ImplClass*>(this)->_IsWiFiStationProvisioned();
	}

	inline void ConnectivityManager::ClearWiFiStationProvision(void)
	{
	static_cast<ImplClass*>(this)->_ClearWiFiStationProvision();
	}

	inline ConnectivityManager::WiFiAPMode ConnectivityManager::GetWiFiAPMode(void)
	{
	return static_cast<ImplClass*>(this)->_GetWiFiAPMode();
	}

	inline WEAVE_ERROR ConnectivityManager::SetWiFiAPMode(WiFiAPMode val)
	{
	return static_cast<ImplClass*>(this)->_SetWiFiAPMode(val);
	}

	inline bool ConnectivityManager::IsWiFiAPActive(void)
	{
	return static_cast<ImplClass*>(this)->_IsWiFiAPActive();
	}

	inline bool ConnectivityManager::IsWiFiAPApplicationControlled(void)
	{
	return static_cast<ImplClass*>(this)->_IsWiFiAPApplicationControlled();
	}

	inline void ConnectivityManager::DemandStartWiFiAP(void)
	{
	static_cast<ImplClass*>(this)->_DemandStartWiFiAP();
	}

	inline void ConnectivityManager::StopOnDemandWiFiAP(void)
	{
	static_cast<ImplClass*>(this)->_StopOnDemandWiFiAP();
	}

	inline void ConnectivityManager::MaintainOnDemandWiFiAP(void)
	{
	static_cast<ImplClass*>(this)->_MaintainOnDemandWiFiAP();
	}

	inline uint32_t ConnectivityManager::GetWiFiAPIdleTimeoutMS(void)
	{
	return static_cast<ImplClass*>(this)->_GetWiFiAPIdleTimeoutMS();
	}

	inline void ConnectivityManager::SetWiFiAPIdleTimeoutMS(uint32_t val)
	{
	static_cast<ImplClass*>(this)->_SetWiFiAPIdleTimeoutMS(val);
	}

	inline WEAVE_ERROR ConnectivityManager::GetAndLogWifiStatsCounters(void)
	{
	return static_cast<ImplClass*>(this)->_GetAndLogWifiStatsCounters();
	}

	inline bool ConnectivityManager::HaveServiceConnectivityViaTunnel(void)
	{
	return static_cast<ImplClass*>(this)->_HaveServiceConnectivityViaTunnel();
	}

	inline bool ConnectivityManager::HaveIPv4InternetConnectivity(void)
	{
	return static_cast<ImplClass*>(this)->_HaveIPv4InternetConnectivity();
	}

	inline bool ConnectivityManager::HaveIPv6InternetConnectivity(void)
	{
	return static_cast<ImplClass*>(this)->_HaveIPv6InternetConnectivity();
	}

	inline ConnectivityManager::ServiceTunnelMode ConnectivityManager::GetServiceTunnelMode(void)
	{
	return static_cast<ImplClass*>(this)->_GetServiceTunnelMode();
	}

	inline WEAVE_ERROR ConnectivityManager::SetServiceTunnelMode(ServiceTunnelMode val)
	{
	return static_cast<ImplClass*>(this)->_SetServiceTunnelMode(val);
	}

	inline bool ConnectivityManager::IsServiceTunnelConnected(void)
	{
	return static_cast<ImplClass*>(this)->_IsServiceTunnelConnected();
	}

	inline bool ConnectivityManager::IsServiceTunnelRestricted(void)
	{
	return static_cast<ImplClass*>(this)->_IsServiceTunnelRestricted();
	}

	inline bool ConnectivityManager::HaveServiceConnectivity(void)
	{
	return static_cast<ImplClass*>(this)->_HaveServiceConnectivity();
	}

	inline ConnectivityManager::ThreadMode ConnectivityManager::GetThreadMode(void)
	{
	return static_cast<ImplClass*>(this)->_GetThreadMode();
	}

	inline WEAVE_ERROR ConnectivityManager::SetThreadMode(ThreadMode val)
	{
	return static_cast<ImplClass*>(this)->_SetThreadMode(val);
	}

	inline bool ConnectivityManager::IsThreadEnabled(void)
	{
	return static_cast<ImplClass*>(this)->_IsThreadEnabled();
	}

	inline bool ConnectivityManager::IsThreadApplicationControlled(void)
	{
	return static_cast<ImplClass*>(this)->_IsThreadApplicationControlled();
	}

	inline ConnectivityManager::ThreadDeviceType ConnectivityManager::GetThreadDeviceType(void)
	{
	return static_cast<ImplClass*>(this)->_GetThreadDeviceType();
	}

	inline WEAVE_ERROR ConnectivityManager::SetThreadDeviceType(ThreadDeviceType deviceType)
	{
	return static_cast<ImplClass*>(this)->_SetThreadDeviceType(deviceType);
	}

	inline void ConnectivityManager::GetThreadPollingConfig(ThreadPollingConfig & pollingConfig)
	{
	return static_cast<ImplClass*>(this)->_GetThreadPollingConfig(pollingConfig);
	}

	inline WEAVE_ERROR ConnectivityManager::SetThreadPollingConfig(const ThreadPollingConfig & pollingConfig)
	{
	return static_cast<ImplClass*>(this)->_SetThreadPollingConfig(pollingConfig);
	}

	inline bool ConnectivityManager::IsThreadAttached(void)
	{
	return static_cast<ImplClass*>(this)->_IsThreadAttached();
	}

	inline bool ConnectivityManager::IsThreadProvisioned(void)
	{
	return static_cast<ImplClass*>(this)->_IsThreadProvisioned();
	}

	inline void ConnectivityManager::ClearThreadProvision(void)
	{
	static_cast<ImplClass*>(this)->_ClearThreadProvision();
	}

	inline bool ConnectivityManager::HaveServiceConnectivityViaThread(void)
	{
	return static_cast<ImplClass*>(this)->_HaveServiceConnectivityViaThread();
	}

	inline ConnectivityManager::WoBLEServiceMode ConnectivityManager::GetWoBLEServiceMode(void)
	{
	return static_cast<ImplClass*>(this)->_GetWoBLEServiceMode();
	}

	inline WEAVE_ERROR ConnectivityManager::SetWoBLEServiceMode(WoBLEServiceMode val)
	{
	return static_cast<ImplClass*>(this)->_SetWoBLEServiceMode(val);
	}

	inline bool ConnectivityManager::IsBLEAdvertisingEnabled(void)
	{
	return static_cast<ImplClass*>(this)->_IsBLEAdvertisingEnabled();
	}

	inline WEAVE_ERROR ConnectivityManager::SetBLEAdvertisingEnabled(bool val)
	{
	return static_cast<ImplClass*>(this)->_SetBLEAdvertisingEnabled(val);
	}

	inline bool ConnectivityManager::IsBLEFastAdvertisingEnabled(void)
	{
	return static_cast<ImplClass*>(this)->_IsBLEFastAdvertisingEnabled();
	}

	inline WEAVE_ERROR ConnectivityManager::SetBLEFastAdvertisingEnabled(bool val)
	{
	return static_cast<ImplClass*>(this)->_SetBLEFastAdvertisingEnabled(val);
	}

	inline bool ConnectivityManager::IsBLEAdvertising(void)
	{
	return static_cast<ImplClass*>(this)->_IsBLEAdvertising();
	}

	inline WEAVE_ERROR ConnectivityManager::GetBLEDeviceName(char * buf, size_t bufSize)
	{
	return static_cast<ImplClass*>(this)->_GetBLEDeviceName(buf, bufSize);
	}

	inline WEAVE_ERROR ConnectivityManager::SetBLEDeviceName(const char * deviceName)
	{
	return static_cast<ImplClass*>(this)->_SetBLEDeviceName(deviceName);
	}

	inline uint16_t ConnectivityManager::NumBLEConnections(void)
	{
	return static_cast<ImplClass*>(this)->_NumBLEConnections();
	}

	inline bool ConnectivityManager::IsUserSelectedModeActive(void)
	{
	return static_cast<ImplClass*>(this)->_IsUserSelectedModeActive();
	}

	inline void ConnectivityManager::SetUserSelectedMode(bool val)
	{
	static_cast<ImplClass*>(this)->_SetUserSelectedMode(val);
	}

	inline uint16_t ConnectivityManager::GetUserSelectedModeTimeout(void)
	{
	return static_cast<ImplClass*>(this)->_GetUserSelectedModeTimeout();
	}

	inline void ConnectivityManager::SetUserSelectedModeTimeout(uint16_t val)
	{
	static_cast<ImplClass*>(this)->_SetUserSelectedModeTimeout(val);
	}

	inline const char * ConnectivityManager::WiFiStationModeToStr(WiFiStationMode mode)
	{
	return ImplClass::_WiFiStationModeToStr(mode);
	}

	inline const char * ConnectivityManager::WiFiAPModeToStr(WiFiAPMode mode)
	{
	return ImplClass::_WiFiAPModeToStr(mode);
	}

	inline const char * ConnectivityManager::ServiceTunnelModeToStr(ServiceTunnelMode mode)
	{
	return ImplClass::_ServiceTunnelModeToStr(mode);
	}

	inline const char * ConnectivityManager::WoBLEServiceModeToStr(WoBLEServiceMode mode)
	{
	return ImplClass::_WoBLEServiceModeToStr(mode);
	}

	inline WEAVE_ERROR ConnectivityManager::Init(void)
	{
	return static_cast<ImplClass*>(this)->_Init();
	}

	inline void ConnectivityManager::OnPlatformEvent(const WeaveDeviceEvent * event)
	{
	static_cast<ImplClass*>(this)->_OnPlatformEvent(event);
	}

	inline bool ConnectivityManager::CanStartWiFiScan(void)
	{
	return static_cast<ImplClass*>(this)->_CanStartWiFiScan();
	}

	inline void ConnectivityManager::OnWiFiScanDone(void)
	{
	static_cast<ImplClass*>(this)->_OnWiFiScanDone();
	}

	inline void ConnectivityManager::OnWiFiStationProvisionChange(void)
	{
	static_cast<ImplClass*>(this)->_OnWiFiStationProvisionChange();
	}

	} // namespace DeviceLayer
	} // namespace Weave
	} // namespace nl

	#endif // CONNECTIVITY_MANAGER_H