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 }
  312 le_wifiClient_Event_t;
  313 
  314 
  315 //--------------------------------------------------------------------------------------------------
  316 /**
  317  * WiFi Client Security Protocol for connection
  318  */
  319 //--------------------------------------------------------------------------------------------------
  320 typedef enum
  321 {
  322     LE_WIFICLIENT_SECURITY_NONE = 0,
  323         ///< no security.
  324     LE_WIFICLIENT_SECURITY_WEP = 1,
  325         ///< Using WEP.
  326     LE_WIFICLIENT_SECURITY_WPA_PSK_PERSONAL = 2,
  327         ///< Using WPA
  328     LE_WIFICLIENT_SECURITY_WPA2_PSK_PERSONAL = 3,
  329         ///< Using WPA2
  330     LE_WIFICLIENT_SECURITY_WPA_EAP_PEAP0_ENTERPRISE = 4,
  331         ///< Using WPA Enterprise
  332     LE_WIFICLIENT_SECURITY_WPA2_EAP_PEAP0_ENTERPRISE = 5
  333         ///< Using WPA2 Enterprise
  334 }
  335 le_wifiClient_SecurityProtocol_t;
  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 //--------------------------------------------------------------------------------------------------
  351 typedef void (*le_wifiClient_NewEventHandlerFunc_t)
  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 //--------------------------------------------------------------------------------------------------
  367 le_wifiClient_NewEventHandlerRef_t le_wifiClient_AddNewEventHandler
  368 (
  369     le_wifiClient_NewEventHandlerFunc_t handlerPtr,
  370         ///< [IN]
  371     void* contextPtr
  372         ///< [IN]
  373 );
  374 
  375 //--------------------------------------------------------------------------------------------------
  376 /**
  377  * Remove handler function for EVENT 'le_wifiClient_NewEvent'
  378  */
  379 //--------------------------------------------------------------------------------------------------
  380 void le_wifiClient_RemoveNewEventHandler
  381 (
  382     le_wifiClient_NewEventHandlerRef_t handlerRef
  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 //--------------------------------------------------------------------------------------------------
  397 le_result_t le_wifiClient_Start
  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 //--------------------------------------------------------------------------------------------------
  413 le_result_t le_wifiClient_Stop
  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 //--------------------------------------------------------------------------------------------------
  428 le_result_t le_wifiClient_Scan
  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 //--------------------------------------------------------------------------------------------------
  443 le_wifiClient_AccessPointRef_t le_wifiClient_GetFirstAccessPoint
  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 //--------------------------------------------------------------------------------------------------
  459 le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint
  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 //--------------------------------------------------------------------------------------------------
  473 int16_t le_wifiClient_GetSignalStrength
  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 //--------------------------------------------------------------------------------------------------
  489 le_result_t le_wifiClient_GetBssid
  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 //--------------------------------------------------------------------------------------------------
  510 le_result_t le_wifiClient_GetSsid
  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 //--------------------------------------------------------------------------------------------------
  533 le_result_t le_wifiClient_SetPassphrase
  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 //--------------------------------------------------------------------------------------------------
  553 le_result_t le_wifiClient_SetPreSharedKey
  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 //--------------------------------------------------------------------------------------------------
  572 le_result_t le_wifiClient_SetSecurityProtocol
  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 //--------------------------------------------------------------------------------------------------
  592 le_result_t le_wifiClient_SetUserCredentials
  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 //--------------------------------------------------------------------------------------------------
  611 le_result_t le_wifiClient_SetWepKey
  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 //--------------------------------------------------------------------------------------------------
  634 le_result_t le_wifiClient_SetHiddenNetworkAttribute
  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 //--------------------------------------------------------------------------------------------------
  653 le_wifiClient_AccessPointRef_t le_wifiClient_Create
  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 //--------------------------------------------------------------------------------------------------
  672 le_result_t le_wifiClient_Delete
  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 //--------------------------------------------------------------------------------------------------
  691 le_result_t le_wifiClient_Connect
  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 //--------------------------------------------------------------------------------------------------
  706 le_result_t le_wifiClient_Disconnect
  707 (
  708     void
  709 );
  710 
  711 #endif // LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
le_wifiClient_ConnectService
void le_wifiClient_ConnectService(void)
le_wifiClient_SecurityProtocol_t
le_wifiClient_SecurityProtocol_t
Definition: le_wifiClient_interface.h:320
le_wifiClient_Event_t
le_wifiClient_Event_t
Definition: le_wifiClient_interface.h:303
le_wifiClient_DisconnectHandler_t
void(* le_wifiClient_DisconnectHandler_t)(void *)
Definition: le_wifiClient_interface.h:213
LE_WIFICLIENT_EVENT_CONNECTED
WiFi Client Connected. 
Definition: le_wifiClient_interface.h:305
le_result_t
le_result_t
Definition: le_basics.h:35
le_wifiClient_RemoveNewEventHandler
void le_wifiClient_RemoveNewEventHandler(le_wifiClient_NewEventHandlerRef_t handlerRef)
le_wifiClient_Start
le_result_t le_wifiClient_Start(void)
le_wifiClient_DisconnectService
void le_wifiClient_DisconnectService(void)
le_wifiClient_TryConnectService
le_result_t le_wifiClient_TryConnectService(void)
LE_WIFICLIENT_EVENT_DISCONNECTED
WiFi Client Disconnected. 
Definition: le_wifiClient_interface.h:307
le_wifiDefs_interface.h
le_wifiClient_SetPassphrase
le_result_t le_wifiClient_SetPassphrase(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PassPhrase)
le_wifiClient_NewEventHandlerRef_t
struct le_wifiClient_NewEventHandler * le_wifiClient_NewEventHandlerRef_t
Definition: le_wifiClient_interface.h:343
le_wifiClient_Disconnect
le_result_t le_wifiClient_Disconnect(void)
LE_WIFICLIENT_SECURITY_WPA_EAP_PEAP0_ENTERPRISE
Using WPA Enterprise. 
Definition: le_wifiClient_interface.h:330
le_wifiClient_AccessPointRef_t
struct le_wifiClient_AccessPoint * le_wifiClient_AccessPointRef_t
Definition: le_wifiClient_interface.h:295
le_wifiClient_Delete
le_result_t le_wifiClient_Delete(le_wifiClient_AccessPointRef_t accessPointRef)
LE_WIFICLIENT_SECURITY_NONE
no security. 
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_SetHiddenNetworkAttribute
le_result_t le_wifiClient_SetHiddenNetworkAttribute(le_wifiClient_AccessPointRef_t accessPointRef, bool hidden)
LE_WIFICLIENT_SECURITY_WPA2_PSK_PERSONAL
Using WPA2. 
Definition: le_wifiClient_interface.h:328
le_wifiClient_SetServerDisconnectHandler
void le_wifiClient_SetServerDisconnectHandler(le_wifiClient_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_wifiClient_GetFirstAccessPoint
le_wifiClient_AccessPointRef_t le_wifiClient_GetFirstAccessPoint(void)
legato.h
le_wifiClient_AddNewEventHandler
le_wifiClient_NewEventHandlerRef_t le_wifiClient_AddNewEventHandler(le_wifiClient_NewEventHandlerFunc_t handlerPtr, void *contextPtr)
le_wifiClient_GetBssid
le_result_t le_wifiClient_GetBssid(le_wifiClient_AccessPointRef_t accessPointRef, char *bssid, size_t bssidSize)
LE_WIFICLIENT_SECURITY_WPA2_EAP_PEAP0_ENTERPRISE
Using WPA2 Enterprise. 
Definition: le_wifiClient_interface.h:332
LE_WIFICLIENT_SECURITY_WEP
Using WEP. 
Definition: le_wifiClient_interface.h:324
LE_WIFICLIENT_SECURITY_WPA_PSK_PERSONAL
Using WPA. 
Definition: le_wifiClient_interface.h:326
le_wifiClient_GetNextAccessPoint
le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint(void)
le_wifiClient_Connect
le_result_t le_wifiClient_Connect(le_wifiClient_AccessPointRef_t accessPointRef)
le_wifiClient_GetSsid
le_result_t le_wifiClient_GetSsid(le_wifiClient_AccessPointRef_t accessPointRef, uint8_t *ssidPtr, size_t *ssidSizePtr)
le_wifiClient_SetSecurityProtocol
le_result_t le_wifiClient_SetSecurityProtocol(le_wifiClient_AccessPointRef_t accessPointRef, le_wifiClient_SecurityProtocol_t securityProtocol)
le_wifiClient_Create
le_wifiClient_AccessPointRef_t le_wifiClient_Create(const uint8_t *SsidPtr, size_t SsidSize)
le_wifiClient_SetPreSharedKey
le_result_t le_wifiClient_SetPreSharedKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PreSharedKey)
le_wifiClient_Scan
le_result_t le_wifiClient_Scan(void)
le_wifiClient_NewEventHandlerFunc_t
void(* le_wifiClient_NewEventHandlerFunc_t)(le_wifiClient_Event_t event, void *contextPtr)
Definition: le_wifiClient_interface.h:352
le_wifiClient_Stop
le_result_t le_wifiClient_Stop(void)
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_GetSignalStrength
int16_t le_wifiClient_GetSignalStrength(le_wifiClient_AccessPointRef_t accessPointRef)
LE_WIFICLIENT_EVENT_SCAN_DONE
WiFi Scan result for available Access Points available. 
Definition: le_wifiClient_interface.h:309