le_wifiClient_interface.h

    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 //--------------------------------------------------------------------------------------------------
  228 void le_wifiClient_ConnectService
  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 //--------------------------------------------------------------------------------------------------
  253 le_result_t le_wifiClient_TryConnectService
  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 //--------------------------------------------------------------------------------------------------
  266 void le_wifiClient_SetServerDisconnectHandler
  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 //--------------------------------------------------------------------------------------------------
  284 void le_wifiClient_DisconnectService
  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 {
  305     LE_WIFICLIENT_EVENT_CONNECTED = 0,
  306         ///< WiFi Client Connected
  307     LE_WIFICLIENT_EVENT_DISCONNECTED = 1,
  308         ///< WiFi Client Disconnected
  309     LE_WIFICLIENT_EVENT_SCAN_DONE = 2,
  310         ///< WiFi Scan result for available Access Points available
  311     LE_WIFICLIENT_EVENT_SCAN_FAILED = 3
  312         ///< WiFi Scan failed
  313 }
  314 le_wifiClient_Event_t;
  315 
  316 
  317 //--------------------------------------------------------------------------------------------------
  318 /**
  319  * WiFi Client Security Protocol for connection
  320  */
  321 //--------------------------------------------------------------------------------------------------
  322 typedef enum
  323 {
  324     LE_WIFICLIENT_SECURITY_NONE = 0,
  325         ///< no security.
  326     LE_WIFICLIENT_SECURITY_WEP = 1,
  327         ///< Using WEP.
  328     LE_WIFICLIENT_SECURITY_WPA_PSK_PERSONAL = 2,
  329         ///< Using WPA
  330     LE_WIFICLIENT_SECURITY_WPA2_PSK_PERSONAL = 3,
  331         ///< Using WPA2
  332     LE_WIFICLIENT_SECURITY_WPA_EAP_PEAP0_ENTERPRISE = 4,
  333         ///< Using WPA Enterprise
  334     LE_WIFICLIENT_SECURITY_WPA2_EAP_PEAP0_ENTERPRISE = 5
  335         ///< Using WPA2 Enterprise
  336 }
  337 le_wifiClient_SecurityProtocol_t;
  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 //--------------------------------------------------------------------------------------------------
  353 typedef void (*le_wifiClient_NewEventHandlerFunc_t)
  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 //--------------------------------------------------------------------------------------------------
  369 le_wifiClient_NewEventHandlerRef_t le_wifiClient_AddNewEventHandler
  370 (
  371     le_wifiClient_NewEventHandlerFunc_t handlerPtr,
  372         ///< [IN]
  373     void* contextPtr
  374         ///< [IN]
  375 );
  376 
  377 //--------------------------------------------------------------------------------------------------
  378 /**
  379  * Remove handler function for EVENT 'le_wifiClient_NewEvent'
  380  */
  381 //--------------------------------------------------------------------------------------------------
  382 void le_wifiClient_RemoveNewEventHandler
  383 (
  384     le_wifiClient_NewEventHandlerRef_t handlerRef
  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 //--------------------------------------------------------------------------------------------------
  399 le_result_t le_wifiClient_Start
  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 //--------------------------------------------------------------------------------------------------
  415 le_result_t le_wifiClient_Stop
  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 //--------------------------------------------------------------------------------------------------
  430 le_result_t le_wifiClient_Scan
  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 //--------------------------------------------------------------------------------------------------
  445 le_wifiClient_AccessPointRef_t le_wifiClient_GetFirstAccessPoint
  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 //--------------------------------------------------------------------------------------------------
  461 le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint
  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 //--------------------------------------------------------------------------------------------------
  475 int16_t le_wifiClient_GetSignalStrength
  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 //--------------------------------------------------------------------------------------------------
  491 le_result_t le_wifiClient_GetBssid
  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 //--------------------------------------------------------------------------------------------------
  512 le_result_t le_wifiClient_GetSsid
  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 //--------------------------------------------------------------------------------------------------
  535 le_result_t le_wifiClient_SetPassphrase
  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 //--------------------------------------------------------------------------------------------------
  555 le_result_t le_wifiClient_SetPreSharedKey
  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 //--------------------------------------------------------------------------------------------------
  574 le_result_t le_wifiClient_SetSecurityProtocol
  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 //--------------------------------------------------------------------------------------------------
  594 le_result_t le_wifiClient_SetUserCredentials
  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 //--------------------------------------------------------------------------------------------------
  613 le_result_t le_wifiClient_SetWepKey
  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 //--------------------------------------------------------------------------------------------------
  636 le_result_t le_wifiClient_SetHiddenNetworkAttribute
  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 //--------------------------------------------------------------------------------------------------
  655 le_wifiClient_AccessPointRef_t le_wifiClient_Create
  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 //--------------------------------------------------------------------------------------------------
  674 le_result_t le_wifiClient_Delete
  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 //--------------------------------------------------------------------------------------------------
  693 le_result_t le_wifiClient_Connect
  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 //--------------------------------------------------------------------------------------------------
  708 le_result_t le_wifiClient_Disconnect
  709 (
  710     void
  711 );
  712 
  713 #endif // LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
le_wifiClient_NewEventHandlerRef_t
struct le_wifiClient_NewEventHandler * le_wifiClient_NewEventHandlerRef_t
Definition: le_wifiClient_interface.h:345
le_wifiClient_GetNextAccessPoint
le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint(void)
le_wifiClient_DisconnectHandler_t
void(* le_wifiClient_DisconnectHandler_t)(void *)
Definition: le_wifiClient_interface.h:213
le_wifiClient_ConnectService
void le_wifiClient_ConnectService(void)
le_wifiClient_GetBssid
le_result_t le_wifiClient_GetBssid(le_wifiClient_AccessPointRef_t accessPointRef, char *bssid, size_t bssidSize)
le_wifiClient_SetUserCredentials
le_result_t le_wifiClient_SetUserCredentials(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL userName, const char *LE_NONNULL password)
le_wifiClient_GetSsid
le_result_t le_wifiClient_GetSsid(le_wifiClient_AccessPointRef_t accessPointRef, uint8_t *ssidPtr, size_t *ssidSizePtr)
le_result_t
le_result_t
Definition: le_basics.h:35
le_wifiClient_Start
le_result_t le_wifiClient_Start(void)
le_wifiDefs_interface.h
LE_WIFICLIENT_EVENT_SCAN_DONE
WiFi Scan result for available Access Points available. 
Definition: le_wifiClient_interface.h:309
le_wifiClient_Stop
le_result_t le_wifiClient_Stop(void)
LE_WIFICLIENT_EVENT_DISCONNECTED
WiFi Client Disconnected. 
Definition: le_wifiClient_interface.h:307
le_wifiClient_GetSignalStrength
int16_t le_wifiClient_GetSignalStrength(le_wifiClient_AccessPointRef_t accessPointRef)
le_wifiClient_SetSecurityProtocol
le_result_t le_wifiClient_SetSecurityProtocol(le_wifiClient_AccessPointRef_t accessPointRef, le_wifiClient_SecurityProtocol_t securityProtocol)
LE_WIFICLIENT_SECURITY_NONE
no security. 
Definition: le_wifiClient_interface.h:324
le_wifiClient_SetServerDisconnectHandler
void le_wifiClient_SetServerDisconnectHandler(le_wifiClient_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_wifiClient_Event_t
le_wifiClient_Event_t
Definition: le_wifiClient_interface.h:303
le_wifiClient_SecurityProtocol_t
le_wifiClient_SecurityProtocol_t
Definition: le_wifiClient_interface.h:322
le_wifiClient_SetWepKey
le_result_t le_wifiClient_SetWepKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL wepKey)
LE_WIFICLIENT_SECURITY_WPA2_PSK_PERSONAL
Using WPA2. 
Definition: le_wifiClient_interface.h:330
le_wifiClient_SetHiddenNetworkAttribute
le_result_t le_wifiClient_SetHiddenNetworkAttribute(le_wifiClient_AccessPointRef_t accessPointRef, bool hidden)
le_wifiClient_Delete
le_result_t le_wifiClient_Delete(le_wifiClient_AccessPointRef_t accessPointRef)
LE_WIFICLIENT_EVENT_CONNECTED
WiFi Client Connected. 
Definition: le_wifiClient_interface.h:305
le_wifiClient_SetPreSharedKey
le_result_t le_wifiClient_SetPreSharedKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PreSharedKey)
LE_WIFICLIENT_SECURITY_WPA_PSK_PERSONAL
Using WPA. 
Definition: le_wifiClient_interface.h:328
le_wifiClient_Disconnect
le_result_t le_wifiClient_Disconnect(void)
le_wifiClient_RemoveNewEventHandler
void le_wifiClient_RemoveNewEventHandler(le_wifiClient_NewEventHandlerRef_t handlerRef)
legato.h
le_wifiClient_Create
le_wifiClient_AccessPointRef_t le_wifiClient_Create(const uint8_t *SsidPtr, size_t SsidSize)
LE_WIFICLIENT_SECURITY_WPA_EAP_PEAP0_ENTERPRISE
Using WPA Enterprise. 
Definition: le_wifiClient_interface.h:332
LE_WIFICLIENT_SECURITY_WPA2_EAP_PEAP0_ENTERPRISE
Using WPA2 Enterprise. 
Definition: le_wifiClient_interface.h:334
le_wifiClient_NewEventHandlerFunc_t
void(* le_wifiClient_NewEventHandlerFunc_t)(le_wifiClient_Event_t event, void *contextPtr)
Definition: le_wifiClient_interface.h:354
le_wifiClient_TryConnectService
le_result_t le_wifiClient_TryConnectService(void)
LE_WIFICLIENT_EVENT_SCAN_FAILED
WiFi Scan failed. 
Definition: le_wifiClient_interface.h:311
le_wifiClient_AccessPointRef_t
struct le_wifiClient_AccessPoint * le_wifiClient_AccessPointRef_t
Definition: le_wifiClient_interface.h:295
le_wifiClient_Scan
le_result_t le_wifiClient_Scan(void)
le_wifiClient_Connect
le_result_t le_wifiClient_Connect(le_wifiClient_AccessPointRef_t accessPointRef)
le_wifiClient_DisconnectService
void le_wifiClient_DisconnectService(void)
le_wifiClient_GetFirstAccessPoint
le_wifiClient_AccessPointRef_t le_wifiClient_GetFirstAccessPoint(void)
le_wifiClient_AddNewEventHandler
le_wifiClient_NewEventHandlerRef_t le_wifiClient_AddNewEventHandler(le_wifiClient_NewEventHandlerFunc_t handlerPtr, void *contextPtr)
le_wifiClient_SetPassphrase
le_result_t le_wifiClient_SetPassphrase(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PassPhrase)
LE_WIFICLIENT_SECURITY_WEP
Using WEP. 
Definition: le_wifiClient_interface.h:326