src/include/platform/internal/GenericConnectivityManagerImpl_NoWiFi.h

   1 /*
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *    Copyright (c) 2019 Nest Labs, Inc.
   5  *
   6  *    Licensed under the Apache License, Version 2.0 (the "License");
   7  *    you may not use this file except in compliance with the License.
   8  *    You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *    Unless required by applicable law or agreed to in writing, software
  13  *    distributed under the License is distributed on an "AS IS" BASIS,
  14  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *    See the License for the specific language governing permissions and
  16  *    limitations under the License.
  17  */
  18
  19 /**
  20  *    @file
  21  *          Provides an generic implementation of ConnectivityManager features
  22  *          for use on platforms that don't have WiFi.
  23  */
  24
  25 #pragma once
  26
  27 namespace chip {
  28 namespace DeviceLayer {
  29 namespace Internal {
  30
  31 /**
  32  * Provides a generic implementation of WiFi-specific ConnectivityManager features for
  33  * platforms that don't support WiFi.
  34  *
  35  * This class is intended to be inherited (directly or indirectly) by the ConnectivityManagerImpl
  36  * class, which also appears as the template's ImplClass parameter.
  37  *
  38  * The members of this class are all inlined methods that do nothing, and return static return
  39  * values.  This allows the compiler to optimize away dead code without the use of \#ifdef's.
  40  * For example:
  41  *
  42  * ```
  43  * if (ConnectivityMgr().GetWiFiStationMode() != ConnectivityManager::kWiFiStationMode_NotSupported)
  44  * {
  45  *     // ... do something on devices that support WiFi ...
  46  * }
  47  * ```
  48  */
  49 template <class ImplClass>
  50 class GenericConnectivityManagerImpl_NoWiFi
  51 {
  52 public:
  53     // ===== Methods that implement the ConnectivityManager abstract interface.
  54
  55     ConnectivityManager::WiFiStationMode _GetWiFiStationMode(void);
  56     CHIP_ERROR _SetWiFiStationMode(ConnectivityManager::WiFiStationMode val);
  57     bool _IsWiFiStationEnabled(void);
  58     bool _IsWiFiStationApplicationControlled(void);
  59     bool _IsWiFiStationConnected(void);
  60     bool _HaveIPv4InternetConnectivity(void);
  61     bool _HaveIPv6InternetConnectivity(void);
  62     uint32_t _GetWiFiStationReconnectIntervalMS(void);
  63     CHIP_ERROR _SetWiFiStationReconnectIntervalMS(uint32_t val);
  64     bool _IsWiFiStationProvisioned(void);
  65     void _ClearWiFiStationProvision(void);
  66     ConnectivityManager::WiFiAPMode _GetWiFiAPMode(void);
  67     CHIP_ERROR _SetWiFiAPMode(ConnectivityManager::WiFiAPMode val);
  68     bool _IsWiFiAPActive(void);
  69     bool _IsWiFiAPApplicationControlled(void);
  70     void _DemandStartWiFiAP(void);
  71     void _StopOnDemandWiFiAP(void);
  72     void _MaintainOnDemandWiFiAP(void);
  73     uint32_t _GetWiFiAPIdleTimeoutMS(void);
  74     void _SetWiFiAPIdleTimeoutMS(uint32_t val);
  75     CHIP_ERROR _GetAndLogWifiStatsCounters(void);
  76     bool _CanStartWiFiScan();
  77     void _OnWiFiScanDone();
  78     void _OnWiFiStationProvisionChange();
  79     static const char * _WiFiStationModeToStr(ConnectivityManager::WiFiStationMode mode);
  80     static const char * _WiFiAPModeToStr(ConnectivityManager::WiFiAPMode mode);
  81     static const char * _WiFiStationStateToStr(ConnectivityManager::WiFiStationState state);
  82     static const char * _WiFiAPStateToStr(ConnectivityManager::WiFiAPState state);
  83
  84 private:
  85     ImplClass * Impl() { return static_cast<ImplClass *>(this); }
  86 };
  87
  88 template <class ImplClass>
  89 inline ConnectivityManager::WiFiStationMode GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_GetWiFiStationMode(void)
  90 {
  91     return ConnectivityManager::kWiFiStationMode_NotSupported;
  92 }
  93
  94 template <class ImplClass>
  95 inline CHIP_ERROR GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_SetWiFiStationMode(ConnectivityManager::WiFiStationMode val)
  96 {
  97     return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
  98 }
  99
 100 template <class ImplClass>
 101 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_IsWiFiStationEnabled(void)
 102 {
 103     return false;
 104 }
 105
 106 template <class ImplClass>
 107 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_IsWiFiStationConnected(void)
 108 {
 109     return false;
 110 }
 111
 112 template <class ImplClass>
 113 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_HaveIPv4InternetConnectivity(void)
 114 {
 115     return false;
 116 }
 117
 118 template <class ImplClass>
 119 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_HaveIPv6InternetConnectivity(void)
 120 {
 121     return false;
 122 }
 123
 124 template <class ImplClass>
 125 inline uint32_t GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_GetWiFiStationReconnectIntervalMS(void)
 126 {
 127     return 0;
 128 }
 129
 130 template <class ImplClass>
 131 inline CHIP_ERROR GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_SetWiFiStationReconnectIntervalMS(uint32_t val)
 132 {
 133     return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
 134 }
 135
 136 template <class ImplClass>
 137 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_IsWiFiStationProvisioned(void)
 138 {
 139     return false;
 140 }
 141
 142 template <class ImplClass>
 143 inline void GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_ClearWiFiStationProvision(void)
 144 {}
 145
 146 template <class ImplClass>
 147 inline ConnectivityManager::WiFiAPMode GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_GetWiFiAPMode(void)
 148 {
 149     return ConnectivityManager::kWiFiAPMode_NotSupported;
 150 }
 151
 152 template <class ImplClass>
 153 inline CHIP_ERROR GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_SetWiFiAPMode(ConnectivityManager::WiFiAPMode val)
 154 {
 155     return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
 156 }
 157
 158 template <class ImplClass>
 159 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_IsWiFiAPActive(void)
 160 {
 161     return false;
 162 }
 163
 164 template <class ImplClass>
 165 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_IsWiFiAPApplicationControlled(void)
 166 {
 167     return false;
 168 }
 169
 170 template <class ImplClass>
 171 inline void GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_DemandStartWiFiAP(void)
 172 {}
 173
 174 template <class ImplClass>
 175 inline void GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_StopOnDemandWiFiAP(void)
 176 {}
 177
 178 template <class ImplClass>
 179 inline void GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_MaintainOnDemandWiFiAP(void)
 180 {}
 181
 182 template <class ImplClass>
 183 inline uint32_t GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_GetWiFiAPIdleTimeoutMS(void)
 184 {
 185     return 0;
 186 }
 187
 188 template <class ImplClass>
 189 inline void GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_SetWiFiAPIdleTimeoutMS(uint32_t val)
 190 {}
 191
 192 template <class ImplClass>
 193 inline CHIP_ERROR GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_GetAndLogWifiStatsCounters(void)
 194 {
 195     return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
 196 }
 197
 198 template <class ImplClass>
 199 inline bool GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_CanStartWiFiScan()
 200 {
 201     return false;
 202 }
 203
 204 template <class ImplClass>
 205 inline void GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_OnWiFiScanDone()
 206 {}
 207
 208 template <class ImplClass>
 209 inline void GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_OnWiFiStationProvisionChange()
 210 {}
 211
 212 template <class ImplClass>
 213 inline const char *
 214 GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_WiFiStationModeToStr(ConnectivityManager::WiFiStationMode mode)
 215 {
 216     return NULL;
 217 }
 218
 219 template <class ImplClass>
 220 inline const char * GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_WiFiAPModeToStr(ConnectivityManager::WiFiAPMode mode)
 221 {
 222     return NULL;
 223 }
 224
 225 template <class ImplClass>
 226 inline const char *
 227 GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_WiFiStationStateToStr(ConnectivityManager::WiFiStationState state)
 228 {
 229     return NULL;
 230 }
 231
 232 template <class ImplClass>
 233 inline const char * GenericConnectivityManagerImpl_NoWiFi<ImplClass>::_WiFiAPStateToStr(ConnectivityManager::WiFiAPState state)
 234 {
 235     return NULL;
 236 }
 237
 238 } // namespace Internal
 239 } // namespace DeviceLayer
 240 } // namespace chip