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