le_wifiClient_interface.h

Go to the documentation of this file.
1 
2 
3 /*
4  * ====================== WARNING ======================
5  *
6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
7  * DO NOT MODIFY IN ANY WAY.
8  *
9  * ====================== WARNING ======================
10  */
11 
12 /**
13  * @page c_le_wifi_client WiFi Client Service
14  *
15  * @ref le_wifiClient_interface.h "API Reference"
16  *
17  * <HR>
18  *
19  * This API provides WiFi Client setup.
20  * Please note that the WiFi Client cannot be used at the same time as the WiFi Access Points
21  * service, due to the sharing of same wifi hardware.
22  *
23  * @section le_wifi_binding IPC interfaces binding
24  *
25  *
26  * Here's a code sample binding to WiFi service:
27  * @verbatim
28  bindings:
29  {
30  clientExe.clientComponent.le_wifiClient -> wifiService.le_wifiClient
31  }
32  @endverbatim
33  *
34  * @section le_wifiClient_Start Starting the WiFi Client
35  *
36  * First of all the function le_wifiClient_Start() must be called to start the WiFi Service.
37  * - le_wifiClient_Start(): returns LE_OK if the call went ok.
38  * If WiFi Access Point is active, this will fail.
39  *
40  *
41  * To subscribe to wifi events le_wifiClient_AddNewEventHandler() is to be called.
42  * - le_wifiClient_AddNewEventHandler(): returns the handler reference if the call went ok.
43  *
44  * @code
45  *
46  * static void EventHandler
47  * (
48  * le_wifiClient_Event_t clientEvent,
49  * void *contextPtr
50  * )
51  * {
52  * switch( clientEvent )
53  * {
54  * case LE_WIFICLIENT_EVENT_CONNECTED:
55  * {
56  * LE_INFO("WiFi Client Connected.");
57  * }
58  * break;
59  * case LE_WIFICLIENT_EVENT_DISCONNECTED:
60  * {
61  * LE_INFO("WiFi Client Disconnected.");
62  * }
63  * break;
64  * case LE_WIFICLIENT_EVENT_SCAN_DONE:
65  * {
66  * LE_INFO("WiFi Client Scan is done.");
67  * MyHandleScanResult();
68  * }
69  * break;
70  * }
71  * }
72  *
73  * le_wifiClient_NewEventHandler WiFiEventHandlerRef = NULL;
74  *
75  * static void MyInit
76  * (
77  * void
78  * )
79  * {
80  * le_result_t result = le_wifiClient_start();
81  *
82  * if ( LE_OK == result )
83  * {
84  * LE_INFO("WiFi Client started.");
85  * WiFiEventHandlerRef = le_wifiClient_AddNewEventHandler( EventHandler, NULL );
86  * }
87  * else if ( LE_BUSY == result )
88  * {
89  * LE_INFO("ERROR: WiFi Client already started.");
90  * }
91  * else
92  * {
93  * LE_INFO("ERROR: WiFi Client not started.");
94  * }
95  *
96  * }
97  *
98  * @endcode
99  *
100  *
101  * @section le_wifiClient_scan Scanning Access Points with WiFi Client
102  *
103  * To start a scan for Access Points, the le_wifiClient_Scan() should be called.
104  * - le_wifiClient_Scan(): returns the LE_OK if the call went ok.
105  *
106  *
107  * @section le_wifiClient_scan_result Processing the WiFi scan results
108  *
109  * Once the scan results are available, the event LE_WIFICLIENT_EVENT_SCAN_DONE is received.
110  * The found Access Points can then be gotten with
111  * - le_wifiClient_GetFirstAccessPoint(): returns the Access Point if found. Else NULL.
112  * - le_wifiClient_GetNextAccessPoint(): returns the next Access Point if found. Else NULL.
113  *
114  * The Access Points SSID, Service Set Identifier, is not a string.
115  * It does however often contain human readable ASCII values.
116  * It can be read with the following function:
117  * - le_wifiClient_GetSsid() : returns the LE_OK if the SSID was read ok.
118  *
119  * The Access Points signal strength can be read with the following function:
120  * - le_wifiClient_GetSignalStrength() : returns the signal strength in dBm of the AccessPoint
121  *
122  * @code
123  *
124  * static void MyHandleScanResult
125  * (
126  * void
127  * )
128  * {
129  * uint8 ssid[MAX_SSID_BYTES];
130  * le_wifiClient_AccessPointRef_t accessPointRef = le_wifiClient_GetFirstAccessPoint();
131  *
132  * while( NULL != accessPointRef )
133  * {
134  * result = le_wifiClient_GetSsid( accessPointRef, ssid, MAX_SSID_BYTES );
135  * if (( result == LE_OK ) && ( memcmp( ssid, "MySSID", 6) == 0 ))
136  * {
137  * LE_INFO("WiFi Client found.");
138  * break;
139  * }
140  * accessPointRef = le_wifiClient_GetNextAccessPoint();
141  * }
142  * }
143  *
144  * @endcode
145  *
146  * @section le_wifiClient_connect_to_ap Connecting to Access Point
147  *
148  * First of all, an Access Point reference should be created using the SSID of the target Access
149  * Point. Use the following function to create a reference:
150  * - le_wifiClient_Create(): returns Access Point reference
151  *
152  * To set the pass phrase prior for the Access Point use the function:
153  * - le_wifiClient_SetPassphrase(): returns the function execution status.
154  *
155  * WPA-Enterprise requires a username and password to authenticate.
156  * To set them use the function:
157  * - le_wifiClient_SetUserCredentials(): returns the function execution status.
158  *
159  * If an Access Point is hidden, it does not announce its presence and will not show up in scan.
160  * So, the SSID of this Access Point must be known in advance. Then, use the following function to
161  * allow connections to hidden Access Points:
162  * le_wifiClient_SetHiddenNetworkAttribute(): returns the function execution status.
163  *
164  * Finally and when the Access Point parameters have been configured, use the following function to
165  * attempt a connection:
166  * - le_wifiClient_Connect(): returns the function execution status.
167  *
168  * @code
169  *
170  * static void MyConnectTo
171  * (
172  * le_wifiClient_AccessPointRef_t accessPointRef
173  * )
174  * {
175  * le_result_t result;
176  * le_wifiClient_SetPassphrase ( accessPointRef, "Secret1" );
177  * result = le_wifiClient_Connect( accessPointRef );
178  * if (result == LE_OK)
179  * {
180  * LE_INFO("Connecting to AP.");
181  * }
182  * }
183  *
184  * @endcode
185  *
186  * <HR>
187  *
188  * Copyright (C) Sierra Wireless Inc.
189  */
190 /**
191  * @file le_wifiClient_interface.h
192  *
193  * Legato @ref c_le_wifi_client include file.
194  *
195  * Copyright (C) Sierra Wireless Inc.
196  */
197 
198 #ifndef LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
199 #define LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
200 
201 
202 #include "legato.h"
203 
204 // Interface specific includes
205 #include "le_wifiDefs_interface.h"
206 
207 
208 //--------------------------------------------------------------------------------------------------
209 /**
210  * Type for handler called when a server disconnects.
211  */
212 //--------------------------------------------------------------------------------------------------
213 typedef void (*le_wifiClient_DisconnectHandler_t)(void *);
214 
215 //--------------------------------------------------------------------------------------------------
216 /**
217  *
218  * Connect the current client thread to the service providing this API. Block until the service is
219  * available.
220  *
221  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
222  * called before any other functions in this API. Normally, ConnectService is automatically called
223  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
224  *
225  * This function is created automatically.
226  */
227 //--------------------------------------------------------------------------------------------------
229 (
230  void
231 );
232 
233 //--------------------------------------------------------------------------------------------------
234 /**
235  *
236  * Try to connect the current client thread to the service providing this API. Return with an error
237  * if the service is not available.
238  *
239  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
240  * called before any other functions in this API. Normally, ConnectService is automatically called
241  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
242  *
243  * This function is created automatically.
244  *
245  * @return
246  * - LE_OK if the client connected successfully to the service.
247  * - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
248  * bound.
249  * - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
250  * - LE_COMM_ERROR if the Service Directory cannot be reached.
251  */
252 //--------------------------------------------------------------------------------------------------
254 (
255  void
256 );
257 
258 //--------------------------------------------------------------------------------------------------
259 /**
260  * Set handler called when server disconnection is detected.
261  *
262  * When a server connection is lost, call this handler then exit with LE_FATAL. If a program wants
263  * to continue without exiting, it should call longjmp() from inside the handler.
264  */
265 //--------------------------------------------------------------------------------------------------
267 (
268  le_wifiClient_DisconnectHandler_t disconnectHandler,
269  void *contextPtr
270 );
271 
272 //--------------------------------------------------------------------------------------------------
273 /**
274  *
275  * Disconnect the current client thread from the service providing this API.
276  *
277  * Normally, this function doesn't need to be called. After this function is called, there's no
278  * longer a connection to the service, and the functions in this API can't be used. For details, see
279  * @ref apiFilesC_client.
280  *
281  * This function is created automatically.
282  */
283 //--------------------------------------------------------------------------------------------------
285 (
286  void
287 );
288 
289 
290 //--------------------------------------------------------------------------------------------------
291 /**
292  * Reference type for AccessPoint that is returned by the WiFi Scan.
293  */
294 //--------------------------------------------------------------------------------------------------
295 typedef struct le_wifiClient_AccessPoint* le_wifiClient_AccessPointRef_t;
296 
297 
298 //--------------------------------------------------------------------------------------------------
299 /**
300  * WiFi Client Events.
301  */
302 //--------------------------------------------------------------------------------------------------
303 typedef enum
304 {
306  ///< WiFi Client Connected
308  ///< WiFi Client Disconnected
310  ///< WiFi Scan result for available Access Points available
312  ///< WiFi Scan failed
313 }
315 
316 
317 //--------------------------------------------------------------------------------------------------
318 /**
319  * WiFi Client Security Protocol for connection
320  */
321 //--------------------------------------------------------------------------------------------------
322 typedef enum
323 {
325  ///< no security.
327  ///< Using WEP.
329  ///< Using WPA
331  ///< Using WPA2
333  ///< Using WPA Enterprise
335  ///< Using WPA2 Enterprise
336 }
338 
339 
340 //--------------------------------------------------------------------------------------------------
341 /**
342  * Reference type used by Add/Remove functions for EVENT 'le_wifiClient_NewEvent'
343  */
344 //--------------------------------------------------------------------------------------------------
345 typedef struct le_wifiClient_NewEventHandler* le_wifiClient_NewEventHandlerRef_t;
346 
347 
348 //--------------------------------------------------------------------------------------------------
349 /**
350  * Handler for WiFi Client changes
351  */
352 //--------------------------------------------------------------------------------------------------
354 (
355  le_wifiClient_Event_t event,
356  ///< Handles the wifi events
357  void* contextPtr
358  ///<
359 );
360 
361 //--------------------------------------------------------------------------------------------------
362 /**
363  * Add handler function for EVENT 'le_wifiClient_NewEvent'
364  *
365  * This event provide information on WiFi Client event changes.
366  *
367  */
368 //--------------------------------------------------------------------------------------------------
370 (
372  ///< [IN]
373  void* contextPtr
374  ///< [IN]
375 );
376 
377 //--------------------------------------------------------------------------------------------------
378 /**
379  * Remove handler function for EVENT 'le_wifiClient_NewEvent'
380  */
381 //--------------------------------------------------------------------------------------------------
383 (
385  ///< [IN]
386 );
387 
388 //--------------------------------------------------------------------------------------------------
389 /**
390  * This function starts the WIFI device.
391  *
392  * @return
393  * - LE_FAULT if the function failed.
394  * - LE_BUSY if the WIFI device is already started.
395  * - LE_OK if the function succeeded.
396  *
397  */
398 //--------------------------------------------------------------------------------------------------
400 (
401  void
402 );
403 
404 //--------------------------------------------------------------------------------------------------
405 /**
406  * This function stops the WIFI device.
407  *
408  * @return
409  * - LE_FAULT if the function failed.
410  * - LE_DUPLICATE if the WIFI device is already stopped.
411  * - LE_OK if the function succeeded.
412  *
413  */
414 //--------------------------------------------------------------------------------------------------
416 (
417  void
418 );
419 
420 //--------------------------------------------------------------------------------------------------
421 /**
422  * Start Scanning for WiFi Access points
423  * Will result in event LE_WIFICLIENT_EVENT_SCAN_DONE when the scan results are available.
424  *
425  * @return
426  * - LE_FAULT if the function failed.
427  * - LE_OK if the function succeeded.
428  */
429 //--------------------------------------------------------------------------------------------------
431 (
432  void
433 );
434 
435 //--------------------------------------------------------------------------------------------------
436 /**
437  * Get the first WiFi Access Point found.
438  * Will return the Access Points in the order of found.
439  *
440  * @return
441  * - WiFi Access Point reference if ok.
442  * - NULL if no Access Point reference available.
443  */
444 //--------------------------------------------------------------------------------------------------
446 (
447  void
448 );
449 
450 //--------------------------------------------------------------------------------------------------
451 /**
452  * Get the next WiFi Access Point.
453  * Will return the Access Points in the order of found.
454  * This function must be called in the same context as the GetFirstAccessPoint
455  *
456  * @return
457  * - WiFi Access Point reference if ok.
458  * - NULL if no Access Point reference available.
459  */
460 //--------------------------------------------------------------------------------------------------
462 (
463  void
464 );
465 
466 //--------------------------------------------------------------------------------------------------
467 /**
468  * Get the signal strength of the AccessPoint
469  *
470  * @return
471  * - signal strength in dBm. Example -30 = -30dBm
472  * - if no signal available it will return OxFFFF
473  */
474 //--------------------------------------------------------------------------------------------------
476 (
477  le_wifiClient_AccessPointRef_t accessPointRef
478  ///< [IN] WiFi Access Point reference.
479 );
480 
481 //--------------------------------------------------------------------------------------------------
482 /**
483  * Get the Basic Service set identifier (BSSID) of the AccessPoint
484  *
485  * @return LE_FAULT Function failed.
486  * @return LE_BAD_PARAMETER Some parameter is invalid.
487  * @return LE_OVERFLOW bssid buffer is too small to contain the BSSID
488  * @return LE_OK Function succeeded.
489  */
490 //--------------------------------------------------------------------------------------------------
492 (
493  le_wifiClient_AccessPointRef_t accessPointRef,
494  ///< [IN] WiFi Access Point reference.
495  char* bssid,
496  ///< [OUT] The BSSID
497  size_t bssidSize
498  ///< [IN]
499 );
500 
501 //--------------------------------------------------------------------------------------------------
502 /**
503  * Get the Service set identification (SSID) of the AccessPoint
504  * @note that the SSID does not have to be human readable ASCII values, but often has.
505  *
506  * @return LE_FAULT Function failed.
507  * @return LE_BAD_PARAMETER Some parameter is invalid.
508  * @return LE_OVERFLOW ssid buffer is too small to contain the SSID
509  * @return LE_OK Function succeeded.
510  */
511 //--------------------------------------------------------------------------------------------------
513 (
514  le_wifiClient_AccessPointRef_t accessPointRef,
515  ///< [IN] WiFi Access Point reference.
516  uint8_t* ssidPtr,
517  ///< [OUT] The SSID returned as a octet array.
518  size_t* ssidSizePtr
519  ///< [INOUT]
520 );
521 
522 //--------------------------------------------------------------------------------------------------
523 /**
524  * Set the passphrase used to generate the PSK.
525  *
526  * @note the difference between le_wifiClient_SetPreSharedKey() and this function
527  *
528  * @return
529  * - LE_FAULT if the function failed.
530  * - LE_BAD_PARAMETER if parameter is invalid.
531  * - LE_OK if the function succeeded.
532  *
533  */
534 //--------------------------------------------------------------------------------------------------
536 (
537  le_wifiClient_AccessPointRef_t accessPointRef,
538  ///< [IN] WiFi Access Point reference.
539  const char* LE_NONNULL PassPhrase
540  ///< [IN] pass-phrase for PSK
541 );
542 
543 //--------------------------------------------------------------------------------------------------
544 /**
545  * Set the Pre Shared Key, PSK.
546  * @note the difference between le_wifiClient_SetPassphrase() and this function
547  *
548  * @return
549  * - LE_FAULT if the function failed.
550  * - LE_BAD_PARAMETER if parameter is invalid.
551  * - LE_OK if the function succeeded.
552  *
553  */
554 //--------------------------------------------------------------------------------------------------
556 (
557  le_wifiClient_AccessPointRef_t accessPointRef,
558  ///< [IN] WiFi Access Point reference.
559  const char* LE_NONNULL PreSharedKey
560  ///< [IN] PSK. Note the difference between PSK and Pass Phrase.
561 );
562 
563 //--------------------------------------------------------------------------------------------------
564 /**
565  * Set the security protocol for connection
566  *
567  * @return
568  * - LE_FAULT if the function failed.
569  * - LE_BAD_PARAMETER if parameter is invalid.
570  * - LE_OK if the function succeeded.
571  *
572  */
573 //--------------------------------------------------------------------------------------------------
575 (
576  le_wifiClient_AccessPointRef_t accessPointRef,
577  ///< [IN] WiFi Access Point reference.
578  le_wifiClient_SecurityProtocol_t securityProtocol
579  ///< [IN] Security Mode
580 );
581 
582 //--------------------------------------------------------------------------------------------------
583 /**
584  * WPA-Enterprise requires a username and password to authenticate.
585  * This function sets these parameters.
586  *
587  * @return
588  * - LE_FAULT if the function failed.
589  * - LE_BAD_PARAMETER if parameter is invalid.
590  * - LE_OK if the function succeeded.
591  *
592  */
593 //--------------------------------------------------------------------------------------------------
595 (
596  le_wifiClient_AccessPointRef_t accessPointRef,
597  ///< [IN] WiFi Access Point reference.
598  const char* LE_NONNULL userName,
599  ///< [IN] UserName used for WPA-Enterprise.
600  const char* LE_NONNULL password
601  ///< [IN] Password used for WPA-Enterprise.
602 );
603 
604 //--------------------------------------------------------------------------------------------------
605 /**
606  * Set the WEP key (WEP)
607  *
608  * @return
609  * - LE_FAULT if the function failed.
610  * - LE_OK if the function succeeded.
611  */
612 //--------------------------------------------------------------------------------------------------
614 (
615  le_wifiClient_AccessPointRef_t accessPointRef,
616  ///< [IN] WiFi Access Point reference.
617  const char* LE_NONNULL wepKey
618  ///< [IN] The WEP key
619 );
620 
621 //--------------------------------------------------------------------------------------------------
622 /**
623  * This function specifies whether the target Access Point is hiding its presence from clients or
624  * not. When an Access Point is hidden, it cannot be discovered by a scan process.
625  *
626  * @note By default, this attribute is not set which means that the client is unable to connect to
627  * a hidden access point. When enabled, the client will be able to connect to the access point
628  * whether it is hidden or not.
629  *
630  * @return
631  * - LE_BAD_PARAMETER if parameter is invalid.
632  * - LE_OK if the function succeeded.
633  *
634  */
635 //--------------------------------------------------------------------------------------------------
637 (
638  le_wifiClient_AccessPointRef_t accessPointRef,
639  ///< [IN] WiFi Access Point reference.
640  bool hidden
641  ///< [IN] If TRUE, the WIFI client will be able to connect to a hidden access point.
642 );
643 
644 //--------------------------------------------------------------------------------------------------
645 /**
646  * This function creates a reference to an Access Point given its SSID.
647  * If an Access Point is hidden, it will not show up in the scan. So, its SSID must be known
648  * in advance in order to create a reference.
649  *
650  * @note This function fails if called while scan is running.
651  *
652  * @return AccessPoint reference to the current
653  */
654 //--------------------------------------------------------------------------------------------------
656 (
657  const uint8_t* SsidPtr,
658  ///< [IN] The SSID as a octet array.
659  size_t SsidSize
660  ///< [IN]
661 );
662 
663 //--------------------------------------------------------------------------------------------------
664 /**
665  * Deletes an accessPointRef.
666  *
667  * @note The handle becomes invalid after it has been deleted.
668  * @return
669  * - LE_BAD_PARAMETER if accessPointRef was not found.
670  * - LE_BUSY if the function was called during a scan.
671  * - LE_OK if the function succeeded.
672  */
673 //--------------------------------------------------------------------------------------------------
675 (
676  le_wifiClient_AccessPointRef_t accessPointRef
677  ///< [IN] WiFi Access Point reference.
678 );
679 
680 //--------------------------------------------------------------------------------------------------
681 /**
682  * Connect to the WiFi Access Point.
683  * All authentication must be set prior to calling this function.
684  *
685  * @return
686  * - LE_BAD_PARAMETER if parameter is invalid.
687  * - LE_OK if the function succeeded.
688  *
689  * @note For PSK credentials see le_wifiClient_SetPassphrase() or le_wifiClient_SetPreSharedKey() .
690  * @note For WPA-Enterprise credentials see le_wifiClient_SetUserCredentials()
691  */
692 //--------------------------------------------------------------------------------------------------
694 (
695  le_wifiClient_AccessPointRef_t accessPointRef
696  ///< [IN] WiFi Access Point reference.
697 );
698 
699 //--------------------------------------------------------------------------------------------------
700 /**
701  * Disconnect from the current connected WiFi Access Point.
702  *
703  * @return
704  * - LE_FAULT if the function failed.
705  * - LE_OK if the function succeeded.
706  */
707 //--------------------------------------------------------------------------------------------------
709 (
710  void
711 );
712 
713 #endif // LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
void le_wifiClient_ConnectService(void)
le_wifiClient_SecurityProtocol_t
Definition: le_wifiClient_interface.h:322
le_wifiClient_Event_t
Definition: le_wifiClient_interface.h:303
void(* le_wifiClient_DisconnectHandler_t)(void *)
Definition: le_wifiClient_interface.h:213
WiFi Client Connected.
Definition: le_wifiClient_interface.h:305
le_result_t
Definition: le_basics.h:35
void le_wifiClient_RemoveNewEventHandler(le_wifiClient_NewEventHandlerRef_t handlerRef)
le_result_t le_wifiClient_Start(void)
void le_wifiClient_DisconnectService(void)
le_result_t le_wifiClient_TryConnectService(void)
WiFi Scan failed.
Definition: le_wifiClient_interface.h:311
WiFi Client Disconnected.
Definition: le_wifiClient_interface.h:307
le_result_t le_wifiClient_SetPassphrase(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PassPhrase)
struct le_wifiClient_NewEventHandler * le_wifiClient_NewEventHandlerRef_t
Definition: le_wifiClient_interface.h:345
le_result_t le_wifiClient_Disconnect(void)
Using WPA Enterprise.
Definition: le_wifiClient_interface.h:332
struct le_wifiClient_AccessPoint * le_wifiClient_AccessPointRef_t
Definition: le_wifiClient_interface.h:295
le_result_t le_wifiClient_Delete(le_wifiClient_AccessPointRef_t accessPointRef)
no security.
Definition: le_wifiClient_interface.h:324
le_result_t le_wifiClient_SetWepKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL wepKey)
le_result_t le_wifiClient_SetHiddenNetworkAttribute(le_wifiClient_AccessPointRef_t accessPointRef, bool hidden)
Using WPA2.
Definition: le_wifiClient_interface.h:330
void le_wifiClient_SetServerDisconnectHandler(le_wifiClient_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_wifiClient_AccessPointRef_t le_wifiClient_GetFirstAccessPoint(void)
le_wifiClient_NewEventHandlerRef_t le_wifiClient_AddNewEventHandler(le_wifiClient_NewEventHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_wifiClient_GetBssid(le_wifiClient_AccessPointRef_t accessPointRef, char *bssid, size_t bssidSize)
Using WPA2 Enterprise.
Definition: le_wifiClient_interface.h:334
Using WEP.
Definition: le_wifiClient_interface.h:326
Using WPA.
Definition: le_wifiClient_interface.h:328
le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint(void)
le_result_t le_wifiClient_Connect(le_wifiClient_AccessPointRef_t accessPointRef)
le_result_t le_wifiClient_GetSsid(le_wifiClient_AccessPointRef_t accessPointRef, uint8_t *ssidPtr, size_t *ssidSizePtr)
le_result_t le_wifiClient_SetSecurityProtocol(le_wifiClient_AccessPointRef_t accessPointRef, le_wifiClient_SecurityProtocol_t securityProtocol)
le_wifiClient_AccessPointRef_t le_wifiClient_Create(const uint8_t *SsidPtr, size_t SsidSize)
le_result_t le_wifiClient_SetPreSharedKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PreSharedKey)
le_result_t le_wifiClient_Scan(void)
void(* le_wifiClient_NewEventHandlerFunc_t)(le_wifiClient_Event_t event, void *contextPtr)
Definition: le_wifiClient_interface.h:354
le_result_t le_wifiClient_Stop(void)
le_result_t le_wifiClient_SetUserCredentials(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL userName, const char *LE_NONNULL password)
int16_t le_wifiClient_GetSignalStrength(le_wifiClient_AccessPointRef_t accessPointRef)
WiFi Scan result for available Access Points available.
Definition: le_wifiClient_interface.h:309