src/include/platform/ConnectivityManager.h

/*
 *
 *    Copyright (c) 2020 Project CHIP Authors
 *    Copyright (c) 2018 Nest Labs, Inc.
 *
 *    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.
 */

#pragma once
#include <memory>

#include <app/AttributeAccessInterface.h>
#include <inet/UDPEndPoint.h>
#include <lib/support/CodeUtils.h>
#include <platform/CHIPDeviceBuildConfig.h>
#include <platform/CHIPDeviceConfig.h>
#include <platform/CHIPDeviceEvent.h>

#include <app-common/zap-generated/cluster-objects.h>
#include <app/util/basic-types.h>

#if INET_CONFIG_ENABLE_TCP_ENDPOINT
#include <inet/TCPEndPoint.h>
#endif

namespace chip {

namespace Ble {
class BleLayer;
class BLEEndPoint;
} // namespace Ble

namespace DeviceLayer {

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

class ConnectivityManager;
class ConnectivityManagerImpl;

/**
 * Defines the delegate class of Connectivity Manager to notify connectivity updates.
 */
class ConnectivityManagerDelegate
{
public:
    virtual ~ConnectivityManagerDelegate() {}

    /**
     * @brief
     *   Called when any network interface on the Node is changed
     *
     */
    virtual void OnNetworkInfoChanged() {}
};

/**
 * Provides control of network connectivity for a chip device.
 */
class ConnectivityManager
{
    using ImplClass = ::chip::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 WiFiStationState
    {
        kWiFiStationState_NotConnected,
        kWiFiStationState_Connecting,
        kWiFiStationState_Connecting_Succeeded,
        kWiFiStationState_Connecting_Failed,
        kWiFiStationState_Connected,
        kWiFiStationState_Disconnecting,
    };

    enum WiFiAPState
    {
        kWiFiAPState_NotActive,
        kWiFiAPState_Activating,
        kWiFiAPState_Active,
        kWiFiAPState_Deactivating,
    };

    enum CHIPoBLEServiceMode
    {
        kCHIPoBLEServiceMode_NotSupported = 0,
        kCHIPoBLEServiceMode_Enabled      = 1,
        kCHIPoBLEServiceMode_Disabled     = 2,
    };

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

    enum BLEAdvertisingMode
    {
        kFastAdvertising = 0,
        kSlowAdvertising = 1,
    };

    enum class SEDIntervalMode
    {
        Idle   = 0,
        Active = 1,
    };

    struct SEDIntervalsConfig;

    void SetDelegate(ConnectivityManagerDelegate * delegate) { mDelegate = delegate; }
    ConnectivityManagerDelegate * GetDelegate() const { return mDelegate; }

    chip::Inet::EndPointManager<Inet::UDPEndPoint> & UDPEndPointManager();

#if INET_CONFIG_ENABLE_TCP_ENDPOINT
    chip::Inet::EndPointManager<Inet::TCPEndPoint> & TCPEndPointManager();
#endif

    // WiFi station methods
    WiFiStationMode GetWiFiStationMode();
    CHIP_ERROR SetWiFiStationMode(WiFiStationMode val);
    bool IsWiFiStationEnabled();
    bool IsWiFiStationApplicationControlled();
    bool IsWiFiStationConnected();
    System::Clock::Timeout GetWiFiStationReconnectInterval();
    CHIP_ERROR SetWiFiStationReconnectInterval(System::Clock::Timeout val);
    bool IsWiFiStationProvisioned();
    void ClearWiFiStationProvision();
    CHIP_ERROR GetAndLogWiFiStatsCounters();

    // WiFi AP methods
    WiFiAPMode GetWiFiAPMode();
    CHIP_ERROR SetWiFiAPMode(WiFiAPMode val);
    bool IsWiFiAPActive();
    bool IsWiFiAPApplicationControlled();
    void DemandStartWiFiAP();
    void StopOnDemandWiFiAP();
    void MaintainOnDemandWiFiAP();
    System::Clock::Timeout GetWiFiAPIdleTimeout();
    void SetWiFiAPIdleTimeout(System::Clock::Timeout val);

