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