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