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  * Value for no signal strength.
293  */
294 //--------------------------------------------------------------------------------------------------
295 #define LE_WIFICLIENT_NO_SIGNAL_STRENGTH 32767
296 
297 //--------------------------------------------------------------------------------------------------
298 /**
299  * Reference type for AccessPoint that is returned by the WiFi Scan.
300  */
301 //--------------------------------------------------------------------------------------------------
302 typedef struct le_wifiClient_AccessPoint* le_wifiClient_AccessPointRef_t;
303 
304 
305 //--------------------------------------------------------------------------------------------------
306 /**
307  * WiFi Client Events.
308  */
309 //--------------------------------------------------------------------------------------------------
310 typedef enum
311 {
313  ///< WiFi Client Connected
315  ///< WiFi Client Disconnected
317  ///< WiFi Scan result for available Access Points available
319  ///< WiFi Scan failed
320 }
322 
323 
324 //--------------------------------------------------------------------------------------------------
325 /**
326  * WiFi Client Security Protocol for connection
327  */
328 //--------------------------------------------------------------------------------------------------
329 typedef enum
330 {
332  ///< no security.
334  ///< Using WEP.
336  ///< Using WPA
338  ///< Using WPA2
340  ///< Using WPA Enterprise
342  ///< Using WPA2 Enterprise
343 }
345 
346 
347 //--------------------------------------------------------------------------------------------------
348 /**
349  * Reference type used by Add/Remove functions for EVENT 'le_wifiClient_NewEvent'
350  */
351 //--------------------------------------------------------------------------------------------------
352 typedef struct le_wifiClient_NewEventHandler* le_wifiClient_NewEventHandlerRef_t;
353 
354 
355 //--------------------------------------------------------------------------------------------------
356 /**
357  * Handler for WiFi Client changes
358  */
359 //--------------------------------------------------------------------------------------------------
361 (
362  le_wifiClient_Event_t event,
363  ///< Handles the wifi events
364  void* contextPtr
365  ///<
366 );
367 
368 //--------------------------------------------------------------------------------------------------
369 /**
370  * Add handler function for EVENT 'le_wifiClient_NewEvent'
371  *
372  * This event provide information on WiFi Client event changes.
373  *
374  */
375 //--------------------------------------------------------------------------------------------------
377 (
379  ///< [IN]
380  void* contextPtr
381  ///< [IN]
382 );
383 
384 //--------------------------------------------------------------------------------------------------
385 /**
386  * Remove handler function for EVENT 'le_wifiClient_NewEvent'
387  */
388 //--------------------------------------------------------------------------------------------------
390 (
392  ///< [IN]
393 );
394 
395 //--------------------------------------------------------------------------------------------------
396 /**
397  * Start the WIFI device.
398  *
399  * @return
400  * - LE_OK Function succeeded.
401  * - LE_FAULT Function failed.
402  * - LE_BUSY The WIFI device is already started.
403  */
404 //--------------------------------------------------------------------------------------------------
406 (
407  void
408 );
409 
410 //--------------------------------------------------------------------------------------------------
411 /**
412  * Stop the WIFI device.
413  *
414  * @return
415  * - LE_OK Function succeeded.
416  * - LE_FAULT Function failed.
417  * - LE_DUPLICATE The WIFI device is already stopped.
418  */
419 //--------------------------------------------------------------------------------------------------
421 (
422  void
423 );
424 
425 //--------------------------------------------------------------------------------------------------
426 /**
427  * Start Scanning for WiFi Access points
428  * Will result in event LE_WIFICLIENT_EVENT_SCAN_DONE when the scan results are available.
429  *
430  * @return
431  * - LE_OK Function succeeded.
432  * - LE_FAULT Function failed.
433  * - LE_BUSY Scan already running.
434  */
435 //--------------------------------------------------------------------------------------------------
437 (
438  void
439 );
440 
441 //--------------------------------------------------------------------------------------------------
442 /**
443  * Get the first WiFi Access Point found.
444  *
445  * @return
446  * - WiFi Access Point reference if ok.
447  * - NULL If no Access Point reference available.
448  */
449 //--------------------------------------------------------------------------------------------------
451 (
452  void
453 );
454 
455 //--------------------------------------------------------------------------------------------------
456 /**
457  * Get the next WiFi Access Point.
458  * Will return the Access Points in the order of found.
459  * This function must be called in the same context as the GetFirstAccessPoint
460  *
461  * @return
462  * - WiFi Access Point reference if ok.
463  * - NULL If no Access Point reference available.
464  */
465 //--------------------------------------------------------------------------------------------------
467 (
468  void
469 );
470 
471 //--------------------------------------------------------------------------------------------------
472 /**
473  * Get the signal strength of the AccessPoint
474  *
475  * @return
476  * - Signal strength in dBm. Example -30 = -30dBm
477  * - If no signal available it will return LE_WIFICLIENT_NO_SIGNAL_STRENGTH
478  *
479  * @note The function returns the signal strength as reported at the time of the scan.
480  */
481 //--------------------------------------------------------------------------------------------------
483 (
484  le_wifiClient_AccessPointRef_t accessPointRef
485  ///< [IN] WiFi Access Point reference.
486 );
487 
488 //--------------------------------------------------------------------------------------------------
489 /**
490  * Get the Basic Service set identifier (BSSID) of the AccessPoint
491  *
492  * @return
493  * LE_OK Function succeeded.
494  * LE_FAULT Function failed.
495  * LE_BAD_PARAMETER Invalid parameter.
496  * LE_OVERFLOW bssid buffer is too small to contain the BSSID.
497  */
498 //--------------------------------------------------------------------------------------------------
500 (
501  le_wifiClient_AccessPointRef_t accessPointRef,
502  ///< [IN] WiFi Access Point reference.
503  char* bssid,
504  ///< [OUT] The BSSID
505  size_t bssidSize
506  ///< [IN]
507 );
508 
509 //--------------------------------------------------------------------------------------------------
510 /**
511  * Get the Service set identification (SSID) of the AccessPoint
512  *
513  * @return
514  * LE_OK Function succeeded.
515  * LE_FAULT Function failed.
516  * LE_BAD_PARAMETER Invalid parameter.
517  * LE_OVERFLOW ssid buffer is too small to contain the SSID.
518  *
519  * @note The SSID does not have to be human readable ASCII values, but often is.
520  */
521 //--------------------------------------------------------------------------------------------------
523 (
524  le_wifiClient_AccessPointRef_t accessPointRef,
525  ///< [IN] WiFi Access Point reference.
526  uint8_t* ssidPtr,
527  ///< [OUT] The SSID returned as a octet array.
528  size_t* ssidSizePtr
529  ///< [INOUT]
530 );
531 
532 //--------------------------------------------------------------------------------------------------
533 /**
534  * Set the passphrase used to generate the PSK.
535  *
536  * @return
537  * - LE_OK Function succeeded.
538  * - LE_FAULT Function failed.
539  * - LE_BAD_PARAMETER Invalid parameter.
540  *
541  * @note The difference between le_wifiClient_SetPreSharedKey() and this function
542  */
543 //--------------------------------------------------------------------------------------------------
545 (
546  le_wifiClient_AccessPointRef_t accessPointRef,
547  ///< [IN] WiFi Access Point reference.
548  const char* LE_NONNULL PassPhrase
549  ///< [IN] pass-phrase for PSK
550 );
551 
552 //--------------------------------------------------------------------------------------------------
553 /**
554  * Set the Pre Shared Key, PSK.
555  *
556  * @return
557  * - LE_OK Function succeeded.
558  * - LE_FAULT Function failed.
559  * - LE_BAD_PARAMETER Invalid parameter.
560  *
561  * @note This is one way to authenticate against the access point. The other one is provided by the
562  * le_wifiClient_SetPassPhrase() function. Both ways are exclusive and are effective only when used
563  * with WPA-personal authentication.
564  */
565 //--------------------------------------------------------------------------------------------------
567 (
568  le_wifiClient_AccessPointRef_t accessPointRef,
569  ///< [IN] WiFi Access Point reference.
570  const char* LE_NONNULL PreSharedKey
571  ///< [IN] PSK. Note the difference between PSK and
572  ///< Pass Phrase.
573 );
574 
575 //--------------------------------------------------------------------------------------------------
576 /**
577  * Set the security protocol for connection
578  *
579  * @return
580  * - LE_OK Function succeeded.
581  * - LE_FAULT Function failed.
582  * - LE_BAD_PARAMETER Invalid parameter.
583  */
584 //--------------------------------------------------------------------------------------------------
586 (
587  le_wifiClient_AccessPointRef_t accessPointRef,
588  ///< [IN] WiFi Access Point reference.
589  le_wifiClient_SecurityProtocol_t securityProtocol
590  ///< [IN] Security Mode
591 );
592 
593 //--------------------------------------------------------------------------------------------------
594 /**
595  * WPA-Enterprise requires a username and password to authenticate.
596  * This function sets these parameters.
597  *
598  * @return
599  * - LE_OK Function succeeded.
600  * - LE_FAULT Function failed.
601  * - LE_BAD_PARAMETER Invalid parameter.
602  */
603 //--------------------------------------------------------------------------------------------------
605 (
606  le_wifiClient_AccessPointRef_t accessPointRef,
607  ///< [IN] WiFi Access Point reference.
608  const char* LE_NONNULL userName,
609  ///< [IN] UserName used for WPA-Enterprise.
610  const char* LE_NONNULL password
611  ///< [IN] Password used for WPA-Enterprise.
612 );
613 
614 //--------------------------------------------------------------------------------------------------
615 /**
616  * Set the WEP key (WEP)
617  *
618  * @return
619  * - LE_OK Function succeeded.
620  * - LE_FAULT Function failed.
621  */
622 //--------------------------------------------------------------------------------------------------
624 (
625  le_wifiClient_AccessPointRef_t accessPointRef,
626  ///< [IN] WiFi Access Point reference.
627  const char* LE_NONNULL wepKey
628  ///< [IN] The WEP key
629 );
630 
631 //--------------------------------------------------------------------------------------------------
632 /**
633  * This function specifies whether the target Access Point is hiding its presence from clients or
634  * not. When an Access Point is hidden, it cannot be discovered by a scan process.
635  *
636  * @return
637  * - LE_OK Function succeeded.
638  * - LE_BAD_PARAMETER Invalid parameter.
639  *
640  * @note By default, this attribute is not set which means that the client is unable to connect to
641  * a hidden access point. When enabled, the client will be able to connect to the access point
642  * whether it is hidden or not.
643  */
644 //--------------------------------------------------------------------------------------------------
646 (
647  le_wifiClient_AccessPointRef_t accessPointRef,
648  ///< [IN] WiFi Access Point reference.
649  bool hidden
650  ///< [IN] If TRUE, the WIFI client will be able to connect to a hidden access point.
651 );
652 
653 //--------------------------------------------------------------------------------------------------
654 /**
655  * This function creates a reference to an Access Point given its SSID.
656  * If an Access Point is hidden, it will not show up in the scan. So, its SSID must be known
657  * in advance in order to create a reference.
658  *
659  * @return
660  * - AccessPoint reference to the current Access Point.
661  *
662  * @note This function fails if called while scan is running.
663  */
664 //--------------------------------------------------------------------------------------------------
666 (
667  const uint8_t* SsidPtr,
668  ///< [IN] The SSID as a octet array.
669  size_t SsidSize
670  ///< [IN]
671 );
672 
673 //--------------------------------------------------------------------------------------------------
674 /**
675  * Deletes an accessPointRef.
676  *
677  * @return
678  * - LE_OK Function succeeded.
679  * - LE_BAD_PARAMETER Invalid parameter.
680  * - LE_BUSY Function called during scan.
681  *
682  * @note The handle becomes invalid after it has been deleted.
683  */
684 //--------------------------------------------------------------------------------------------------
686 (
687  le_wifiClient_AccessPointRef_t accessPointRef
688  ///< [IN] WiFi Access Point reference.
689 );
690 
691 //--------------------------------------------------------------------------------------------------
692 /**
693  * Connect to the WiFi Access Point.
694  * All authentication must be set prior to calling this function.
695  *
696  * @return
697  * - LE_OK Function succeeded.
698  * - LE_BAD_PARAMETER Invalid parameter.
699  *
700  * @note For PSK credentials see le_wifiClient_SetPassphrase() or le_wifiClient_SetPreSharedKey() .
701  * @note For WPA-Enterprise credentials see le_wifiClient_SetUserCredentials()
702  */
703 //--------------------------------------------------------------------------------------------------
705 (
706  le_wifiClient_AccessPointRef_t accessPointRef
707  ///< [IN] WiFi Access Point reference.
708 );
709 
710 //--------------------------------------------------------------------------------------------------
711 /**
712  * Disconnect from the current connected WiFi Access Point.
713  *
714  * @return
715  * - LE_OK Function succeeded.
716  * - LE_FAULT Function failed.
717  */
718 //--------------------------------------------------------------------------------------------------
720 (
721  void
722 );
723 
724 #endif // LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
struct le_wifiClient_NewEventHandler * le_wifiClient_NewEventHandlerRef_t
Definition: le_wifiClient_interface.h:352
le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint(void)
void(* le_wifiClient_DisconnectHandler_t)(void *)
Definition: le_wifiClient_interface.h:213
void le_wifiClient_ConnectService(void)
le_result_t le_wifiClient_GetBssid(le_wifiClient_AccessPointRef_t accessPointRef, char *bssid, size_t bssidSize)
le_result_t le_wifiClient_SetUserCredentials(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL userName, const char *LE_NONNULL password)
le_result_t le_wifiClient_GetSsid(le_wifiClient_AccessPointRef_t accessPointRef, uint8_t *ssidPtr, size_t *ssidSizePtr)
le_result_t
Definition: le_basics.h:35
le_result_t le_wifiClient_Start(void)
WiFi Scan result for available Access Points available.
Definition: le_wifiClient_interface.h:316
le_result_t le_wifiClient_Stop(void)
WiFi Client Disconnected.
Definition: le_wifiClient_interface.h:314
int16_t le_wifiClient_GetSignalStrength(le_wifiClient_AccessPointRef_t accessPointRef)
le_result_t le_wifiClient_SetSecurityProtocol(le_wifiClient_AccessPointRef_t accessPointRef, le_wifiClient_SecurityProtocol_t securityProtocol)
no security.
Definition: le_wifiClient_interface.h:331
void le_wifiClient_SetServerDisconnectHandler(le_wifiClient_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_wifiClient_Event_t
Definition: le_wifiClient_interface.h:310
le_wifiClient_SecurityProtocol_t
Definition: le_wifiClient_interface.h:329
le_result_t le_wifiClient_SetWepKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL wepKey)
Using WPA2.
Definition: le_wifiClient_interface.h:337
le_result_t le_wifiClient_SetHiddenNetworkAttribute(le_wifiClient_AccessPointRef_t accessPointRef, bool hidden)
le_result_t le_wifiClient_Delete(le_wifiClient_AccessPointRef_t accessPointRef)
WiFi Client Connected.
Definition: le_wifiClient_interface.h:312
le_result_t le_wifiClient_SetPreSharedKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PreSharedKey)
Using WPA.
Definition: le_wifiClient_interface.h:335
le_result_t le_wifiClient_Disconnect(void)
void le_wifiClient_RemoveNewEventHandler(le_wifiClient_NewEventHandlerRef_t handlerRef)
le_wifiClient_AccessPointRef_t le_wifiClient_Create(const uint8_t *SsidPtr, size_t SsidSize)
Using WPA Enterprise.
Definition: le_wifiClient_interface.h:339
Using WPA2 Enterprise.
Definition: le_wifiClient_interface.h:341
void(* le_wifiClient_NewEventHandlerFunc_t)(le_wifiClient_Event_t event, void *contextPtr)
Definition: le_wifiClient_interface.h:361
le_result_t le_wifiClient_TryConnectService(void)
WiFi Scan failed.
Definition: le_wifiClient_interface.h:318
struct le_wifiClient_AccessPoint * le_wifiClient_AccessPointRef_t
Definition: le_wifiClient_interface.h:302
le_result_t le_wifiClient_Scan(void)
le_result_t le_wifiClient_Connect(le_wifiClient_AccessPointRef_t accessPointRef)
void le_wifiClient_DisconnectService(void)
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_SetPassphrase(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PassPhrase)
Using WEP.
Definition: le_wifiClient_interface.h:333