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