src/platform/ESP32/ConnectivityManagerImpl.h

   1 /*
   2  *
   3  *    Copyright (c) 2020-2021 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 #include <support/BitFlags.h>
  32
  33 #include "esp_event.h"
  34
  35 namespace Inet {
  36 class IPAddress;
  37 } // namespace Inet
  38
  39 namespace chip {
  40 namespace DeviceLayer {
  41
  42 class PlatformManagerImpl;
  43
  44 namespace Internal {
  45
  46 class NetworkProvisioningServerImpl;
  47 template <class ImplClass>
  48 class GenericNetworkProvisioningServerImpl;
  49
  50 } // namespace Internal
  51
  52 /**
  53  * Concrete implementation of the ConnectivityManager singleton object for the ESP32 platform.
  54  */
  55 class ConnectivityManagerImpl final : public ConnectivityManager,
  56                                       public Internal::GenericConnectivityManagerImpl<ConnectivityManagerImpl>,
  57                                       public Internal::GenericConnectivityManagerImpl_WiFi<ConnectivityManagerImpl>,
  58 #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
  59                                       public Internal::GenericConnectivityManagerImpl_BLE<ConnectivityManagerImpl>,
  60 #else
  61                                       public Internal::GenericConnectivityManagerImpl_NoBLE<ConnectivityManagerImpl>,
  62 #endif
  63                                       public Internal::GenericConnectivityManagerImpl_NoThread<ConnectivityManagerImpl>
  64 {
  65
  66     // Allow the ConnectivityManager interface class to delegate method calls to
  67     // the implementation methods provided by this class.
  68     friend class ConnectivityManager;
  69
  70 private:
  71     using Flags = GenericConnectivityManagerImpl_WiFi::ConnectivityFlags;
  72     // ===== Members that implement the ConnectivityManager abstract interface.
  73
  74     WiFiStationMode _GetWiFiStationMode(void);
  75     CHIP_ERROR _SetWiFiStationMode(WiFiStationMode val);
  76     bool _IsWiFiStationEnabled(void);
  77     bool _IsWiFiStationApplicationControlled(void);
  78     bool _IsWiFiStationConnected(void);
  79     uint32_t _GetWiFiStationReconnectIntervalMS(void);
  80     CHIP_ERROR _SetWiFiStationReconnectIntervalMS(uint32_t val);
  81     bool _IsWiFiStationProvisioned(void);
  82     void _ClearWiFiStationProvision(void);
  83     WiFiAPMode _GetWiFiAPMode(void);
  84     CHIP_ERROR _SetWiFiAPMode(WiFiAPMode val);
  85     bool _IsWiFiAPActive(void);
  86     bool _IsWiFiAPApplicationControlled(void);
  87     void _DemandStartWiFiAP(void);
  88     void _StopOnDemandWiFiAP(void);
  89     void _MaintainOnDemandWiFiAP(void);
  90     uint32_t _GetWiFiAPIdleTimeoutMS(void);
  91     void _SetWiFiAPIdleTimeoutMS(uint32_t val);
  92     CHIP_ERROR _GetAndLogWifiStatsCounters(void);
  93     bool _HaveIPv4InternetConnectivity(void);
  94     bool _HaveIPv6InternetConnectivity(void);
  95     bool _HaveServiceConnectivity(void);
  96     CHIP_ERROR _Init(void);
  97     void _OnPlatformEvent(const ChipDeviceEvent * event);
  98     bool _CanStartWiFiScan();
  99     void _OnWiFiScanDone();
 100     void _OnWiFiStationProvisionChange();
 101
 102     // ===== Members for internal use by the following friends.
 103
 104     friend ConnectivityManager & ConnectivityMgr(void);
 105     friend ConnectivityManagerImpl & ConnectivityMgrImpl(void);
 106
 107     static ConnectivityManagerImpl sInstance;
 108
 109     // ===== Private members reserved for use by this class only.
 110
 111     uint64_t mLastStationConnectFailTime;
 112     uint64_t mLastAPDemandTime;
 113     WiFiStationMode mWiFiStationMode;
 114     WiFiStationState mWiFiStationState;
 115     WiFiAPMode mWiFiAPMode;
 116     WiFiAPState mWiFiAPState;
 117     uint32_t mWiFiStationReconnectIntervalMS;
 118     uint32_t mWiFiAPIdleTimeoutMS;
 119     BitFlags<Flags> mFlags;
 120
 121     void DriveStationState(void);
 122     void OnStationConnected(void);
 123     void OnStationDisconnected(void);
 124     void ChangeWiFiStationState(WiFiStationState newState);
 125     static void DriveStationState(::chip::System::Layer * aLayer, void * aAppState, ::chip::System::Error aError);
 126
 127     void DriveAPState(void);
 128     CHIP_ERROR ConfigureWiFiAP(void);
 129     void ChangeWiFiAPState(WiFiAPState newState);
 130     static void DriveAPState(::chip::System::Layer * aLayer, void * aAppState, ::chip::System::Error aError);
 131
 132     void UpdateInternetConnectivityState(void);
 133     void OnStationIPv4AddressAvailable(const ip_event_got_ip_t & got_ip);
 134     void OnStationIPv4AddressLost(void);
 135     void OnIPv6AddressAvailable(const ip_event_got_ip6_t & got_ip);
 136
 137     static void RefreshMessageLayer(void);
 138 };
 139
 140 inline bool ConnectivityManagerImpl::_IsWiFiStationApplicationControlled(void)
 141 {
 142     return mWiFiStationMode == kWiFiStationMode_ApplicationControlled;
 143 }
 144
 145 inline bool ConnectivityManagerImpl::_IsWiFiStationConnected(void)
 146 {
 147     return mWiFiStationState == kWiFiStationState_Connected;
 148 }
 149
 150 inline bool ConnectivityManagerImpl::_IsWiFiAPApplicationControlled(void)
 151 {
 152     return mWiFiAPMode == kWiFiAPMode_ApplicationControlled;
 153 }
 154
 155 inline uint32_t ConnectivityManagerImpl::_GetWiFiStationReconnectIntervalMS(void)
 156 {
 157     return mWiFiStationReconnectIntervalMS;
 158 }
 159
 160 inline ConnectivityManager::WiFiAPMode ConnectivityManagerImpl::_GetWiFiAPMode(void)
 161 {
 162     return mWiFiAPMode;
 163 }
 164
 165 inline bool ConnectivityManagerImpl::_IsWiFiAPActive(void)
 166 {
 167     return mWiFiAPState == kWiFiAPState_Active;
 168 }
 169
 170 inline uint32_t ConnectivityManagerImpl::_GetWiFiAPIdleTimeoutMS(void)
 171 {
 172     return mWiFiAPIdleTimeoutMS;
 173 }
 174
 175 inline bool ConnectivityManagerImpl::_HaveIPv4InternetConnectivity(void)
 176 {
 177     return mFlags.Has(Flags::kHaveIPv4InternetConnectivity);
 178 }
 179
 180 inline bool ConnectivityManagerImpl::_HaveIPv6InternetConnectivity(void)
 181 {
 182     return mFlags.Has(Flags::kHaveIPv6InternetConnectivity);
 183 }
 184
 185 inline bool ConnectivityManagerImpl::_CanStartWiFiScan()
 186 {
 187     return mWiFiStationState != kWiFiStationState_Connecting;
 188 }
 189
 190 inline bool ConnectivityManagerImpl::_HaveServiceConnectivity(void)
 191 {
 192     return HaveServiceConnectivityViaThread();
 193 }
 194
 195 /**
 196  * Returns the public interface of the ConnectivityManager singleton object.
 197  *
 198  * Chip applications should use this to access features of the ConnectivityManager object
 199  * that are common to all platforms.
 200  */
 201 inline ConnectivityManager & ConnectivityMgr(void)
 202 {
 203     return ConnectivityManagerImpl::sInstance;
 204 }
 205
 206 /**
 207  * Returns the platform-specific implementation of the ConnectivityManager singleton object.
 208  *
 209  * Chip applications can use this to gain access to features of the ConnectivityManager
 210  * that are specific to the ESP32 platform.
 211  */
 212 inline ConnectivityManagerImpl & ConnectivityMgrImpl(void)
 213 {
 214     return ConnectivityManagerImpl::sInstance;
 215 }
 216
 217 } // namespace DeviceLayer
 218 } // namespace chip