    // Thread Methods
    ThreadMode GetThreadMode();
    CHIP_ERROR SetThreadMode(ThreadMode val);
    bool IsThreadEnabled();
    bool IsThreadApplicationControlled();
    ThreadDeviceType GetThreadDeviceType();
    CHIP_ERROR SetThreadDeviceType(ThreadDeviceType deviceType);
    bool IsThreadAttached();
    bool IsThreadProvisioned();
    void ErasePersistentInfo();
    void ResetThreadNetworkDiagnosticsCounts();
    CHIP_ERROR WriteThreadNetworkDiagnosticAttributeToTlv(AttributeId attributeId, app::AttributeValueEncoder & encoder);

// Sleepy end device methods
#if CHIP_DEVICE_CONFIG_ENABLE_SED
    CHIP_ERROR GetSEDIntervalsConfig(SEDIntervalsConfig & intervalsConfig);

    /**
     * Sets Sleepy End Device intervals configuration and posts kSEDIntervalChange event to inform other software
     * modules about the change.
     *
     * @param[in]  intervalsConfig intervals configuration to be set
     */
    CHIP_ERROR SetSEDIntervalsConfig(const SEDIntervalsConfig & intervalsConfig);

    /**
     * Requests setting Sleepy End Device active interval on or off.
     * Every method call with onOff parameter set to true or false results in incrementing or decrementing the active mode
     * consumers counter. Active mode is set if the consumers counter is bigger than 0.
     *
     * @param[in]  onOff  true if active mode should be enabled and false otherwise.
     */
    CHIP_ERROR RequestSEDActiveMode(bool onOff);
#endif

    // CHIPoBLE service methods
    Ble::BleLayer * GetBleLayer();
    bool IsBLEAdvertisingEnabled();
    /**
     * Enable or disable BLE advertising.
     *
     * @return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE if BLE advertising is not
     * supported or other error on other failures.
     */
    CHIP_ERROR SetBLEAdvertisingEnabled(bool val);
    bool IsBLEAdvertising();
    CHIP_ERROR SetBLEAdvertisingMode(BLEAdvertisingMode mode);
    CHIP_ERROR GetBLEDeviceName(char * buf, size_t bufSize);
    CHIP_ERROR SetBLEDeviceName(const char * deviceName);
    uint16_t NumBLEConnections();

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

    // Support methods
    static const char * WiFiStationModeToStr(WiFiStationMode mode);
    static const char * WiFiAPModeToStr(WiFiAPMode mode);
    static const char * WiFiStationStateToStr(WiFiStationState state);
    static const char * WiFiAPStateToStr(WiFiAPState state);
    static const char * CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode);

private:
    ConnectivityManagerDelegate * mDelegate = nullptr;

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

    friend class PlatformManagerImpl;
    template <class>
    friend class Internal::GenericPlatformManagerImpl;
    template <class>
    friend class Internal::GenericPlatformManagerImpl_FreeRTOS;
    template <class>
    friend class Internal::GenericPlatformManagerImpl_POSIX;

    CHIP_ERROR Init();
    void OnPlatformEvent(const ChipDeviceEvent * event);
    bool CanStartWiFiScan();
    void OnWiFiScanDone();
    void OnWiFiStationProvisionChange();

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 intervals for a sleepy end device (SED).
 */
struct ConnectivityManager::SEDIntervalsConfig
{
    /** Interval at which the device is able to communicate with its parent when there are active chip exchanges in progress. Only
     * meaningful when the device is acting as a sleepy end node.  */
    System::Clock::Milliseconds32 ActiveIntervalMS;

    /** Interval at which the device is able to communicate with its parent when there are NO active chip exchanges in progress.
     * Only meaningful when the device is acting as a sleepy end node. */
    System::Clock::Milliseconds32 IdleIntervalMS;
};

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

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

} // namespace DeviceLayer
} // namespace chip

/* Include a header file containing the implementation of the ConfigurationManager
 * object for the selected platform.
 */
#ifdef EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
#include EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
#elif defined(CHIP_DEVICE_LAYER_TARGET)
#define CONNECTIVITYMANAGERIMPL_HEADER <platform/CHIP_DEVICE_LAYER_TARGET/ConnectivityManagerImpl.h>
#include CONNECTIVITYMANAGERIMPL_HEADER
#endif // defined(CHIP_DEVICE_LAYER_TARGET)

