src/include/platform/ConnectivityManager.h

   1 /*
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *    Copyright (c) 2018 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  *          Defines the public interface for the Device Layer ConnectivityManager object.
  22  */
  23
  24 #pragma once
  25
  26 #include <support/CodeUtils.h>
  27
  28 namespace chip {
  29
  30 namespace Ble {
  31 class BleLayer;
  32 class BLEEndPoint;
  33 } // namespace Ble
  34
  35 namespace DeviceLayer {
  36
  37 namespace Internal {
  38 template <class>
  39 class GenericPlatformManagerImpl;
  40 template <class>
  41 class GenericPlatformManagerImpl_FreeRTOS;
  42 template <class>
  43 class GenericPlatformManagerImpl_POSIX;
  44 } // namespace Internal
  45
  46 class ConnectivityManagerImpl;
  47
  48 /**
  49  * Provides control of network connectivity for a chip device.
  50  */
  51 class ConnectivityManager
  52 {
  53     using ImplClass = ::chip::DeviceLayer::ConnectivityManagerImpl;
  54
  55 public:
  56     // ===== Members that define the public interface of the ConnectivityManager
  57
  58     enum WiFiStationMode
  59     {
  60         kWiFiStationMode_NotSupported          = 0,
  61         kWiFiStationMode_ApplicationControlled = 1,
  62         kWiFiStationMode_Disabled              = 2,
  63         kWiFiStationMode_Enabled               = 3,
  64     };
  65
  66     enum WiFiAPMode
  67     {
  68         kWiFiAPMode_NotSupported                = 0,
  69         kWiFiAPMode_ApplicationControlled       = 1,
  70         kWiFiAPMode_Disabled                    = 2,
  71         kWiFiAPMode_Enabled                     = 3,
  72         kWiFiAPMode_OnDemand                    = 4,
  73         kWiFiAPMode_OnDemand_NoStationProvision = 5,
  74     };
  75
  76     enum ThreadMode
  77     {
  78         kThreadMode_NotSupported          = 0,
  79         kThreadMode_ApplicationControlled = 1,
  80         kThreadMode_Disabled              = 2,
  81         kThreadMode_Enabled               = 3,
  82     };
  83
  84     enum WiFiStationState
  85     {
  86         kWiFiStationState_NotConnected,
  87         kWiFiStationState_Connecting,
  88         kWiFiStationState_Connecting_Succeeded,
  89         kWiFiStationState_Connecting_Failed,
  90         kWiFiStationState_Connected,
  91         kWiFiStationState_Disconnecting,
  92     };
  93
  94     enum WiFiAPState
  95     {
  96         kWiFiAPState_NotActive,
  97         kWiFiAPState_Activating,
  98         kWiFiAPState_Active,
  99         kWiFiAPState_Deactivating,
 100     };
 101
 102     enum CHIPoBLEServiceMode
 103     {
 104         kCHIPoBLEServiceMode_NotSupported = 0,
 105         kCHIPoBLEServiceMode_Enabled      = 1,
 106         kCHIPoBLEServiceMode_Disabled     = 2,
 107     };
 108
 109     enum ThreadDeviceType
 110     {
 111         kThreadDeviceType_NotSupported     = 0,
 112         kThreadDeviceType_Router           = 1,
 113         kThreadDeviceType_FullEndDevice    = 2,
 114         kThreadDeviceType_MinimalEndDevice = 3,
 115         kThreadDeviceType_SleepyEndDevice  = 4,
 116     };
 117
 118     enum BLEAdvertisingMode
 119     {
 120         kFastAdvertising = 0,
 121         kSlowAdvertising = 1,
 122     };
 123
 124     struct ThreadPollingConfig;
 125
 126     // WiFi station methods
 127     WiFiStationMode GetWiFiStationMode();
 128     CHIP_ERROR SetWiFiStationMode(WiFiStationMode val);
 129     bool IsWiFiStationEnabled();
 130     bool IsWiFiStationApplicationControlled();
 131     bool IsWiFiStationConnected();
 132     uint32_t GetWiFiStationReconnectIntervalMS();
 133     CHIP_ERROR SetWiFiStationReconnectIntervalMS(uint32_t val);
 134     bool IsWiFiStationProvisioned();
 135     void ClearWiFiStationProvision();
 136     CHIP_ERROR GetAndLogWifiStatsCounters();
 137
 138     // WiFi AP methods
 139     WiFiAPMode GetWiFiAPMode();
 140     CHIP_ERROR SetWiFiAPMode(WiFiAPMode val);
 141     bool IsWiFiAPActive();
 142     bool IsWiFiAPApplicationControlled();
 143     void DemandStartWiFiAP();
 144     void StopOnDemandWiFiAP();
 145     void MaintainOnDemandWiFiAP();
 146     uint32_t GetWiFiAPIdleTimeoutMS();
 147     void SetWiFiAPIdleTimeoutMS(uint32_t val);
 148
 149     // Thread Methods
 150     ThreadMode GetThreadMode();
 151     CHIP_ERROR SetThreadMode(ThreadMode val);
 152     bool IsThreadEnabled();
 153     bool IsThreadApplicationControlled();
 154     ThreadDeviceType GetThreadDeviceType();
 155     CHIP_ERROR SetThreadDeviceType(ThreadDeviceType deviceType);
 156     void GetThreadPollingConfig(ThreadPollingConfig & pollingConfig);
 157     CHIP_ERROR SetThreadPollingConfig(const ThreadPollingConfig & pollingConfig);
 158     bool IsThreadAttached();
 159     bool IsThreadProvisioned();
 160     void ErasePersistentInfo();
 161     bool HaveServiceConnectivityViaThread();
 162
 163     // Internet connectivity methods
 164     bool HaveIPv4InternetConnectivity();
 165     bool HaveIPv6InternetConnectivity();
 166
 167     // Service connectivity methods
 168     bool HaveServiceConnectivity();
 169
 170     // CHIPoBLE service methods
 171     Ble::BleLayer * GetBleLayer();
 172     CHIPoBLEServiceMode GetCHIPoBLEServiceMode();
 173     CHIP_ERROR SetCHIPoBLEServiceMode(CHIPoBLEServiceMode val);
 174     bool IsBLEAdvertisingEnabled();
 175     CHIP_ERROR SetBLEAdvertisingEnabled(bool val);
 176     bool IsBLEAdvertising();
 177     CHIP_ERROR SetBLEAdvertisingMode(BLEAdvertisingMode mode);
 178     CHIP_ERROR GetBLEDeviceName(char * buf, size_t bufSize);
 179     CHIP_ERROR SetBLEDeviceName(const char * deviceName);
 180     uint16_t NumBLEConnections();
 181
 182     // User selected mode methods
 183     bool IsUserSelectedModeActive();
 184     void SetUserSelectedMode(bool val);
 185     uint16_t GetUserSelectedModeTimeout();
 186     void SetUserSelectedModeTimeout(uint16_t val);
 187
 188     // Support methods
 189     static const char * WiFiStationModeToStr(WiFiStationMode mode);
 190     static const char * WiFiAPModeToStr(WiFiAPMode mode);
 191     static const char * WiFiStationStateToStr(WiFiStationState state);
 192     static const char * WiFiAPStateToStr(WiFiAPState state);
 193     static const char * CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode);
 194
 195 private:
 196     // ===== Members for internal use by the following friends.
 197
 198     friend class PlatformManagerImpl;
 199     template <class>
 200     friend class Internal::GenericPlatformManagerImpl;
 201     template <class>
 202     friend class Internal::GenericPlatformManagerImpl_FreeRTOS;
 203     template <class>
 204     friend class Internal::GenericPlatformManagerImpl_POSIX;
 205
 206     CHIP_ERROR Init();
 207     void OnPlatformEvent(const ChipDeviceEvent * event);
 208     bool CanStartWiFiScan();
 209     void OnWiFiScanDone();
 210     void OnWiFiStationProvisionChange();
 211
 212 protected:
 213     // Construction/destruction limited to subclasses.
 214     ConnectivityManager()  = default;
 215     ~ConnectivityManager() = default;
 216
 217     // No copy, move or assignment.
 218     ConnectivityManager(const ConnectivityManager &)  = delete;
 219     ConnectivityManager(const ConnectivityManager &&) = delete;
 220     ConnectivityManager & operator=(const ConnectivityManager &) = delete;
 221 };
 222
 223 /**
 224  * Information describing the desired Thread polling behavior of a device.
 225  */
 226 struct ConnectivityManager::ThreadPollingConfig
 227 {
 228     uint32_t ActivePollingIntervalMS; /**< Interval at which the device polls its parent Thread router when
 229                                            when there are active chip exchanges in progress. Only meaningful
 230                                            when the device is acting as a sleepy end node. */
 231
 232     uint32_t InactivePollingIntervalMS; /**< Interval at which the device polls its parent Thread router when
 233                                              when there are NO active chip exchanges in progress. Only meaningful
 234                                              when the device is acting as a sleepy end node. */
 235
 236     void Clear() { memset(this, 0, sizeof(*this)); }
 237 };
 238
 239 /**
 240  * Returns a reference to the public interface of the ConnectivityManager singleton object.
 241  *
 242  * chip applications should use this to access features of the ConnectivityManager object
 243  * that are common to all platforms.
 244  */
 245 extern ConnectivityManager & ConnectivityMgr();
 246
 247 /**
 248  * Returns the platform-specific implementation of the ConnectivityManager singleton object.
 249  *
 250  * chip applications can use this to gain access to features of the ConnectivityManager
 251  * that are specific to the selected platform.
 252  */
 253 extern ConnectivityManagerImpl & ConnectivityMgrImpl();
 254
 255 } // namespace DeviceLayer
 256 } // namespace chip
 257
 258 /* Include a header file containing the implementation of the ConfigurationManager
 259  * object for the selected platform.
 260  */
 261 #ifdef EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
 262 #include EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
 263 #elif defined(CHIP_DEVICE_LAYER_TARGET)
 264 #define CONNECTIVITYMANAGERIMPL_HEADER <platform/CHIP_DEVICE_LAYER_TARGET/ConnectivityManagerImpl.h>
 265 #include CONNECTIVITYMANAGERIMPL_HEADER
 266 #endif // defined(CHIP_DEVICE_LAYER_TARGET)
 267
 268 namespace chip {
 269 namespace DeviceLayer {
 270
 271 inline ConnectivityManager::WiFiStationMode ConnectivityManager::GetWiFiStationMode()
 272 {
 273     return static_cast<ImplClass *>(this)->_GetWiFiStationMode();
 274 }
 275
 276 inline CHIP_ERROR ConnectivityManager::SetWiFiStationMode(WiFiStationMode val)
 277 {
 278     return static_cast<ImplClass *>(this)->_SetWiFiStationMode(val);
 279 }
 280
 281 inline bool ConnectivityManager::IsWiFiStationEnabled()
 282 {
 283     return static_cast<ImplClass *>(this)->_IsWiFiStationEnabled();
 284 }
 285
 286 inline bool ConnectivityManager::IsWiFiStationApplicationControlled()
 287 {
 288     return static_cast<ImplClass *>(this)->_IsWiFiStationApplicationControlled();
 289 }
 290
 291 inline bool ConnectivityManager::IsWiFiStationConnected()
 292 {
 293     return static_cast<ImplClass *>(this)->_IsWiFiStationConnected();
 294 }
 295
 296 inline uint32_t ConnectivityManager::GetWiFiStationReconnectIntervalMS()
 297 {
 298     return static_cast<ImplClass *>(this)->_GetWiFiStationReconnectIntervalMS();
 299 }
 300
 301 inline CHIP_ERROR ConnectivityManager::SetWiFiStationReconnectIntervalMS(uint32_t val)
 302 {
 303     return static_cast<ImplClass *>(this)->_SetWiFiStationReconnectIntervalMS(val);
 304 }
 305
 306 inline bool ConnectivityManager::IsWiFiStationProvisioned()
 307 {
 308     return static_cast<ImplClass *>(this)->_IsWiFiStationProvisioned();
 309 }
 310
 311 inline void ConnectivityManager::ClearWiFiStationProvision()
 312 {
 313     static_cast<ImplClass *>(this)->_ClearWiFiStationProvision();
 314 }
 315
 316 inline ConnectivityManager::WiFiAPMode ConnectivityManager::GetWiFiAPMode()
 317 {
 318     return static_cast<ImplClass *>(this)->_GetWiFiAPMode();
 319 }
 320
 321 inline CHIP_ERROR ConnectivityManager::SetWiFiAPMode(WiFiAPMode val)
 322 {
 323     return static_cast<ImplClass *>(this)->_SetWiFiAPMode(val);
 324 }
 325
 326 inline bool ConnectivityManager::IsWiFiAPActive()
 327 {
 328     return static_cast<ImplClass *>(this)->_IsWiFiAPActive();
 329 }
 330
 331 inline bool ConnectivityManager::IsWiFiAPApplicationControlled()
 332 {
 333     return static_cast<ImplClass *>(this)->_IsWiFiAPApplicationControlled();
 334 }
 335
 336 inline void ConnectivityManager::DemandStartWiFiAP()
 337 {
 338     static_cast<ImplClass *>(this)->_DemandStartWiFiAP();
 339 }
 340
 341 inline void ConnectivityManager::StopOnDemandWiFiAP()
 342 {
 343     static_cast<ImplClass *>(this)->_StopOnDemandWiFiAP();
 344 }
 345
 346 inline void ConnectivityManager::MaintainOnDemandWiFiAP()
 347 {
 348     static_cast<ImplClass *>(this)->_MaintainOnDemandWiFiAP();
 349 }
 350
 351 inline uint32_t ConnectivityManager::GetWiFiAPIdleTimeoutMS()
 352 {
 353     return static_cast<ImplClass *>(this)->_GetWiFiAPIdleTimeoutMS();
 354 }
 355
 356 inline void ConnectivityManager::SetWiFiAPIdleTimeoutMS(uint32_t val)
 357 {
 358     static_cast<ImplClass *>(this)->_SetWiFiAPIdleTimeoutMS(val);
 359 }
 360
 361 inline CHIP_ERROR ConnectivityManager::GetAndLogWifiStatsCounters()
 362 {
 363     return static_cast<ImplClass *>(this)->_GetAndLogWifiStatsCounters();
 364 }
 365
 366 inline bool ConnectivityManager::HaveIPv4InternetConnectivity()
 367 {
 368     return static_cast<ImplClass *>(this)->_HaveIPv4InternetConnectivity();
 369 }
 370
 371 inline bool ConnectivityManager::HaveIPv6InternetConnectivity()
 372 {
 373     return static_cast<ImplClass *>(this)->_HaveIPv6InternetConnectivity();
 374 }
 375
 376 inline bool ConnectivityManager::HaveServiceConnectivity()
 377 {
 378     return static_cast<ImplClass *>(this)->_HaveServiceConnectivity();
 379 }
 380
 381 inline ConnectivityManager::ThreadMode ConnectivityManager::GetThreadMode()
 382 {
 383     return static_cast<ImplClass *>(this)->_GetThreadMode();
 384 }
 385
 386 inline CHIP_ERROR ConnectivityManager::SetThreadMode(ThreadMode val)
 387 {
 388     return static_cast<ImplClass *>(this)->_SetThreadMode(val);
 389 }
 390
 391 inline bool ConnectivityManager::IsThreadEnabled()
 392 {
 393     return static_cast<ImplClass *>(this)->_IsThreadEnabled();
 394 }
 395
 396 inline bool ConnectivityManager::IsThreadApplicationControlled()
 397 {
 398     return static_cast<ImplClass *>(this)->_IsThreadApplicationControlled();
 399 }
 400
 401 inline ConnectivityManager::ThreadDeviceType ConnectivityManager::GetThreadDeviceType()
 402 {
 403     return static_cast<ImplClass *>(this)->_GetThreadDeviceType();
 404 }
 405
 406 inline CHIP_ERROR ConnectivityManager::SetThreadDeviceType(ThreadDeviceType deviceType)
 407 {
 408     return static_cast<ImplClass *>(this)->_SetThreadDeviceType(deviceType);
 409 }
 410
 411 inline void ConnectivityManager::GetThreadPollingConfig(ThreadPollingConfig & pollingConfig)
 412 {
 413     return static_cast<ImplClass *>(this)->_GetThreadPollingConfig(pollingConfig);
 414 }
 415
 416 inline CHIP_ERROR ConnectivityManager::SetThreadPollingConfig(const ThreadPollingConfig & pollingConfig)
 417 {
 418     return static_cast<ImplClass *>(this)->_SetThreadPollingConfig(pollingConfig);
 419 }
 420
 421 inline bool ConnectivityManager::IsThreadAttached()
 422 {
 423     return static_cast<ImplClass *>(this)->_IsThreadAttached();
 424 }
 425
 426 inline bool ConnectivityManager::IsThreadProvisioned()
 427 {
 428     return static_cast<ImplClass *>(this)->_IsThreadProvisioned();
 429 }
 430
 431 inline void ConnectivityManager::ErasePersistentInfo()
 432 {
 433     static_cast<ImplClass *>(this)->_ErasePersistentInfo();
 434 }
 435
 436 inline bool ConnectivityManager::HaveServiceConnectivityViaThread()
 437 {
 438     return static_cast<ImplClass *>(this)->_HaveServiceConnectivityViaThread();
 439 }
 440
 441 inline Ble::BleLayer * ConnectivityManager::GetBleLayer()
 442 {
 443     return static_cast<ImplClass *>(this)->_GetBleLayer();
 444 }
 445
 446 inline ConnectivityManager::CHIPoBLEServiceMode ConnectivityManager::GetCHIPoBLEServiceMode()
 447 {
 448     return static_cast<ImplClass *>(this)->_GetCHIPoBLEServiceMode();
 449 }
 450
 451 inline CHIP_ERROR ConnectivityManager::SetCHIPoBLEServiceMode(CHIPoBLEServiceMode val)
 452 {
 453     return static_cast<ImplClass *>(this)->_SetCHIPoBLEServiceMode(val);
 454 }
 455
 456 inline bool ConnectivityManager::IsBLEAdvertisingEnabled()
 457 {
 458     return static_cast<ImplClass *>(this)->_IsBLEAdvertisingEnabled();
 459 }
 460
 461 inline CHIP_ERROR ConnectivityManager::SetBLEAdvertisingEnabled(bool val)
 462 {
 463     return static_cast<ImplClass *>(this)->_SetBLEAdvertisingEnabled(val);
 464 }
 465
 466 inline bool ConnectivityManager::IsBLEAdvertising()
 467 {
 468     return static_cast<ImplClass *>(this)->_IsBLEAdvertising();
 469 }
 470
 471 inline CHIP_ERROR ConnectivityManager::SetBLEAdvertisingMode(BLEAdvertisingMode mode)
 472 {
 473     return static_cast<ImplClass *>(this)->_SetBLEAdvertisingMode(mode);
 474 }
 475
 476 inline CHIP_ERROR ConnectivityManager::GetBLEDeviceName(char * buf, size_t bufSize)
 477 {
 478     return static_cast<ImplClass *>(this)->_GetBLEDeviceName(buf, bufSize);
 479 }
 480
 481 inline CHIP_ERROR ConnectivityManager::SetBLEDeviceName(const char * deviceName)
 482 {
 483     return static_cast<ImplClass *>(this)->_SetBLEDeviceName(deviceName);
 484 }
 485
 486 inline uint16_t ConnectivityManager::NumBLEConnections()
 487 {
 488     return static_cast<ImplClass *>(this)->_NumBLEConnections();
 489 }
 490
 491 inline bool ConnectivityManager::IsUserSelectedModeActive()
 492 {
 493     return static_cast<ImplClass *>(this)->_IsUserSelectedModeActive();
 494 }
 495
 496 inline void ConnectivityManager::SetUserSelectedMode(bool val)
 497 {
 498     static_cast<ImplClass *>(this)->_SetUserSelectedMode(val);
 499 }
 500
 501 inline uint16_t ConnectivityManager::GetUserSelectedModeTimeout()
 502 {
 503     return static_cast<ImplClass *>(this)->_GetUserSelectedModeTimeout();
 504 }
 505
 506 inline void ConnectivityManager::SetUserSelectedModeTimeout(uint16_t val)
 507 {
 508     static_cast<ImplClass *>(this)->_SetUserSelectedModeTimeout(val);
 509 }
 510
 511 inline const char * ConnectivityManager::WiFiStationModeToStr(WiFiStationMode mode)
 512 {
 513     return ImplClass::_WiFiStationModeToStr(mode);
 514 }
 515
 516 inline const char * ConnectivityManager::WiFiAPModeToStr(WiFiAPMode mode)
 517 {
 518     return ImplClass::_WiFiAPModeToStr(mode);
 519 }
 520
 521 inline const char * ConnectivityManager::WiFiStationStateToStr(WiFiStationState state)
 522 {
 523     return ImplClass::_WiFiStationStateToStr(state);
 524 }
 525
 526 inline const char * ConnectivityManager::WiFiAPStateToStr(WiFiAPState state)
 527 {
 528     return ImplClass::_WiFiAPStateToStr(state);
 529 }
 530
 531 inline const char * ConnectivityManager::CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode)
 532 {
 533     return ImplClass::_CHIPoBLEServiceModeToStr(mode);
 534 }
 535
 536 inline CHIP_ERROR ConnectivityManager::Init()
 537 {
 538     return static_cast<ImplClass *>(this)->_Init();
 539 }
 540
 541 inline void ConnectivityManager::OnPlatformEvent(const ChipDeviceEvent * event)
 542 {
 543     static_cast<ImplClass *>(this)->_OnPlatformEvent(event);
 544 }
 545
 546 inline bool ConnectivityManager::CanStartWiFiScan()
 547 {
 548     return static_cast<ImplClass *>(this)->_CanStartWiFiScan();
 549 }
 550
 551 inline void ConnectivityManager::OnWiFiScanDone()
 552 {
 553     static_cast<ImplClass *>(this)->_OnWiFiScanDone();
 554 }
 555
 556 inline void ConnectivityManager::OnWiFiStationProvisionChange()
 557 {
 558     static_cast<ImplClass *>(this)->_OnWiFiStationProvisionChange();
 559 }
 560
 561 } // namespace DeviceLayer
 562 } // namespace chip