src/platform/ESP32/ConnectivityManagerImpl.h

   1 /*
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *    Copyright (c) 2018 Nest Labs, Inc.
   5  *    All rights reserved.
   6  *
   7  *    Licensed under the Apache License, Version 2.0 (the "License");
   8  *    you may not use this file except in compliance with the License.
   9  *    You may obtain a copy of the License at
  10  *
  11  *        http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *    Unless required by applicable law or agreed to in writing, software
  14  *    distributed under the License is distributed on an "AS IS" BASIS,
  15  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *    See the License for the specific language governing permissions and
  17  *    limitations under the License.
  18  */
  19
  20 #pragma once
  21
  22 #include <platform/ConnectivityManager.h>
  23 #include <platform/internal/GenericConnectivityManagerImpl.h>
  24 #include <platform/internal/GenericConnectivityManagerImpl_WiFi.h>
  25 #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
  26 #include <platform/internal/GenericConnectivityManagerImpl_BLE.h>
  27 #else
  28 #include <platform/internal/GenericConnectivityManagerImpl_NoBLE.h>
  29 #endif
  30 #include <platform/internal/GenericConnectivityManagerImpl_NoThread.h>
  31
  32 #include "esp_event.h"
  33
  34 namespace Inet {
  35 class IPAddress;
  36 } // namespace Inet
  37
  38 namespace chip {
  39 namespace DeviceLayer {
  40
  41 class PlatformManagerImpl;
  42
  43 namespace Internal {
  44
  45 class NetworkProvisioningServerImpl;
  46 template <class ImplClass>
  47 class GenericNetworkProvisioningServerImpl;
  48
  49 } // namespace Internal
  50
  51 /**
  52  * Concrete implementation of the ConnectivityManager singleton object for the ESP32 platform.
  53  */
  54 class ConnectivityManagerImpl final : public ConnectivityManager,
  55                                       public Internal::GenericConnectivityManagerImpl<ConnectivityManagerImpl>,
  56                                       public Internal::GenericConnectivityManagerImpl_WiFi<ConnectivityManagerImpl>,
  57 #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
  58                                       public Internal::GenericConnectivityManagerImpl_BLE<ConnectivityManagerImpl>,
  59 #else
  60                                       public Internal::GenericConnectivityManagerImpl_NoBLE<ConnectivityManagerImpl>,
  61 #endif
  62                                       public Internal::GenericConnectivityManagerImpl_NoThread<ConnectivityManagerImpl>
  63 {
  64
  65     // Allow the ConnectivityManager interface class to delegate method calls to
  66     // the implementation methods provided by this class.
  67     friend class ConnectivityManager;
  68
  69 private:
  70     // ===== Members that implement the ConnectivityManager abstract interface.
  71
  72     WiFiStationMode _GetWiFiStationMode(void);
  73     CHIP_ERROR _SetWiFiStationMode(WiFiStationMode val);
  74     bool _IsWiFiStationEnabled(void);
  75     bool _IsWiFiStationApplicationControlled(void);
  76     bool _IsWiFiStationConnected(void);
  77     uint32_t _GetWiFiStationReconnectIntervalMS(void);
  78     CHIP_ERROR _SetWiFiStationReconnectIntervalMS(uint32_t val);
  79     bool _IsWiFiStationProvisioned(void);
  80     void _ClearWiFiStationProvision(void);
  81     WiFiAPMode _GetWiFiAPMode(void);
  82     CHIP_ERROR _SetWiFiAPMode(WiFiAPMode val);
  83     bool _IsWiFiAPActive(void);
  84     bool _IsWiFiAPApplicationControlled(void);
  85     void _DemandStartWiFiAP(void);
  86     void _StopOnDemandWiFiAP(void);
  87     void _MaintainOnDemandWiFiAP(void);
  88     uint32_t _GetWiFiAPIdleTimeoutMS(void);
  89     void _SetWiFiAPIdleTimeoutMS(uint32_t val);
  90     CHIP_ERROR _GetAndLogWifiStatsCounters(void);
  91     bool _HaveIPv4InternetConnectivity(void);
  92     bool _HaveIPv6InternetConnectivity(void);
  93     bool _HaveServiceConnectivity(void);
  94     CHIP_ERROR _Init(void);
  95     void _OnPlatformEvent(const ChipDeviceEvent * event);
  96     bool _CanStartWiFiScan();
  97     void _OnWiFiScanDone();
  98     void _OnWiFiStationProvisionChange();
  99
 100     // ===== Members for internal use by the following friends.
 101
 102     friend ConnectivityManager & ConnectivityMgr(void);
 103     friend ConnectivityManagerImpl & ConnectivityMgrImpl(void);
 104
 105     static ConnectivityManagerImpl sInstance;
 106
 107     // ===== Private members reserved for use by this class only.
 108
 109     uint64_t mLastStationConnectFailTime;
 110     uint64_t mLastAPDemandTime;
 111     WiFiStationMode mWiFiStationMode;
 112     WiFiStationState mWiFiStationState;
 113     WiFiAPMode mWiFiAPMode;
 114     WiFiAPState mWiFiAPState;
 115     uint32_t mWiFiStationReconnectIntervalMS;
 116     uint32_t mWiFiAPIdleTimeoutMS;
 117     uint16_t mFlags;
 118
 119     void DriveStationState(void);
 120     void OnStationConnected(void);
 121     void OnStationDisconnected(void);
 122     void ChangeWiFiStationState(WiFiStationState newState);
 123     static void DriveStationState(::chip::System::Layer * aLayer, void * aAppState, ::chip::System::Error aError);
 124
 125     void DriveAPState(void);
 126     CHIP_ERROR ConfigureWiFiAP(void);
 127     void ChangeWiFiAPState(WiFiAPState newState);
 128     static void DriveAPState(::chip::System::Layer * aLayer, void * aAppState, ::chip::System::Error aError);
 129
 130     void UpdateInternetConnectivityState(void);
 131     void OnStationIPv4AddressAvailable(const ip_event_got_ip_t & got_ip);
 132     void OnStationIPv4AddressLost(void);
 133     void OnIPv6AddressAvailable(const ip_event_got_ip6_t & got_ip);
 134
 135     static void RefreshMessageLayer(void);
 136 };
 137
 138 inline bool ConnectivityManagerImpl::_IsWiFiStationApplicationControlled(void)
 139 {
 140     return mWiFiStationMode == kWiFiStationMode_ApplicationControlled;
 141 }
 142
 143 inline bool ConnectivityManagerImpl::_IsWiFiStationConnected(void)
 144 {
 145     return mWiFiStationState == kWiFiStationState_Connected;
 146 }
 147
 148 inline bool ConnectivityManagerImpl::_IsWiFiAPApplicationControlled(void)
 149 {
 150     return mWiFiAPMode == kWiFiAPMode_ApplicationControlled;
 151 }
 152
 153 inline uint32_t ConnectivityManagerImpl::_GetWiFiStationReconnectIntervalMS(void)
 154 {
 155     return mWiFiStationReconnectIntervalMS;
 156 }
 157
 158 inline ConnectivityManager::WiFiAPMode ConnectivityManagerImpl::_GetWiFiAPMode(void)
 159 {
 160     return mWiFiAPMode;
 161 }
 162
 163 inline bool ConnectivityManagerImpl::_IsWiFiAPActive(void)
 164 {
 165     return mWiFiAPState == kWiFiAPState_Active;
 166 }
 167
 168 inline uint32_t ConnectivityManagerImpl::_GetWiFiAPIdleTimeoutMS(void)
 169 {
 170     return mWiFiAPIdleTimeoutMS;
 171 }
 172
 173 inline bool ConnectivityManagerImpl::_HaveIPv4InternetConnectivity(void)
 174 {
 175     return ::chip::GetFlag(mFlags, kFlag_HaveIPv4InternetConnectivity);
 176 }
 177
 178 inline bool ConnectivityManagerImpl::_HaveIPv6InternetConnectivity(void)
 179 {
 180     return ::chip::GetFlag(mFlags, kFlag_HaveIPv6InternetConnectivity);
 181 }
 182
 183 inline bool ConnectivityManagerImpl::_CanStartWiFiScan()
 184 {
 185     return mWiFiStationState != kWiFiStationState_Connecting;
 186 }
 187
 188 inline bool ConnectivityManagerImpl::_HaveServiceConnectivity(void)
 189 {
 190     return HaveServiceConnectivityViaThread();
 191 }
 192
 193 /**
 194  * Returns the public interface of the ConnectivityManager singleton object.
 195  *
 196  * Chip applications should use this to access features of the ConnectivityManager object
 197  * that are common to all platforms.
 198  */
 199 inline ConnectivityManager & ConnectivityMgr(void)
 200 {
 201     return ConnectivityManagerImpl::sInstance;
 202 }
 203
 204 /**
 205  * Returns the platform-specific implementation of the ConnectivityManager singleton object.
 206  *
 207  * Chip applications can use this to gain access to features of the ConnectivityManager
 208  * that are specific to the ESP32 platform.
 209  */
 210 inline ConnectivityManagerImpl & ConnectivityMgrImpl(void)
 211 {
 212     return ConnectivityManagerImpl::sInstance;
 213 }
 214
 215 } // namespace DeviceLayer
 216 } // namespace chip