namespace chip {
namespace DeviceLayer {

inline chip::Inet::EndPointManager<Inet::UDPEndPoint> & ConnectivityManager::UDPEndPointManager()
{
    return static_cast<ImplClass *>(this)->_UDPEndPointManager();
}

#if INET_CONFIG_ENABLE_TCP_ENDPOINT
inline chip::Inet::EndPointManager<Inet::TCPEndPoint> & ConnectivityManager::TCPEndPointManager()
{
    return static_cast<ImplClass *>(this)->_TCPEndPointManager();
}
#endif

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

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

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

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

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

inline System::Clock::Timeout ConnectivityManager::GetWiFiStationReconnectInterval()
{
    return static_cast<ImplClass *>(this)->_GetWiFiStationReconnectInterval();
}

inline CHIP_ERROR ConnectivityManager::SetWiFiStationReconnectInterval(System::Clock::Timeout val)
{
    return static_cast<ImplClass *>(this)->_SetWiFiStationReconnectInterval(val);
}

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

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

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

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

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

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

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

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

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

inline System::Clock::Timeout ConnectivityManager::GetWiFiAPIdleTimeout()
{
    return static_cast<ImplClass *>(this)->_GetWiFiAPIdleTimeout();
}

inline void ConnectivityManager::SetWiFiAPIdleTimeout(System::Clock::Timeout val)
{
    static_cast<ImplClass *>(this)->_SetWiFiAPIdleTimeout(val);
}

inline CHIP_ERROR ConnectivityManager::GetAndLogWiFiStatsCounters()
{
    return static_cast<ImplClass *>(this)->_GetAndLogWiFiStatsCounters();
}

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

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

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

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

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

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

#if CHIP_DEVICE_CONFIG_ENABLE_SED
inline CHIP_ERROR ConnectivityManager::GetSEDIntervalsConfig(SEDIntervalsConfig & intervalsConfig)
{
    return static_cast<ImplClass *>(this)->_GetSEDIntervalsConfig(intervalsConfig);
}

inline CHIP_ERROR ConnectivityManager::SetSEDIntervalsConfig(const SEDIntervalsConfig & intervalsConfig)
{
    return static_cast<ImplClass *>(this)->_SetSEDIntervalsConfig(intervalsConfig);
}

inline CHIP_ERROR ConnectivityManager::RequestSEDActiveMode(bool onOff)
{
    return static_cast<ImplClass *>(this)->_RequestSEDActiveMode(onOff);
}
#endif

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

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

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

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

/*
 * @brief Get runtime value from the thread network based on the given attribute ID.
 *        The info is encoded via the AttributeValueEncoder.
 *
 * @param attributeId Id of the attribute for the requested info.
 * @param aEncoder Encoder to encode the attribute value.
 *
 * @return CHIP_NO_ERROR = Succes.
 *         CHIP_ERROR_NOT_IMPLEMENTED = Runtime value for this attribute to yet available to send as reply
 *                                      Use standard read.
 *         CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE = Is not a Runtime readable attribute. Use standard read
 *         All other errors should be treated as a read error and reported as such.
 */
inline CHIP_ERROR ConnectivityManager::WriteThreadNetworkDiagnosticAttributeToTlv(AttributeId attributeId,
                                                                                  app::AttributeValueEncoder & encoder)
{
    return static_cast<ImplClass *>(this)->_WriteThreadNetworkDiagnosticAttributeToTlv(attributeId, encoder);
}

inline Ble::BleLayer * ConnectivityManager::GetBleLayer()
{
    return static_cast<ImplClass *>(this)->_GetBleLayer();
}

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

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

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

inline CHIP_ERROR ConnectivityManager::SetBLEAdvertisingMode(BLEAdvertisingMode mode)
{
    return static_cast<ImplClass *>(this)->_SetBLEAdvertisingMode(mode);
}

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

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

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

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

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

inline uint16_t ConnectivityManager::GetUserSelectedModeTimeout()
{
    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::WiFiStationStateToStr(WiFiStationState state)
{
    return ImplClass::_WiFiStationStateToStr(state);
}

inline const char * ConnectivityManager::WiFiAPStateToStr(WiFiAPState state)
{
    return ImplClass::_WiFiAPStateToStr(state);
}

inline const char * ConnectivityManager::CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode)
{
    return ImplClass::_CHIPoBLEServiceModeToStr(mode);
}

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

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

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

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

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

} // namespace DeviceLayer
} // namespace chip