Line data Source code
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 : #include <memory>
26 :
27 : #include <app/icd/server/ICDServerConfig.h>
28 : #include <inet/UDPEndPoint.h>
29 : #include <lib/support/CodeUtils.h>
30 : #include <platform/CHIPDeviceConfig.h>
31 : #include <platform/CHIPDeviceEvent.h>
32 :
33 : #include <app/util/basic-types.h>
34 :
35 : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
36 : #include <inet/TCPEndPoint.h>
37 : #endif
38 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
39 : #include <wifipaf/WiFiPAFLayer.h>
40 : #endif
41 :
42 : namespace chip {
43 :
44 : namespace Ble {
45 : class BleLayer;
46 : class BLEEndPoint;
47 : } // namespace Ble
48 :
49 : namespace DeviceLayer {
50 :
51 : namespace Internal {
52 : template <class>
53 : class GenericPlatformManagerImpl;
54 : template <class>
55 : class GenericPlatformManagerImpl_CMSISOS;
56 : template <class>
57 : class GenericPlatformManagerImpl_FreeRTOS;
58 : template <class>
59 : class GenericPlatformManagerImpl_POSIX;
60 : } // namespace Internal
61 :
62 : class ConnectivityManager;
63 : class ConnectivityManagerImpl;
64 :
65 : /**
66 : * Defines the delegate class of Connectivity Manager to notify connectivity updates.
67 : */
68 : class ConnectivityManagerDelegate
69 : {
70 : public:
71 : virtual ~ConnectivityManagerDelegate() {}
72 :
73 : /**
74 : * @brief
75 : * Called when any network interface on the Node is changed
76 : *
77 : */
78 : virtual void OnNetworkInfoChanged() {}
79 : };
80 :
81 : /**
82 : * Provides control of network connectivity for a chip device.
83 : */
84 : class ConnectivityManager
85 : {
86 : using ImplClass = ::chip::DeviceLayer::ConnectivityManagerImpl;
87 :
88 : public:
89 : // ===== Members that define the public interface of the ConnectivityManager
90 :
91 : enum WiFiStationMode
92 : {
93 : kWiFiStationMode_NotSupported = 0,
94 : kWiFiStationMode_ApplicationControlled = 1,
95 : kWiFiStationMode_Disabled = 2,
96 : kWiFiStationMode_Enabled = 3,
97 : };
98 :
99 : enum WiFiAPMode
100 : {
101 : kWiFiAPMode_NotSupported = 0,
102 : kWiFiAPMode_ApplicationControlled = 1,
103 : kWiFiAPMode_Disabled = 2,
104 : kWiFiAPMode_Enabled = 3,
105 : kWiFiAPMode_OnDemand = 4,
106 : kWiFiAPMode_OnDemand_NoStationProvision = 5,
107 : };
108 :
109 : enum WiFiStationState
110 : {
111 : kWiFiStationState_NotConnected,
112 : kWiFiStationState_Connecting,
113 : kWiFiStationState_Connecting_Succeeded,
114 : kWiFiStationState_Connecting_Failed,
115 : kWiFiStationState_Connected,
116 : kWiFiStationState_Disconnecting,
117 : };
118 :
119 : enum WiFiAPState
120 : {
121 : kWiFiAPState_NotActive,
122 : kWiFiAPState_Activating,
123 : kWiFiAPState_Active,
124 : kWiFiAPState_Deactivating,
125 : };
126 :
127 : enum CHIPoNFCServiceMode
128 : {
129 : kCHIPoNFCServiceMode_NotSupported = 0,
130 : kCHIPoNFCServiceMode_Enabled = 1,
131 : kCHIPoNFCServiceMode_Disabled = 2,
132 : };
133 :
134 : enum CHIPoBLEServiceMode
135 : {
136 : kCHIPoBLEServiceMode_NotSupported = 0,
137 : kCHIPoBLEServiceMode_Enabled = 1,
138 : kCHIPoBLEServiceMode_Disabled = 2,
139 : };
140 :
141 : enum ThreadDeviceType
142 : {
143 : kThreadDeviceType_NotSupported = 0,
144 : kThreadDeviceType_Router = 1,
145 : kThreadDeviceType_FullEndDevice = 2,
146 : kThreadDeviceType_MinimalEndDevice = 3,
147 : kThreadDeviceType_SleepyEndDevice = 4,
148 : kThreadDeviceType_SynchronizedSleepyEndDevice = 5,
149 : };
150 :
151 : enum BLEAdvertisingMode
152 : {
153 : kFastAdvertising = 0,
154 : kSlowAdvertising = 1,
155 : kExtendedAdvertising = 2,
156 : };
157 :
158 : enum class SEDIntervalMode
159 : {
160 : Idle = 0,
161 : Active = 1,
162 : };
163 :
164 : struct SEDIntervalsConfig;
165 :
166 : void SetDelegate(ConnectivityManagerDelegate * delegate) { mDelegate = delegate; }
167 : ConnectivityManagerDelegate * GetDelegate() const { return mDelegate; }
168 :
169 : chip::Inet::EndPointManager<Inet::UDPEndPoint> & UDPEndPointManager();
170 :
171 : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
172 : chip::Inet::EndPointManager<Inet::TCPEndPoint> & TCPEndPointManager();
173 : #endif
174 :
175 : // WiFi station methods
176 : WiFiStationMode GetWiFiStationMode();
177 : CHIP_ERROR SetWiFiStationMode(WiFiStationMode val);
178 : bool IsWiFiStationEnabled();
179 : bool IsWiFiStationApplicationControlled();
180 : bool IsWiFiStationConnected();
181 : System::Clock::Timeout GetWiFiStationReconnectInterval();
182 : CHIP_ERROR SetWiFiStationReconnectInterval(System::Clock::Timeout val);
183 : bool IsWiFiStationProvisioned();
184 : void ClearWiFiStationProvision();
185 : CHIP_ERROR GetAndLogWiFiStatsCounters();
186 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
187 : struct WiFiPAFAdvertiseParam;
188 : CHIP_ERROR WiFiPAFPublish(WiFiPAFAdvertiseParam & args);
189 : CHIP_ERROR WiFiPAFCancelPublish(uint32_t PublishId);
190 : typedef void (*OnConnectionCompleteFunct)(void * appState);
191 : typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err);
192 : CHIP_ERROR WiFiPAFSubscribe(const uint16_t & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess,
193 : OnConnectionErrorFunct onError);
194 : CHIP_ERROR WiFiPAFCancelSubscribe(uint32_t SubscribeId);
195 : CHIP_ERROR WiFiPAFCancelIncompleteSubscribe();
196 : CHIP_ERROR WiFiPAFSend(const WiFiPAF::WiFiPAFSession & TxInfo, System::PacketBufferHandle && msgBuf);
197 : WiFiPAF::WiFiPAFLayer * GetWiFiPAF();
198 : void WiFiPafSetApFreq(const uint16_t freq);
199 : CHIP_ERROR WiFiPAFShutdown(uint32_t id, WiFiPAF::WiFiPafRole role);
200 : bool WiFiPAFResourceAvailable();
201 : #endif
202 :
203 : // WiFi AP methods
204 : WiFiAPMode GetWiFiAPMode();
205 : CHIP_ERROR SetWiFiAPMode(WiFiAPMode val);
206 : bool IsWiFiAPActive();
207 : bool IsWiFiAPApplicationControlled();
208 : void DemandStartWiFiAP();
209 : void StopOnDemandWiFiAP();
210 : void MaintainOnDemandWiFiAP();
211 : System::Clock::Timeout GetWiFiAPIdleTimeout();
212 : void SetWiFiAPIdleTimeout(System::Clock::Timeout val);
213 : CHIP_ERROR DisconnectNetwork();
214 :
215 : // Thread Methods
216 : bool IsThreadEnabled();
217 : ThreadDeviceType GetThreadDeviceType();
218 : CHIP_ERROR SetThreadDeviceType(ThreadDeviceType deviceType);
219 : bool IsThreadAttached();
220 : bool IsThreadProvisioned();
221 : void ErasePersistentInfo();
222 : void ResetThreadNetworkDiagnosticsCounts();
223 :
224 : CHIP_ERROR SetPollingInterval(System::Clock::Milliseconds32 pollingInterval);
225 :
226 : // CHIPoBLE service methods
227 : Ble::BleLayer * GetBleLayer();
228 : bool IsBLEAdvertisingEnabled();
229 : /**
230 : * Enable or disable BLE advertising.
231 : *
232 : * @return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE if BLE advertising is not
233 : * supported or other error on other failures.
234 : */
235 : CHIP_ERROR SetBLEAdvertisingEnabled(bool val);
236 : bool IsBLEAdvertising();
237 : CHIP_ERROR SetBLEAdvertisingMode(BLEAdvertisingMode mode);
238 : CHIP_ERROR GetBLEDeviceName(char * buf, size_t bufSize);
239 : CHIP_ERROR SetBLEDeviceName(const char * deviceName);
240 : uint16_t NumBLEConnections();
241 :
242 : // User selected mode methods
243 : bool IsUserSelectedModeActive();
244 : void SetUserSelectedMode(bool val);
245 : uint16_t GetUserSelectedModeTimeout();
246 : void SetUserSelectedModeTimeout(uint16_t val);
247 :
248 : // Support methods
249 : static const char * WiFiStationModeToStr(WiFiStationMode mode);
250 : static const char * WiFiAPModeToStr(WiFiAPMode mode);
251 : static const char * WiFiStationStateToStr(WiFiStationState state);
252 : static const char * WiFiAPStateToStr(WiFiAPState state);
253 : static const char * CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode);
254 :
255 : private:
256 : ConnectivityManagerDelegate * mDelegate = nullptr;
257 :
258 : // ===== Members for internal use by the following friends.
259 :
260 : friend class PlatformManagerImpl;
261 : template <class>
262 : friend class Internal::GenericPlatformManagerImpl;
263 : template <class>
264 : friend class Internal::GenericPlatformManagerImpl_CMSISOS;
265 : template <class>
266 : friend class Internal::GenericPlatformManagerImpl_FreeRTOS;
267 : template <class>
268 : friend class Internal::GenericPlatformManagerImpl_POSIX;
269 :
270 : CHIP_ERROR Init();
271 : void OnPlatformEvent(const ChipDeviceEvent * event);
272 : void OnWiFiScanDone();
273 : void OnWiFiStationProvisionChange();
274 :
275 : protected:
276 : // Construction/destruction limited to subclasses.
277 : ConnectivityManager() = default;
278 : ~ConnectivityManager() = default;
279 :
280 : // No copy, move or assignment.
281 : ConnectivityManager(const ConnectivityManager &) = delete;
282 : ConnectivityManager(const ConnectivityManager &&) = delete;
283 : ConnectivityManager & operator=(const ConnectivityManager &) = delete;
284 : };
285 :
286 : /**
287 : * Information describing the desired intervals for a sleepy end device (SED).
288 : */
289 : struct ConnectivityManager::SEDIntervalsConfig
290 : {
291 : /** Interval at which the device is able to communicate with its parent when there are active chip exchanges in progress. Only
292 : * meaningful when the device is acting as a sleepy end node. */
293 : System::Clock::Milliseconds32 ActiveIntervalMS;
294 :
295 : /** Interval at which the device is able to communicate with its parent when there are NO active chip exchanges in progress.
296 : * Only meaningful when the device is acting as a sleepy end node. */
297 : System::Clock::Milliseconds32 IdleIntervalMS;
298 : };
299 :
300 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
301 : struct ConnectivityManager::WiFiPAFAdvertiseParam
302 : {
303 : /* To enable/disable WiFiPAF Commissioning */
304 : bool enable;
305 :
306 : /* Frequency list */
307 : uint16_t freq_list_len;
308 : std::unique_ptr<uint16_t[]> freq_list;
309 : uint32_t publish_id;
310 : };
311 : #endif
312 :
313 : /**
314 : * Returns a reference to the public interface of the ConnectivityManager singleton object.
315 : *
316 : * chip applications should use this to access features of the ConnectivityManager object
317 : * that are common to all platforms.
318 : */
319 : extern ConnectivityManager & ConnectivityMgr();
320 :
321 : /**
322 : * Returns the platform-specific implementation of the ConnectivityManager singleton object.
323 : *
324 : * chip applications can use this to gain access to features of the ConnectivityManager
325 : * that are specific to the selected platform.
326 : */
327 : extern ConnectivityManagerImpl & ConnectivityMgrImpl();
328 :
329 : } // namespace DeviceLayer
330 : } // namespace chip
331 :
332 : /* Include a header file containing the implementation of the ConfigurationManager
333 : * object for the selected platform.
334 : */
335 : #ifdef EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
336 : #include EXTERNAL_CONNECTIVITYMANAGERIMPL_HEADER
337 : #elif defined(CHIP_DEVICE_LAYER_TARGET)
338 : #define CONNECTIVITYMANAGERIMPL_HEADER <platform/CHIP_DEVICE_LAYER_TARGET/ConnectivityManagerImpl.h>
339 : #include CONNECTIVITYMANAGERIMPL_HEADER
340 : #endif // defined(CHIP_DEVICE_LAYER_TARGET)
341 :
342 : namespace chip {
343 : namespace DeviceLayer {
344 :
345 23 : inline chip::Inet::EndPointManager<Inet::UDPEndPoint> & ConnectivityManager::UDPEndPointManager()
346 : {
347 23 : return static_cast<ImplClass *>(this)->_UDPEndPointManager();
348 : }
349 :
350 : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
351 5 : inline chip::Inet::EndPointManager<Inet::TCPEndPoint> & ConnectivityManager::TCPEndPointManager()
352 : {
353 5 : return static_cast<ImplClass *>(this)->_TCPEndPointManager();
354 : }
355 : #endif
356 :
357 : inline ConnectivityManager::WiFiStationMode ConnectivityManager::GetWiFiStationMode()
358 : {
359 : return static_cast<ImplClass *>(this)->_GetWiFiStationMode();
360 : }
361 :
362 : inline CHIP_ERROR ConnectivityManager::SetWiFiStationMode(WiFiStationMode val)
363 : {
364 : return static_cast<ImplClass *>(this)->_SetWiFiStationMode(val);
365 : }
366 :
367 : inline bool ConnectivityManager::IsWiFiStationEnabled()
368 : {
369 : return static_cast<ImplClass *>(this)->_IsWiFiStationEnabled();
370 : }
371 :
372 : inline bool ConnectivityManager::IsWiFiStationApplicationControlled()
373 : {
374 : return static_cast<ImplClass *>(this)->_IsWiFiStationApplicationControlled();
375 : }
376 :
377 : inline bool ConnectivityManager::IsWiFiStationConnected()
378 : {
379 : return static_cast<ImplClass *>(this)->_IsWiFiStationConnected();
380 : }
381 :
382 : inline System::Clock::Timeout ConnectivityManager::GetWiFiStationReconnectInterval()
383 : {
384 : return static_cast<ImplClass *>(this)->_GetWiFiStationReconnectInterval();
385 : }
386 :
387 : inline CHIP_ERROR ConnectivityManager::SetWiFiStationReconnectInterval(System::Clock::Timeout val)
388 : {
389 : return static_cast<ImplClass *>(this)->_SetWiFiStationReconnectInterval(val);
390 : }
391 :
392 : inline bool ConnectivityManager::IsWiFiStationProvisioned()
393 : {
394 : return static_cast<ImplClass *>(this)->_IsWiFiStationProvisioned();
395 : }
396 :
397 : inline void ConnectivityManager::ClearWiFiStationProvision()
398 : {
399 : static_cast<ImplClass *>(this)->_ClearWiFiStationProvision();
400 : }
401 :
402 : inline ConnectivityManager::WiFiAPMode ConnectivityManager::GetWiFiAPMode()
403 : {
404 : return static_cast<ImplClass *>(this)->_GetWiFiAPMode();
405 : }
406 :
407 : inline CHIP_ERROR ConnectivityManager::SetWiFiAPMode(WiFiAPMode val)
408 : {
409 : return static_cast<ImplClass *>(this)->_SetWiFiAPMode(val);
410 : }
411 :
412 : inline bool ConnectivityManager::IsWiFiAPActive()
413 : {
414 : return static_cast<ImplClass *>(this)->_IsWiFiAPActive();
415 : }
416 :
417 : inline bool ConnectivityManager::IsWiFiAPApplicationControlled()
418 : {
419 : return static_cast<ImplClass *>(this)->_IsWiFiAPApplicationControlled();
420 : }
421 :
422 : inline void ConnectivityManager::DemandStartWiFiAP()
423 : {
424 : static_cast<ImplClass *>(this)->_DemandStartWiFiAP();
425 : }
426 :
427 : inline void ConnectivityManager::StopOnDemandWiFiAP()
428 : {
429 : static_cast<ImplClass *>(this)->_StopOnDemandWiFiAP();
430 : }
431 :
432 : inline void ConnectivityManager::MaintainOnDemandWiFiAP()
433 : {
434 : static_cast<ImplClass *>(this)->_MaintainOnDemandWiFiAP();
435 : }
436 :
437 : inline System::Clock::Timeout ConnectivityManager::GetWiFiAPIdleTimeout()
438 : {
439 : return static_cast<ImplClass *>(this)->_GetWiFiAPIdleTimeout();
440 : }
441 :
442 : inline void ConnectivityManager::SetWiFiAPIdleTimeout(System::Clock::Timeout val)
443 : {
444 : static_cast<ImplClass *>(this)->_SetWiFiAPIdleTimeout(val);
445 : }
446 :
447 : inline CHIP_ERROR ConnectivityManager::GetAndLogWiFiStatsCounters()
448 : {
449 : return static_cast<ImplClass *>(this)->_GetAndLogWiFiStatsCounters();
450 : }
451 :
452 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
453 : inline CHIP_ERROR ConnectivityManager::WiFiPAFPublish(WiFiPAFAdvertiseParam & args)
454 : {
455 : return static_cast<ImplClass *>(this)->_WiFiPAFPublish(args);
456 : }
457 :
458 : inline CHIP_ERROR ConnectivityManager::WiFiPAFCancelPublish(uint32_t PublishId)
459 : {
460 : return static_cast<ImplClass *>(this)->_WiFiPAFCancelPublish(PublishId);
461 : }
462 :
463 0 : inline CHIP_ERROR ConnectivityManager::WiFiPAFSubscribe(const uint16_t & connDiscriminator, void * appState,
464 : OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError)
465 : {
466 0 : return static_cast<ImplClass *>(this)->_WiFiPAFSubscribe(connDiscriminator, appState, onSuccess, onError);
467 : }
468 :
469 : inline CHIP_ERROR ConnectivityManager::WiFiPAFCancelSubscribe(uint32_t SubscribeId)
470 : {
471 : return static_cast<ImplClass *>(this)->_WiFiPAFCancelSubscribe(SubscribeId);
472 : }
473 :
474 0 : inline CHIP_ERROR ConnectivityManager::WiFiPAFCancelIncompleteSubscribe()
475 : {
476 0 : return static_cast<ImplClass *>(this)->_WiFiPAFCancelIncompleteSubscribe();
477 : }
478 :
479 0 : inline CHIP_ERROR ConnectivityManager::WiFiPAFSend(const WiFiPAF::WiFiPAFSession & TxInfo,
480 : chip::System::PacketBufferHandle && msgBuf)
481 : {
482 0 : return static_cast<ImplClass *>(this)->_WiFiPAFSend(TxInfo, std::move(msgBuf));
483 : }
484 :
485 0 : inline CHIP_ERROR ConnectivityManager::WiFiPAFShutdown(uint32_t id, WiFiPAF::WiFiPafRole role)
486 : {
487 0 : return static_cast<ImplClass *>(this)->_WiFiPAFShutdown(id, role);
488 : }
489 :
490 0 : inline bool ConnectivityManager::WiFiPAFResourceAvailable()
491 : {
492 0 : return static_cast<ImplClass *>(this)->_WiFiPAFResourceAvailable();
493 : }
494 : #endif
495 :
496 : inline bool ConnectivityManager::IsThreadEnabled()
497 : {
498 : return static_cast<ImplClass *>(this)->_IsThreadEnabled();
499 : }
500 :
501 : inline ConnectivityManager::ThreadDeviceType ConnectivityManager::GetThreadDeviceType()
502 : {
503 : return static_cast<ImplClass *>(this)->_GetThreadDeviceType();
504 : }
505 :
506 : inline CHIP_ERROR ConnectivityManager::SetThreadDeviceType(ThreadDeviceType deviceType)
507 : {
508 : return static_cast<ImplClass *>(this)->_SetThreadDeviceType(deviceType);
509 : }
510 :
511 39 : inline CHIP_ERROR ConnectivityManager::SetPollingInterval(System::Clock::Milliseconds32 pollingInterval)
512 : {
513 : #if CHIP_CONFIG_ENABLE_ICD_SERVER
514 : return static_cast<ImplClass *>(this)->_SetPollingInterval(pollingInterval);
515 : #else
516 39 : return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE;
517 : #endif
518 : }
519 :
520 : inline bool ConnectivityManager::IsThreadAttached()
521 : {
522 : return static_cast<ImplClass *>(this)->_IsThreadAttached();
523 : }
524 :
525 : inline bool ConnectivityManager::IsThreadProvisioned()
526 : {
527 : return static_cast<ImplClass *>(this)->_IsThreadProvisioned();
528 : }
529 :
530 : inline void ConnectivityManager::ErasePersistentInfo()
531 : {
532 : static_cast<ImplClass *>(this)->_ErasePersistentInfo();
533 : }
534 :
535 : inline void ConnectivityManager::ResetThreadNetworkDiagnosticsCounts()
536 : {
537 : static_cast<ImplClass *>(this)->_ResetThreadNetworkDiagnosticsCounts();
538 : }
539 :
540 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
541 2 : inline WiFiPAF::WiFiPAFLayer * ConnectivityManager::GetWiFiPAF()
542 : {
543 2 : return &WiFiPAF::WiFiPAFLayer::GetWiFiPAFLayer();
544 : }
545 :
546 : inline void ConnectivityManager::WiFiPafSetApFreq(const uint16_t freq)
547 : {
548 : static_cast<ImplClass *>(this)->_WiFiPafSetApFreq(freq);
549 : }
550 : #endif
551 :
552 2 : inline Ble::BleLayer * ConnectivityManager::GetBleLayer()
553 : {
554 2 : return static_cast<ImplClass *>(this)->_GetBleLayer();
555 : }
556 :
557 : inline bool ConnectivityManager::IsBLEAdvertisingEnabled()
558 : {
559 : return static_cast<ImplClass *>(this)->_IsBLEAdvertisingEnabled();
560 : }
561 :
562 2 : inline CHIP_ERROR ConnectivityManager::SetBLEAdvertisingEnabled(bool val)
563 : {
564 2 : return static_cast<ImplClass *>(this)->_SetBLEAdvertisingEnabled(val);
565 : }
566 :
567 : inline bool ConnectivityManager::IsBLEAdvertising()
568 : {
569 : return static_cast<ImplClass *>(this)->_IsBLEAdvertising();
570 : }
571 :
572 : inline CHIP_ERROR ConnectivityManager::SetBLEAdvertisingMode(BLEAdvertisingMode mode)
573 : {
574 : return static_cast<ImplClass *>(this)->_SetBLEAdvertisingMode(mode);
575 : }
576 :
577 : inline CHIP_ERROR ConnectivityManager::GetBLEDeviceName(char * buf, size_t bufSize)
578 : {
579 : return static_cast<ImplClass *>(this)->_GetBLEDeviceName(buf, bufSize);
580 : }
581 :
582 : inline CHIP_ERROR ConnectivityManager::SetBLEDeviceName(const char * deviceName)
583 : {
584 : return static_cast<ImplClass *>(this)->_SetBLEDeviceName(deviceName);
585 : }
586 :
587 : inline uint16_t ConnectivityManager::NumBLEConnections()
588 : {
589 : return static_cast<ImplClass *>(this)->_NumBLEConnections();
590 : }
591 :
592 : inline bool ConnectivityManager::IsUserSelectedModeActive()
593 : {
594 : return static_cast<ImplClass *>(this)->_IsUserSelectedModeActive();
595 : }
596 :
597 : inline void ConnectivityManager::SetUserSelectedMode(bool val)
598 : {
599 : static_cast<ImplClass *>(this)->_SetUserSelectedMode(val);
600 : }
601 :
602 : inline uint16_t ConnectivityManager::GetUserSelectedModeTimeout()
603 : {
604 : return static_cast<ImplClass *>(this)->_GetUserSelectedModeTimeout();
605 : }
606 :
607 : inline void ConnectivityManager::SetUserSelectedModeTimeout(uint16_t val)
608 : {
609 : static_cast<ImplClass *>(this)->_SetUserSelectedModeTimeout(val);
610 : }
611 :
612 : inline const char * ConnectivityManager::WiFiStationModeToStr(WiFiStationMode mode)
613 : {
614 : return ImplClass::_WiFiStationModeToStr(mode);
615 : }
616 :
617 : inline const char * ConnectivityManager::WiFiAPModeToStr(WiFiAPMode mode)
618 : {
619 : return ImplClass::_WiFiAPModeToStr(mode);
620 : }
621 :
622 : inline const char * ConnectivityManager::WiFiStationStateToStr(WiFiStationState state)
623 : {
624 : return ImplClass::_WiFiStationStateToStr(state);
625 : }
626 :
627 : inline const char * ConnectivityManager::WiFiAPStateToStr(WiFiAPState state)
628 : {
629 : return ImplClass::_WiFiAPStateToStr(state);
630 : }
631 :
632 : inline const char * ConnectivityManager::CHIPoBLEServiceModeToStr(CHIPoBLEServiceMode mode)
633 : {
634 : return ImplClass::_CHIPoBLEServiceModeToStr(mode);
635 : }
636 :
637 : inline CHIP_ERROR ConnectivityManager::Init()
638 : {
639 : return static_cast<ImplClass *>(this)->_Init();
640 : }
641 :
642 : inline void ConnectivityManager::OnPlatformEvent(const ChipDeviceEvent * event)
643 : {
644 : static_cast<ImplClass *>(this)->_OnPlatformEvent(event);
645 : }
646 :
647 : inline void ConnectivityManager::OnWiFiScanDone()
648 : {
649 : static_cast<ImplClass *>(this)->_OnWiFiScanDone();
650 : }
651 :
652 : inline void ConnectivityManager::OnWiFiStationProvisionChange()
653 : {
654 : static_cast<ImplClass *>(this)->_OnWiFiStationProvisionChange();
655 : }
656 :
657 : inline CHIP_ERROR ConnectivityManager::DisconnectNetwork()
658 : {
659 : return static_cast<ImplClass *>(this)->_DisconnectNetwork();
660 : }
661 :
662 : } // namespace DeviceLayer
663 : } // namespace chip
|
