le_mrc_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_mrc Modem Radio Control
   14  *
   15  * @ref le_mrc_interface.h "API Reference"
   16  *
   17  * <HR>
   18  *
   19  * The Modem Radio Control (MRC) APIs is used to control cellular network environments.
   20  *
   21  * It's important for many M2M apps to know details about cellular network environments (like
   22  * network registration and signal quality).
   23  * It allows you to limit some M2M services based on the reliability of the network environment, and
   24  * provides information to control power consumption (power on or shutdown the radio module).
   25  *
   26  * @section le_mrc_binding IPC interfaces binding
   27  *
   28  * All the functions of this API are provided by the @b modemService service.
   29  *
   30  * Here's a code sample binding to modem services:
   31  * @verbatim
   32    bindings:
   33    {
   34       clientExe.clientComponent.le_mrc -> modemService.le_mrc
   35    }
   36    @endverbatim
   37  *
   38  * @section le_mrc_power Radio Power Management
   39  * le_mrc_SetRadioPower() API allows the application to power up or shutdown the radio module.
   40  *
   41  * le_mrc_GetRadioPower() API displays radio module power state.
   42  *
   43  * A sample code can be seen in the following page:
   44  * - @subpage c_mrcRadioPower
   45  *
   46  * @section le_mrc_configuration Radio Configuration preferences
   47  *
   48  * The following functions let you configure and retrieve the radio configuration preferences:
   49  * le_mrc_SetAutomaticRegisterMode(), le_mrc_SetManualRegisterMode() and le_mrc_GetRegisterMode()
   50  * let you set/get the selected Scan mode.
   51  *
   52  * le_mrc_SetBandPreferences(), le_mrc_GetBandPreferences() let you set/get the 2G/3G band
   53  * preferences by using a bit mask built with @c le_mrc_BandBitMask_t
   54  *
   55  * The 2G/3G band preferences can be:
   56  * - Band-Class-0-A-System
   57  * - Band-Class-0-B-System
   58  * - Band-Class-1-All-Blocks
   59  * - Band-Class-2-Placeholder
   60  * - Band-Class-3-A-System
   61  * - Band-Class-4-All-Blocks
   62  * - Band-Class-5-All-Blocks
   63  * - Band-Class-6
   64  * - Band-Class-7
   65  * - Band-Class-8
   66  * - Band-Class-9
   67  * - Band-Class-10
   68  * - Band-Class-11
   69  * - Band-Class-12
   70  * - Band-Class-13
   71  * - Band-Class-14
   72  * - Band-Class-15
   73  * - Band-Class-16
   74  * - Band-Class-17
   75  * - Band-Class-18
   76  * - Band-Class-19
   77  * - GSM-DCS-1800
   78  * - E-GSM-900 (for Extended GSM 900 band)
   79  * - Primary-GSM-900
   80  * - GSM-450
   81  * - GSM-480
   82  * - GSM-750
   83  * - GSM-850
   84  * - GSMR-900 (for GSM Railways GSM 900 band)
   85  * - GSM-PCS-1900
   86  * - WCDMA-EU-J-CH-IMT-2100 (for WCDMA Europe, Japan, and China IMT 2100 band)
   87  * - WCDMA-US-PCS-1900 (for WCDMA U.S. PCS 1900 band)
   88  * - WCDMA-EU-CH-DCS-1800 (for WCDMA Europe and China DCS 1800 band)
   89  * - WCDMA-US-1700 (for WCDMA U.S. 1700 band)
   90  * - WCDMA-US-850 (for WCDMA U.S. 850 band)
   91  * - WCDMA-J-800 (for WCDMA Japan 800 band)
   92  * - WCDMA-EU-2600 (for WCDMA Europe 2600 band)
   93  * - WCDMA-EU-J-900 (for WCDMA Europe and Japan 900 band)
   94  * - WCDMA-J-1700 (for WCDMA Japan 1700 band)
   95  *
   96  * le_mrc_SetLteBandPreferences(), le_mrc_GetLteBandPreferences() let you set/get the LTE band
   97  * preferences by using a bit mask built with @c le_mrc_LteBandBitMask_t.
   98  *
   99  * The LTE band preferences can be 0 to 43 except 15, 16, 22, 23, and 26 to 32.
  100  *
  101  * le_mrc_SetTdScdmaBandPreferences(), le_mrc_GetTdScdmaBandPreferences() let you set/get the
  102  * TD-SCDMA band preferences by using a bit mask built with @c le_mrc_TdScdmaBandBitMask_t
  103  *
  104  * The TD-SCDMA band preferences can be 'A' to 'F'
  105  *
  106  * @warning Ensure to check the supported preferences for your specific platform.
  107  *
  108  * le_mrc_AddPreferredOperator() , le_mrc_RemovePreferredOperator() to add/remove a preferred
  109  * operator by specifying the MCC/MNC and the Radio Access Technology.
  110  *
  111  * le_mrc_GetPreferredOperatorsList(), le_mrc_GetFirstPreferredOperator(),
  112  * le_mrc_GetNextPreferredOperator(), le_mrc_DeletePreferredOperatorsList(),
  113  * le_mrc_GetPreferredOperatorDetails() let you retrieve a list of the selected preferred
  114  * operators and get their details.
  115  *
  116  * A sample code can be seen in the following page:
  117  * - @subpage c_mrcRadioConfigurationPreferences
  118  *
  119  * @section le_mrc_NetworkRejectHandler Report Network Reject Indication
  120  *
  121  * The application can register a handler function to report network reject with MNC/MCC code and
  122  * the Radio Access Technology using le_mrc_AddNetworkRejectHandler() API.
  123  *
  124  * le_mrc_RemoveNetworkRejectHandler() API uninstalls the handler function.
  125  *
  126  * @section le_mrc_capabilities Radio Capabilities
  127  *
  128  * le_mrc_GetBandCapabilities() let you get the 2G/3G band capabilities by retrieving a bit mask
  129  * built with @c le_mrc_BandBitMask_t
  130  *
  131  * le_mrc_GetLteBandCapabilities() let you get the LTE band capabilities by retrieving a bit mask
  132  * built with @c le_mrc_LteBandBitMask_t
  133  *
  134  * le_mrc_GetTdScdmaBandCapabilities() let you get the TD-SCDMA band capabilities by retrieving
  135  * a bit mask built with @c le_mrc_TdScdmaBandBitMask_t
  136  *
  137  * A sample code can be seen in the following page:
  138  * - @subpage c_mrcBandCapabilities
  139  *
  140  * @section le_mrc_rat Radio Access Technology (RAT)
  141  * le_mrc_GetRadioAccessTechInUse() API retrieves the current active Radio Access Technology (RAT).
  142  * @note  The API returns the RAT only if the device is registered on the network.
  143  *
  144  * The application can register a handler function to retrieve the Radio Access Technology each time
  145  * the RAT changes.
  146  *
  147  * le_mrc_AddRatChangeHandler() API installs a RAT change handler.
  148  *
  149  * le_mrc_RemoveRatChangeHandler() API uninstalls the handler function.
  150  *
  151  * le_mrc_SetRatPreferences(), le_mrc_GetRatPreferences() let you set/get the Radio Access
  152  * Technology preferences by using a bit mask built with @c le_mrc_RatBitMask_t.
  153  *
  154  * The Radio Access Technology preferences can be:
  155  * - CDMA (CDMA2000-1X + CDMA2000-HRPD)
  156  * - GSM
  157  * - UMTS (UMTS)
  158  * - TDSCDMA (TD-SCDMA)
  159  * - LTE
  160  *
  161  * @note LE_MRC_BITMASK_RAT_ALL value can be used to select the RAT in automatic mode.
  162  *
  163  * A sample code can be seen in the following page:
  164  * - @subpage c_mrcRAT
  165  *
  166  * @section le_mrc_registration Network Registration
  167  * le_mrc_GetNetRegState() API retrieves the radio module network registration status.
  168  *
  169  * The application can register a handler function to retrieve the registration status each time the
  170  * registration state changes.
  171  *
  172  * le_mrc_AddNetRegStateEventHandler() API installs a registration state handler.
  173  *
  174  * le_mrc_RemoveNetRegStateEventHandler() API uninstalls the handler function.
  175  * @note If only one handler is registered, the le_mrc_RemoveNetRegStateHandler() API
  176  *       resets the registration mode to its original value before any handler functions were added.
  177  *
  178  * le_mrc_SetManualRegisterMode() API registers on a cellular network.
  179  *
  180  * Call le_mrc_SetManualRegisterModeAsync() function to set the manual registration mode
  181  *  asynchronously. The function is not blocking. The response will be returned with the
  182  *  @c le_mrc_ManualSelectionHandlerFunc_t handler function.
  183  *
  184  * When the network registration fails, the platform specific network registration error code can
  185  * be known by using le_mrc_GetPlatformSpecificRegistrationErrorCode() API.
  186  * Please refer to @ref platformConstraintsSpecificErrorCodes for platform specific
  187  * registration error code description.
  188  *
  189  * A sample code can be seen in the following page:
  190  * - @subpage c_mrcNetworkRegistration
  191  *
  192  * @section le_mrc_service Packet services state
  193  *
  194  * le_mrc_GetPacketSwitchedState() API retrieves the current Packet Switched state
  195  * @ref le_mrc_NetRegState_t.
  196  *
  197  * The Packet Switched services state can be:
  198  * - NONE
  199  * - HOME
  200  * - ROAMING
  201  *
  202  * The application can register a handler function to retrieve the Packet
  203  * Switched state each time the service state changes.
  204  *
  205  * le_mrc_AddPacketSwitchedChangeHandler() API installs a Packet Switched state handler.
  206  *
  207  * le_mrc_RemovePacketSwitchedChangeHandler() API uninstalls the handler function.
  208  *
  209  * A sample code can be seen in the following page:
  210  * - @subpage c_mrcGetService
  211  *
  212  * @section le_mrc_signal Signal Quality
  213  *
  214  * le_mrc_GetSignalQual() retrieves the received signal strength details.
  215  *
  216  * You must call le_mrc_MeasureSignalMetrics() to measure the signal metrics of the serving cell
  217  * (aka the 'serving' cell). It returns a reference of le_mrc_MetricsRef_t type.
  218  *
  219  * When the signal metrics are no longer needed, you must call le_mrc_DeleteSignalMetrics() to free
  220  * all allocated ressources associated with the Metrics object.
  221  *
  222  * le_mrc_GetRatOfSignalMetrics() returns the Radio Access Technology of the signal measures.
  223  *
  224  * le_mrc_GetGsmSignalMetrics() the signal strength in dBm and the bit error rate measured on GSM
  225  * network.
  226  *
  227  * le_mrc_GetUmtsSignalMetrics() returns the signal metrics measured on UMTS or TD-SCDMA networks.
  228  *
  229  * le_mrc_GetLteSignalMetrics() returns the signal metrics measured on LTE network.
  230  *
  231  * le_mrc_GetCdmaSignalMetrics() returns the signal metrics measured on CDMA network.
  232  *
  233  * The application can register a handler function to get notifications when the signal strength
  234  * changes of a certain threshold value.
  235  *
  236  * le_mrc_AddSignalStrengthChangeHandler() API installs a signal strength change handler.
  237  * The RAT, the lower-range and the upper-range thresholds must be passed as input parameters. These
  238  * parameters are updated each time the function is called, the previous thresholds are replaced by
  239  * the new ones if the function is called with the same RAT. The event is notified when we cross the
  240  * range limits in both direction.
  241  *
  242  * @warning A fatal error will be thrown if the RAT is not valid and the
  243  *  le_mrc_AddSignalStrengthChangeHandler function won't return.
  244  *
  245  * le_mrc_RemoveSignalStrengthChangeHandler() API uninstalls the handler function.
  246  *
  247  * le_mrc_SetSignalStrengthIndThresholds() API changes or sets new thresholds.
  248  *
  249  * le_mrc_SetSignalStrengthIndDelta() API sets a signal strength indication delta value for a
  250  * specific RAT. The event is notified when the delta range is crossed in both direction.
  251  *
  252  * A sample code can be seen in the following page:
  253  * - @subpage c_mrcQuality
  254  *
  255  * @section le_mrc_location Serving cell's location information
  256  *
  257  * le_mrc_GetServingCellId() retrieves the the serving Cell Identifier.
  258  *
  259  * le_mrc_GetServingCellLocAreaCode() retrieves the Location Area Code of the serving cell.
  260  *
  261  * le_mrc_GetServingCellLteTracAreaCode() retrieves the the Tracking Area Code of the serving cell
  262  * (LTE only).
  263  *
  264  * A sample code can be seen in the following page:
  265  * - @subpage c_mrcLocationinformation
  266  *
  267  * @section le_mrc_network_information Current Network Information
  268  * le_mrc_GetCurrentNetworkName() retrieves the Current Network Name.
  269  * le_mrc_GetCurrentNetworkMccMnc() retrieves the Current Network PLMN information.
  270  *
  271  * A sample code can be seen in the following page:
  272  * - @subpage c_mrcGetCurrentNetwork
  273  *
  274  * @section le_mrc_networkScan Network Scan
  275  *
  276  * Call le_mrc_PerformCellularNetworkScan() to fill a list of all network in sight.
  277  * You can go through all Scan Information by calling le_mrc_GetFirstCellularNetworkScan() and
  278  * le_mrc_GetNextCellularNetworkScan().
  279  *
  280  * Call le_mrc_PerformCellularNetworkScanAsync() to start a network scan asynchronously. The
  281  * function is not blocking. The scan list reference will be returned with the handler function
  282  * response (@c le_mrc_CellularNetworkScanHandlerFunc_t).
  283  *
  284  * For each Scan Information, you can call:
  285  *
  286  *  - le_mrc_GetCellularNetworkMccMnc() to have the operator code.
  287  *  - le_mrc_GetCellularNetworkName() to get the operator name.
  288  *  - le_mrc_GetCellularNetworkRat() to get the radio access technology.
  289  *  - le_mrc_IsCellularNetworkInUse() to check if this is currently in use by the network.
  290  *  - le_mrc_IsCellularNetworkAvailable() to check if this is available.
  291  *  - le_mrc_IsCellularNetworkHome() to check if this is in home status.
  292  *  - le_mrc_IsCellularNetworkForbidden() to check if this is forbidden by the network.
  293  *
  294  * le_mrc_DeleteCellularNetworkScan() should be called when you do not need the list anymore.
  295  *
  296  * A sample code can be seen in the following page:
  297  * - @subpage c_mrcNetworkScan
  298  *
  299  * @section le_mrc_ngbr Neighboring Cells Information
  300  *
  301  * @warning The following functions do not apply to CDMA network.
  302  *
  303  * You must call le_mrc_GetNeighborCellsInfo() to retrieve the neighboring cells
  304  * information. It returns a reference of le_mrc_NeighborCellsRef_t type.
  305  *
  306  * When the neighboring cells information is no longer needed, you must call
  307  * le_mrc_DeleteNeighborCellsInfo() to free all allocated resources associated with the
  308  * object.
  309  *
  310  * Then, you can use the following function to get the information:
  311  * - le_mrc_GetFirstNeighborCellInfo() and le_mrc_GetFirstNeighborCellInfo() allow to go among
  312  *   the single cell information retrieved with le_mrc_GetNeighborCellsInfo(). These two functions
  313  *   return a reference of le_mrc_CellInfoRef_t type.
  314  * - le_mrc_GetNeighborCellId() gets the identifier of the cell specified with the
  315  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT32_MAX value is
  316  *   returned if the value is not available.
  317  * - le_mrc_GetNeighborCellLocAreaCode() gets the location area code of the cell specified with the
  318  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT16_MAX value is
  319  *   returned if the value is not available.
  320  * - le_mrc_GetNeighborCellRxLevel() gets the signal strength (in dBm) of the cell specified with
  321  *   the le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT).
  322  * - le_mrc_GetNeighborCellRat() gets the Radio Access Technology of the cell specified with
  323  *   the le_mrc_CellInfoRef_t parameter.
  324  * - le_mrc_GetNeighborCellUmtsEcIo() gets the Ec/Io (the received energy per chip divided by the
  325  *   power density in the band measured in dBm on the primary CPICH channel of serving cell) of the
  326  *   cell specified with the le_mrc_CellInfoRef_t parameter.
  327  * - le_mrc_GetNeighborCellLteIntraFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  328  *   specified with the le_mrc_CellInfoRef_t parameter.
  329  * - le_mrc_GetNeighborCellLteInterFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  330  *   specified with the le_mrc_CellInfoRef_t parameter.
  331  *
  332  * A sample code can be seen in the following page:
  333  * - @subpage c_mrcNeighborCells
  334  *
  335  * @section le_mrc_jamming Jamming detection
  336  *
  337  * The jamming detection algorithm is based on power measurements and cell synchronization actions
  338  * performed during a GSM network scan procedure.
  339  * During this procedure some intermediate results are reported, that allows user to take some
  340  * preventive actions if necessary.
  341  * This result is reported as a jammed state probability. See @ref le_mrc_JammingStatus_t
  342  * enumeration for probability description.
  343  * Each time the jamming status changes during the scan procedure, it is reported to the user.
  344  * See @ref le_mrc_JammingReport_t enumeration for details.
  345  *
  346  * The jamming status is reported:
  347  * - In an unsolicited way, each time the protocol stack initiates a scan for PLMN selection or
  348  * reselection.
  349  * - On user demand, when a user PLMN scan is performed.
  350  *
  351  * Call le_mrc_StartJammingDetection() to launch jamming monitoring.
  352  * By registering a handler by calling le_mrc_AddJammingDetectionEventHandler(), the notification
  353  * on jamming detection can be sent to the registered application.
  354  *
  355  * For each jamming detection monitoring, the following APIs can be called:
  356  * - le_mrc_StartJammingDetection() to start the jamming monitoring.
  357  * - le_mrc_StopJammingDetection() to stop the jamming monitoring.
  358  * - le_mrc_AddJammingDetectionEventHandler() to register an event handler.
  359  * - le_mrc_RemoveJammingDetectionEventHandler() to remove an event handler.
  360  *
  361  * <HR>
  362  *
  363  * Copyright (C) Sierra Wireless Inc.
  364  */
  365 /**
  366  * @page c_mrcRadioPower Sample code for Radio Power Management
  367  *
  368  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Radio Power
  369  */
  370 /**
  371  * @page c_mrcRadioConfigurationPreferences Sample code for Radio Configuration Preferences
  372  *
  373  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Preferences
  374  *
  375  */
  376 /**
  377  * @page c_mrcRAT Sample code for Radio Access Technology
  378  *
  379  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT in Use
  380  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT Preferences
  381  *
  382  */
  383 /**
  384  * @page c_mrcNetworkRegistration Sample code for Network Registration
  385  *
  386  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Register
  387  *
  388  */
  389 /**
  390  * @page c_mrcQuality Sample code for Signal Quality
  391  *
  392  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Signal Quality
  393  *
  394  */
  395 /**
  396  * @page c_mrcLocationinformation Sample code for Location information
  397  *
  398  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Loc information
  399  *
  400  */
  401 /**
  402  * @page c_mrcBandCapabilities Sample code for Band Capabilities
  403  *
  404  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Capabilities
  405  *
  406  */
  407 /**
  408  * @page c_mrcGetCurrentNetwork Sample code for Get Current Network Information
  409  *
  410  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Get Network
  411  *
  412  */
  413 /**
  414  * @page c_mrcNetworkScan Sample code for Network Scan
  415  *
  416  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Network Scan
  417  *
  418  */
  419 /**
  420  * @page c_mrcNeighborCells Sample code for Neighboring Cells Information
  421  *
  422  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Neighbor Cells
  423  *
  424  */
  425 /**
  426  * @page c_mrcGetService Sample code for Get the Current Packet Switched state
  427  *
  428  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Service State
  429  *
  430  */
  431 /**
  432  * @file le_mrc_interface.h
  433  *
  434  * Legato @ref c_mrc include file.
  435  *
  436  * Copyright (C) Sierra Wireless Inc.
  437  */
  438 
  439 #ifndef LE_MRC_INTERFACE_H_INCLUDE_GUARD
  440 #define LE_MRC_INTERFACE_H_INCLUDE_GUARD
  441 
  442 
  443 #include "legato.h"
  444 
  445 
  446 //--------------------------------------------------------------------------------------------------
  447 /**
  448  * Type for handler called when a server disconnects.
  449  */
  450 //--------------------------------------------------------------------------------------------------
  451 typedef void (*le_mrc_DisconnectHandler_t)(void *);
  452 
  453 //--------------------------------------------------------------------------------------------------
  454 /**
  455  *
  456  * Connect the current client thread to the service providing this API. Block until the service is
  457  * available.
  458  *
  459  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  460  * called before any other functions in this API.  Normally, ConnectService is automatically called
  461  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  462  *
  463  * This function is created automatically.
  464  */
  465 //--------------------------------------------------------------------------------------------------
  466 void le_mrc_ConnectService
  467 (
  468     void
  469 );
  470 
  471 //--------------------------------------------------------------------------------------------------
  472 /**
  473  *
  474  * Try to connect the current client thread to the service providing this API. Return with an error
  475  * if the service is not available.
  476  *
  477  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  478  * called before any other functions in this API.  Normally, ConnectService is automatically called
  479  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  480  *
  481  * This function is created automatically.
  482  *
  483  * @return
  484  *  - LE_OK if the client connected successfully to the service.
  485  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  486  *    bound.
  487  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  488  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  489  */
  490 //--------------------------------------------------------------------------------------------------
  491 le_result_t le_mrc_TryConnectService
  492 (
  493     void
  494 );
  495 
  496 //--------------------------------------------------------------------------------------------------
  497 /**
  498  * Set handler called when server disconnection is detected.
  499  *
  500  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  501  * to continue without exiting, it should call longjmp() from inside the handler.
  502  */
  503 //--------------------------------------------------------------------------------------------------
  504 void le_mrc_SetServerDisconnectHandler
  505 (
  506     le_mrc_DisconnectHandler_t disconnectHandler,
  507     void *contextPtr
  508 );
  509 
  510 //--------------------------------------------------------------------------------------------------
  511 /**
  512  *
  513  * Disconnect the current client thread from the service providing this API.
  514  *
  515  * Normally, this function doesn't need to be called. After this function is called, there's no
  516  * longer a connection to the service, and the functions in this API can't be used. For details, see
  517  * @ref apiFilesC_client.
  518  *
  519  * This function is created automatically.
  520  */
  521 //--------------------------------------------------------------------------------------------------
  522 void le_mrc_DisconnectService
  523 (
  524     void
  525 );
  526 
  527 
  528 //--------------------------------------------------------------------------------------------------
  529 /**
  530  * Mobile Country Code length
  531  */
  532 //--------------------------------------------------------------------------------------------------
  533 #define LE_MRC_MCC_LEN 3
  534 
  535 //--------------------------------------------------------------------------------------------------
  536 /**
  537  * Mobile Country Code length
  538  * One extra byte is added for the null character.
  539  */
  540 //--------------------------------------------------------------------------------------------------
  541 #define LE_MRC_MCC_BYTES 4
  542 
  543 //--------------------------------------------------------------------------------------------------
  544 /**
  545  * Mobile Network Code length
  546  */
  547 //--------------------------------------------------------------------------------------------------
  548 #define LE_MRC_MNC_LEN 3
  549 
  550 //--------------------------------------------------------------------------------------------------
  551 /**
  552  * Mobile Network Code length
  553  * One extra byte is added for the null character.
  554  */
  555 //--------------------------------------------------------------------------------------------------
  556 #define LE_MRC_MNC_BYTES 4
  557 
  558 //--------------------------------------------------------------------------------------------------
  559 /**
  560  * Cellular Network length.
  561  *
  562  */
  563 //--------------------------------------------------------------------------------------------------
  564 #define LE_MRC_NETWORK_NAME_MAX_LEN 100
  565 
  566 //--------------------------------------------------------------------------------------------------
  567 /**
  568  * 2G/3G Band Bit Mask (64 bits)
  569  */
  570 //--------------------------------------------------------------------------------------------------
  571 typedef enum
  572 {
  573     LE_MRC_BITMASK_BAND_CLASS_0_A_SYSTEM = 0x1,
  574     LE_MRC_BITMASK_BAND_CLASS_0_B_SYSTEM = 0x2,
  575     LE_MRC_BITMASK_BAND_CLASS_1_ALL_BLOCKS = 0x4,
  576     LE_MRC_BITMASK_BAND_CLASS_2_PLACEHOLDER = 0x8,
  577     LE_MRC_BITMASK_BAND_CLASS_3_A_SYSTEM = 0x10,
  578     LE_MRC_BITMASK_BAND_CLASS_4_ALL_BLOCKS = 0x20,
  579     LE_MRC_BITMASK_BAND_CLASS_5_ALL_BLOCKS = 0x40,
  580     LE_MRC_BITMASK_BAND_CLASS_6 = 0x80,
  581     LE_MRC_BITMASK_BAND_CLASS_7 = 0x100,
  582     LE_MRC_BITMASK_BAND_CLASS_8 = 0x200,
  583     LE_MRC_BITMASK_BAND_CLASS_9 = 0x400,
  584     LE_MRC_BITMASK_BAND_CLASS_10 = 0x800,
  585     LE_MRC_BITMASK_BAND_CLASS_11 = 0x1000,
  586     LE_MRC_BITMASK_BAND_CLASS_12 = 0x2000,
  587     LE_MRC_BITMASK_BAND_CLASS_14 = 0x4000,
  588     LE_MRC_BITMASK_BAND_CLASS_15 = 0x8000,
  589     LE_MRC_BITMASK_BAND_CLASS_16 = 0x10000,
  590     LE_MRC_BITMASK_BAND_CLASS_17 = 0x20000,
  591     LE_MRC_BITMASK_BAND_CLASS_18 = 0x40000,
  592     LE_MRC_BITMASK_BAND_CLASS_19 = 0x80000,
  593     LE_MRC_BITMASK_BAND_GSM_DCS_1800 = 0x100000,
  594     LE_MRC_BITMASK_BAND_EGSM_900 = 0x200000,
  595     LE_MRC_BITMASK_BAND_PRI_GSM_900 = 0x400000,
  596     LE_MRC_BITMASK_BAND_GSM_450 = 0x800000,
  597     LE_MRC_BITMASK_BAND_GSM_480 = 0x1000000,
  598     LE_MRC_BITMASK_BAND_GSM_750 = 0x2000000,
  599     LE_MRC_BITMASK_BAND_GSM_850 = 0x4000000,
  600     LE_MRC_BITMASK_BAND_GSMR_900 = 0x8000000,
  601     LE_MRC_BITMASK_BAND_GSM_PCS_1900 = 0x10000000,
  602     LE_MRC_BITMASK_BAND_WCDMA_EU_J_CH_IMT_2100 = 0x20000000,
  603     LE_MRC_BITMASK_BAND_WCDMA_US_PCS_1900 = 0x40000000,
  604     LE_MRC_BITMASK_BAND_WCDMA_EU_CH_DCS_1800 = 0x80000000,
  605     LE_MRC_BITMASK_BAND_WCDMA_US_1700 = 0x100000000,
  606     LE_MRC_BITMASK_BAND_WCDMA_US_850 = 0x200000000,
  607     LE_MRC_BITMASK_BAND_WCDMA_J_800 = 0x400000000,
  608     LE_MRC_BITMASK_BAND_WCDMA_EU_2600 = 0x800000000,
  609     LE_MRC_BITMASK_BAND_WCDMA_EU_J_900 = 0x1000000000,
  610     LE_MRC_BITMASK_BAND_WCDMA_J_1700 = 0x2000000000
  611 }
  612 le_mrc_BandBitMask_t;
  613 
  614 
  615 //--------------------------------------------------------------------------------------------------
  616 /**
  617  * LTE Band Bit Mask (32bits)
  618  *
  619  */
  620 //--------------------------------------------------------------------------------------------------
  621 typedef enum
  622 {
  623     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_1 = 0x1,
  624     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_2 = 0x2,
  625     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_3 = 0x4,
  626     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_4 = 0x8,
  627     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_5 = 0x10,
  628     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_6 = 0x20,
  629     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_7 = 0x40,
  630     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_8 = 0x80,
  631     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_9 = 0x100,
  632     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_10 = 0x200,
  633     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_11 = 0x400,
  634     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_12 = 0x800,
  635     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_13 = 0x1000,
  636     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_14 = 0x2000,
  637     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_17 = 0x4000,
  638     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_18 = 0x8000,
  639     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_19 = 0x10000,
  640     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_20 = 0x20000,
  641     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_21 = 0x40000,
  642     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_24 = 0x80000,
  643     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_25 = 0x100000,
  644     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_33 = 0x200000,
  645     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_34 = 0x400000,
  646     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_35 = 0x800000,
  647     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_36 = 0x1000000,
  648     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_37 = 0x2000000,
  649     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_38 = 0x4000000,
  650     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_39 = 0x8000000,
  651     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_40 = 0x10000000,
  652     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_41 = 0x20000000,
  653     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_42 = 0x40000000,
  654     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_43 = 0x80000000
  655 }
  656 le_mrc_LteBandBitMask_t;
  657 
  658 
  659 //--------------------------------------------------------------------------------------------------
  660 /**
  661  * TDSCDMA Band Bit Mask
  662  *
  663  */
  664 //--------------------------------------------------------------------------------------------------
  665 typedef enum
  666 {
  667     LE_MRC_BITMASK_TDSCDMA_BAND_A = 0x1,
  668     LE_MRC_BITMASK_TDSCDMA_BAND_B = 0x2,
  669     LE_MRC_BITMASK_TDSCDMA_BAND_C = 0x4,
  670     LE_MRC_BITMASK_TDSCDMA_BAND_D = 0x8,
  671     LE_MRC_BITMASK_TDSCDMA_BAND_E = 0x10,
  672     LE_MRC_BITMASK_TDSCDMA_BAND_F = 0x20
  673 }
  674 le_mrc_TdScdmaBandBitMask_t;
  675 
  676 
  677 //--------------------------------------------------------------------------------------------------
  678 /**
  679  * Reference type for referring to MRC Scan Information objects.
  680  */
  681 //--------------------------------------------------------------------------------------------------
  682 typedef struct le_mrc_ScanInformation* le_mrc_ScanInformationRef_t;
  683 
  684 
  685 //--------------------------------------------------------------------------------------------------
  686 /**
  687  * Reference type for Scan Information Listing.
  688  */
  689 //--------------------------------------------------------------------------------------------------
  690 typedef struct le_mrc_ScanInformationList* le_mrc_ScanInformationListRef_t;
  691 
  692 
  693 //--------------------------------------------------------------------------------------------------
  694 /**
  695  * Reference type for referring to the Preferred Operator objects.
  696  */
  697 //--------------------------------------------------------------------------------------------------
  698 typedef struct le_mrc_PreferredOperator* le_mrc_PreferredOperatorRef_t;
  699 
  700 
  701 //--------------------------------------------------------------------------------------------------
  702 /**
  703  * Reference type for Preferred Operator Listing.
  704  */
  705 //--------------------------------------------------------------------------------------------------
  706 typedef struct le_mrc_PreferredOperatorList* le_mrc_PreferredOperatorListRef_t;
  707 
  708 
  709 //--------------------------------------------------------------------------------------------------
  710 /**
  711  *  Reference type for one Cell Information.
  712  */
  713 //--------------------------------------------------------------------------------------------------
  714 typedef struct le_mrc_CellInfo* le_mrc_CellInfoRef_t;
  715 
  716 
  717 //--------------------------------------------------------------------------------------------------
  718 /**
  719  *  Reference type for all Neighboring Cells Information.
  720  */
  721 //--------------------------------------------------------------------------------------------------
  722 typedef struct le_mrc_NeighborCells* le_mrc_NeighborCellsRef_t;
  723 
  724 
  725 //--------------------------------------------------------------------------------------------------
  726 /**
  727  *  Reference type for the signal metrics.
  728  */
  729 //--------------------------------------------------------------------------------------------------
  730 typedef struct le_mrc_Metrics* le_mrc_MetricsRef_t;
  731 
  732 
  733 //--------------------------------------------------------------------------------------------------
  734 /**
  735  * Network Registration states.
  736  */
  737 //--------------------------------------------------------------------------------------------------
  738 typedef enum
  739 {
  740     LE_MRC_REG_NONE = 0,
  741         ///< Not registered and not currently searching for new operator.
  742     LE_MRC_REG_HOME = 1,
  743         ///< Registered, home network.
  744     LE_MRC_REG_SEARCHING = 2,
  745         ///< Not registered but currently searching for a new operator.
  746     LE_MRC_REG_DENIED = 3,
  747         ///< Registration was denied, usually because of invalid access credentials.
  748     LE_MRC_REG_ROAMING = 4,
  749         ///< Registered to a roaming network.
  750     LE_MRC_REG_UNKNOWN = 5
  751         ///< Unknown state.
  752 }
  753 le_mrc_NetRegState_t;
  754 
  755 
  756 //--------------------------------------------------------------------------------------------------
  757 /**
  758  * Radio Access Technology enum
  759  */
  760 //--------------------------------------------------------------------------------------------------
  761 typedef enum
  762 {
  763     LE_MRC_RAT_UNKNOWN = 0,
  764         ///< Unknown
  765     LE_MRC_RAT_GSM = 1,
  766         ///< GSM network
  767     LE_MRC_RAT_UMTS = 2,
  768         ///< UMTS networks
  769     LE_MRC_RAT_TDSCDMA = 3,
  770         ///< TD-SCDMA networks
  771     LE_MRC_RAT_LTE = 4,
  772         ///< LTE network
  773     LE_MRC_RAT_CDMA = 5
  774         ///< CDMA network
  775 }
  776 le_mrc_Rat_t;
  777 
  778 
  779 //--------------------------------------------------------------------------------------------------
  780 /**
  781  * Jamming detection report type enum
  782  *
  783  * @note If the reported status is the final status (end of the procedure), this shall be indicated
  784  * within the status report.
  785  * @note Other reports, called intermediate reports, gives only intermediate results issuing from
  786  * the algorithm
  787  */
  788 //--------------------------------------------------------------------------------------------------
  789 typedef enum
  790 {
  791     LE_MRC_JAMMING_REPORT_FINAL = 0,
  792         ///< Final jamming status report
  793     LE_MRC_JAMMING_REPORT_INTERMEDIATE = 1
  794         ///< Intermediate jamming status report
  795 }
  796 le_mrc_JammingReport_t;
  797 
  798 
  799 //--------------------------------------------------------------------------------------------------
  800 /**
  801  * Jamming detection status type enum
  802  *
  803  * @note The final status can be only NULL or JAMMED.
  804  */
  805 //--------------------------------------------------------------------------------------------------
  806 typedef enum
  807 {
  808     LE_MRC_JAMMING_STATUS_UNKNOWN = 0,
  809         ///< Status is unknown
  810     LE_MRC_JAMMING_STATUS_NULL = 1,
  811         ///< No jamming suspicion; radio environment is considered normal
  812     LE_MRC_JAMMING_STATUS_LOW = 2,
  813         ///< Low probability that the device is jammed, but some radio
  814         ///< environment parameters are considered abnormal
  815     LE_MRC_JAMMING_STATUS_MEDIUM = 3,
  816         ///< Medium probability that the device is jammed; a lot of
  817         ///< interferences in the radio spectrum
  818     LE_MRC_JAMMING_STATUS_HIGH = 4,
  819         ///< High probability that the device is jammed; radio environment is
  820         ///< considered jammed, but there is still a possibility that the module
  821         ///< succeeds in synchronizing a cell
  822     LE_MRC_JAMMING_STATUS_JAMMED = 5
  823         ///< Module is jammed; cell synchronization impossible while sufficient
  824         ///< power level is detected on a large number of frequencies
  825 }
  826 le_mrc_JammingStatus_t;
  827 
  828 
  829 //--------------------------------------------------------------------------------------------------
  830 /**
  831  * Radio Bitmask Access Technology Bit Mask
  832  */
  833 //--------------------------------------------------------------------------------------------------
  834 typedef enum
  835 {
  836     LE_MRC_BITMASK_RAT_GSM = 0x1,        ///< GSM RAT Bit Mask
  837     LE_MRC_BITMASK_RAT_UMTS = 0x2,        ///< UMTS RAT Bit Mask
  838     LE_MRC_BITMASK_RAT_TDSCDMA = 0x4,        ///< TD-SCDMA RAT Bit Mask
  839     LE_MRC_BITMASK_RAT_LTE = 0x8,        ///< LTE RAT Bit Mask
  840     LE_MRC_BITMASK_RAT_CDMA = 0x10,        ///< CDMA RAT Bit Mask
  841     LE_MRC_BITMASK_RAT_ALL = 0x20,        ///< To Set all RAT preference Bit Mask
  842     LE_MRC_BITMASK_RAT_MAX = 0x40
  843 }
  844 le_mrc_RatBitMask_t;
  845 
  846 
  847 //--------------------------------------------------------------------------------------------------
  848 /**
  849  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegStateEvent'
  850  */
  851 //--------------------------------------------------------------------------------------------------
  852 typedef struct le_mrc_NetRegStateEventHandler* le_mrc_NetRegStateEventHandlerRef_t;
  853 
  854 
  855 //--------------------------------------------------------------------------------------------------
  856 /**
  857  * Reference type used by Add/Remove functions for EVENT 'le_mrc_RatChange'
  858  */
  859 //--------------------------------------------------------------------------------------------------
  860 typedef struct le_mrc_RatChangeHandler* le_mrc_RatChangeHandlerRef_t;
  861 
  862 
  863 //--------------------------------------------------------------------------------------------------
  864 /**
  865  * Reference type used by Add/Remove functions for EVENT 'le_mrc_PacketSwitchedChange'
  866  */
  867 //--------------------------------------------------------------------------------------------------
  868 typedef struct le_mrc_PacketSwitchedChangeHandler* le_mrc_PacketSwitchedChangeHandlerRef_t;
  869 
  870 
  871 //--------------------------------------------------------------------------------------------------
  872 /**
  873  * Reference type used by Add/Remove functions for EVENT 'le_mrc_SignalStrengthChange'
  874  */
  875 //--------------------------------------------------------------------------------------------------
  876 typedef struct le_mrc_SignalStrengthChangeHandler* le_mrc_SignalStrengthChangeHandlerRef_t;
  877 
  878 
  879 //--------------------------------------------------------------------------------------------------
  880 /**
  881  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetworkReject'
  882  */
  883 //--------------------------------------------------------------------------------------------------
  884 typedef struct le_mrc_NetworkRejectHandler* le_mrc_NetworkRejectHandlerRef_t;
  885 
  886 
  887 //--------------------------------------------------------------------------------------------------
  888 /**
  889  * Reference type used by Add/Remove functions for EVENT 'le_mrc_JammingDetectionEvent'
  890  */
  891 //--------------------------------------------------------------------------------------------------
  892 typedef struct le_mrc_JammingDetectionEventHandler* le_mrc_JammingDetectionEventHandlerRef_t;
  893 
  894 
  895 //--------------------------------------------------------------------------------------------------
  896 /**
  897  * Handler for Network registration state changes.
  898  *
  899  */
  900 //--------------------------------------------------------------------------------------------------
  901 typedef void (*le_mrc_NetRegStateHandlerFunc_t)
  902 (
  903     le_mrc_NetRegState_t state,
  904         ///< Parameter ready to receive the Network Registration state.
  905     void* contextPtr
  906         ///<
  907 );
  908 
  909 //--------------------------------------------------------------------------------------------------
  910 /**
  911  * Handler for Radio Access Technology changes.
  912  *
  913  */
  914 //--------------------------------------------------------------------------------------------------
  915 typedef void (*le_mrc_RatChangeHandlerFunc_t)
  916 (
  917     le_mrc_Rat_t rat,
  918         ///< Parameter ready to receive the Radio Access Technology.
  919     void* contextPtr
  920         ///<
  921 );
  922 
  923 //--------------------------------------------------------------------------------------------------
  924 /**
  925  * Handler for Packet Switched service state changes.
  926  *
  927  */
  928 //--------------------------------------------------------------------------------------------------
  929 typedef void (*le_mrc_PacketSwitchedChangeHandlerFunc_t)
  930 (
  931     le_mrc_NetRegState_t state,
  932         ///< Parameter ready to receive the Packet Switched service state.
  933     void* contextPtr
  934         ///<
  935 );
  936 
  937 //--------------------------------------------------------------------------------------------------
  938 /**
  939  * Handler for Signal Strength value changes.
  940  *
  941  */
  942 //--------------------------------------------------------------------------------------------------
  943 typedef void (*le_mrc_SignalStrengthChangeHandlerFunc_t)
  944 (
  945     int32_t ss,
  946         ///< Signal strength in dBm
  947     void* contextPtr
  948         ///<
  949 );
  950 
  951 //--------------------------------------------------------------------------------------------------
  952 /**
  953  * Handler for cellular asynchronous network scan Sending result.
  954  *  Returns the reference to the List object. Null pointer if the scan failed.
  955  *
  956  */
  957 //--------------------------------------------------------------------------------------------------
  958 typedef void (*le_mrc_CellularNetworkScanHandlerFunc_t)
  959 (
  960     le_mrc_ScanInformationListRef_t listRef,
  961         ///< Reference to the List object. Null pointer if the
  962         ///< scan failed.
  963     void* contextPtr
  964         ///<
  965 );
  966 
  967 //--------------------------------------------------------------------------------------------------
  968 /**
  969  * Handler for asynchronous manual selection response
  970  *
  971  */
  972 //--------------------------------------------------------------------------------------------------
  973 typedef void (*le_mrc_ManualSelectionHandlerFunc_t)
  974 (
  975     le_result_t result,
  976         ///< Manual selection response
  977     void* contextPtr
  978         ///<
  979 );
  980 
  981 //--------------------------------------------------------------------------------------------------
  982 /**
  983  * Handler to report network reject indication.
  984  *
  985  */
  986 //--------------------------------------------------------------------------------------------------
  987 typedef void (*le_mrc_NetworkRejectHandlerFunc_t)
  988 (
  989     const char* LE_NONNULL mcc,
  990         ///< Mobile Country Code
  991     const char* LE_NONNULL mnc,
  992         ///< Mobile Network Code
  993     le_mrc_Rat_t rat,
  994         ///< Radio Access Technology.
  995     void* contextPtr
  996         ///<
  997 );
  998 
  999 //--------------------------------------------------------------------------------------------------
 1000 /**
 1001  * Handler for jamming detection event.
 1002  */
 1003 //--------------------------------------------------------------------------------------------------
 1004 typedef void (*le_mrc_JammingDetectionHandlerFunc_t)
 1005 (
 1006     le_mrc_JammingReport_t report,
 1007         ///< Report type.
 1008     le_mrc_JammingStatus_t status,
 1009         ///< Jamming detection status.
 1010     void* contextPtr
 1011         ///<
 1012 );
 1013 
 1014 //--------------------------------------------------------------------------------------------------
 1015 /**
 1016  * Add handler function for EVENT 'le_mrc_NetRegStateEvent'
 1017  *
 1018  * This event provides information on network registration state changes.
 1019  *
 1020  * @note <b>multi-app safe</b>
 1021  */
 1022 //--------------------------------------------------------------------------------------------------
 1023 le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler
 1024 (
 1025     le_mrc_NetRegStateHandlerFunc_t handlerPtr,
 1026         ///< [IN]
 1027     void* contextPtr
 1028         ///< [IN]
 1029 );
 1030 
 1031 //--------------------------------------------------------------------------------------------------
 1032 /**
 1033  * Remove handler function for EVENT 'le_mrc_NetRegStateEvent'
 1034  */
 1035 //--------------------------------------------------------------------------------------------------
 1036 void le_mrc_RemoveNetRegStateEventHandler
 1037 (
 1038     le_mrc_NetRegStateEventHandlerRef_t handlerRef
 1039         ///< [IN]
 1040 );
 1041 
 1042 //--------------------------------------------------------------------------------------------------
 1043 /**
 1044  * Add handler function for EVENT 'le_mrc_RatChange'
 1045  *
 1046  * This event provides information on Radio Access Technology changes.
 1047  *
 1048  * @note <b>multi-app safe</b>
 1049  */
 1050 //--------------------------------------------------------------------------------------------------
 1051 le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler
 1052 (
 1053     le_mrc_RatChangeHandlerFunc_t handlerPtr,
 1054         ///< [IN]
 1055     void* contextPtr
 1056         ///< [IN]
 1057 );
 1058 
 1059 //--------------------------------------------------------------------------------------------------
 1060 /**
 1061  * Remove handler function for EVENT 'le_mrc_RatChange'
 1062  */
 1063 //--------------------------------------------------------------------------------------------------
 1064 void le_mrc_RemoveRatChangeHandler
 1065 (
 1066     le_mrc_RatChangeHandlerRef_t handlerRef
 1067         ///< [IN]
 1068 );
 1069 
 1070 //--------------------------------------------------------------------------------------------------
 1071 /**
 1072  * Add handler function for EVENT 'le_mrc_PacketSwitchedChange'
 1073  *
 1074  * This event provides information on Packet Switched service changes.
 1075  *
 1076  * @note <b>multi-app safe</b>
 1077  */
 1078 //--------------------------------------------------------------------------------------------------
 1079 le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler
 1080 (
 1081     le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr,
 1082         ///< [IN]
 1083     void* contextPtr
 1084         ///< [IN]
 1085 );
 1086 
 1087 //--------------------------------------------------------------------------------------------------
 1088 /**
 1089  * Remove handler function for EVENT 'le_mrc_PacketSwitchedChange'
 1090  */
 1091 //--------------------------------------------------------------------------------------------------
 1092 void le_mrc_RemovePacketSwitchedChangeHandler
 1093 (
 1094     le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef
 1095         ///< [IN]
 1096 );
 1097 
 1098 //--------------------------------------------------------------------------------------------------
 1099 /**
 1100  * Add handler function for EVENT 'le_mrc_SignalStrengthChange'
 1101  *
 1102  * This event provides information on Signal Strength value changes.
 1103  *
 1104  * @note <b>NOT multi-app safe</b>
 1105  */
 1106 //--------------------------------------------------------------------------------------------------
 1107 le_mrc_SignalStrengthChangeHandlerRef_t le_mrc_AddSignalStrengthChangeHandler
 1108 (
 1109     le_mrc_Rat_t rat,
 1110         ///< [IN] Radio Access Technology
 1111     int32_t lowerRangeThreshold,
 1112         ///< [IN] Lower-range Signal strength threshold in dBm
 1113     int32_t upperRangeThreshold,
 1114         ///< [IN] Upper-range Signal strength threshold in dBm
 1115     le_mrc_SignalStrengthChangeHandlerFunc_t handlerPtr,
 1116         ///< [IN]
 1117     void* contextPtr
 1118         ///< [IN]
 1119 );
 1120 
 1121 //--------------------------------------------------------------------------------------------------
 1122 /**
 1123  * Remove handler function for EVENT 'le_mrc_SignalStrengthChange'
 1124  */
 1125 //--------------------------------------------------------------------------------------------------
 1126 void le_mrc_RemoveSignalStrengthChangeHandler
 1127 (
 1128     le_mrc_SignalStrengthChangeHandlerRef_t handlerRef
 1129         ///< [IN]
 1130 );
 1131 
 1132 //--------------------------------------------------------------------------------------------------
 1133 /**
 1134  * This function sets signal strength indication thresholds for a specific RAT.
 1135  *
 1136  * @return
 1137  *  - LE_OK             Function succeeded.
 1138  *  - LE_BAD_PARAMETER  Bad parameters
 1139  *  - LE_FAULT          Function failed.
 1140  *
 1141  * @note <b>NOT multi-app safe</b>
 1142  */
 1143 //--------------------------------------------------------------------------------------------------
 1144 le_result_t le_mrc_SetSignalStrengthIndThresholds
 1145 (
 1146     le_mrc_Rat_t rat,
 1147         ///< [IN] Radio Access Technology
 1148     int32_t lowerRangeThreshold,
 1149         ///< [IN] Lower-range Signal strength threshold in dBm
 1150     int32_t upperRangeThreshold
 1151         ///< [IN] Upper-range Signal strength threshold in dBm
 1152 );
 1153 
 1154 //--------------------------------------------------------------------------------------------------
 1155 /**
 1156  * This function sets a signal strength indication delta for a specific RAT.
 1157  *
 1158  * @return
 1159  *  - LE_OK             Function succeeded.
 1160  *  - LE_BAD_PARAMETER  Bad parameters.
 1161  *  - LE_FAULT          Function failed.
 1162  *
 1163  * @note The signal delta is set in units of 0.1 dBm. For example, to set a delta of 10.6 dBm, the
 1164  *       delta value must be set to 106.
 1165  *
 1166  * @warning The signal delta resolution is platform dependent. Please refer to
 1167  *          @ref platformConstraintsModemRadiocontrol section for full details.
 1168  */
 1169 //--------------------------------------------------------------------------------------------------
 1170 le_result_t le_mrc_SetSignalStrengthIndDelta
 1171 (
 1172     le_mrc_Rat_t rat,
 1173         ///< [IN] Radio Access Technology
 1174     uint16_t delta
 1175         ///< [IN] Signal delta in units of 0.1 dBm
 1176 );
 1177 
 1178 //--------------------------------------------------------------------------------------------------
 1179 /**
 1180  * Enable the automatic Selection Register mode.
 1181  *
 1182  * @return
 1183  *  - LE_FAULT  Function failed.
 1184  *  - LE_OK     Function succeeded.
 1185  *
 1186  * @note <b>NOT multi-app safe</b>
 1187  */
 1188 //--------------------------------------------------------------------------------------------------
 1189 le_result_t le_mrc_SetAutomaticRegisterMode
 1190 (
 1191     void
 1192 );
 1193 
 1194 //--------------------------------------------------------------------------------------------------
 1195 /**
 1196  * Set the manual Selection Register mode with the MCC/MNC parameters.
 1197  *
 1198  * @return
 1199  *  - LE_FAULT  Function failed.
 1200  *  - LE_OK     Function succeeded.
 1201  *
 1202  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1203  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1204  *       won't return.
 1205  *
 1206  * @note <b>NOT multi-app safe</b>
 1207  */
 1208 //--------------------------------------------------------------------------------------------------
 1209 le_result_t le_mrc_SetManualRegisterMode
 1210 (
 1211     const char* LE_NONNULL mcc,
 1212         ///< [IN] Mobile Country Code
 1213     const char* LE_NONNULL mnc
 1214         ///< [IN] Mobile Network Code
 1215 );
 1216 
 1217 //--------------------------------------------------------------------------------------------------
 1218 /**
 1219  * Set the manual selection register mode asynchronously. This function is not blocking,
 1220  *  the response will be returned with a handler function.
 1221  *
 1222  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1223  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1224  *       won't return.
 1225  *
 1226  *@note <b>NOT multi-app safe</b>
 1227  *
 1228  */
 1229 //--------------------------------------------------------------------------------------------------
 1230 void le_mrc_SetManualRegisterModeAsync
 1231 (
 1232     const char* LE_NONNULL mcc,
 1233         ///< [IN] Mobile Country Code
 1234     const char* LE_NONNULL mnc,
 1235         ///< [IN] Mobile Network Code
 1236     le_mrc_ManualSelectionHandlerFunc_t handlerPtr,
 1237         ///< [IN] handler for sending result
 1238     void* contextPtr
 1239         ///< [IN]
 1240 );
 1241 
 1242 //--------------------------------------------------------------------------------------------------
 1243 /**
 1244  * Get the selected Selection Register mode.
 1245  *
 1246  * @return
 1247  *  - LE_FAULT  Function failed.
 1248  *  - LE_OK     Function succeeded.
 1249  *
 1250  * @note <b>multi-app safe</b>
 1251  */
 1252 //--------------------------------------------------------------------------------------------------
 1253 le_result_t le_mrc_GetRegisterMode
 1254 (
 1255     bool* isManualPtrPtr,
 1256         ///< [OUT] true if the scan mode is manual, false if the scan mode is automatic.
 1257     char* mccPtr,
 1258         ///< [OUT] Mobile Country Code
 1259     size_t mccPtrSize,
 1260         ///< [IN]
 1261     char* mncPtr,
 1262         ///< [OUT] Mobile Network Code
 1263     size_t mncPtrSize
 1264         ///< [IN]
 1265 );
 1266 
 1267 //--------------------------------------------------------------------------------------------------
 1268 /**
 1269  * Get the Packet Switched state.
 1270  *
 1271  * @return
 1272  *  - LE_FAULT  Function failed.
 1273  *  - LE_OK     Function succeeded.
 1274  *
 1275  * @note <b>multi-app safe</b>
 1276  */
 1277 //--------------------------------------------------------------------------------------------------
 1278 le_result_t le_mrc_GetPacketSwitchedState
 1279 (
 1280     le_mrc_NetRegState_t* statePtr
 1281         ///< [OUT] The current Packet switched state.
 1282 );
 1283 
 1284 //--------------------------------------------------------------------------------------------------
 1285 /**
 1286  * Get the platform specific network registration error code.
 1287  *
 1288  * Refer to @ref platformConstraintsSpecificErrorCodes for platform specific
 1289  * registration error code description.
 1290  *
 1291  * @return the platform specific registration error code
 1292  *
 1293  */
 1294 //--------------------------------------------------------------------------------------------------
 1295 int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode
 1296 (
 1297     void
 1298 );
 1299 
 1300 //--------------------------------------------------------------------------------------------------
 1301 /**
 1302  * Set the Radio Access Technology preferences by using a bit mask.
 1303  *
 1304  * @return
 1305  *  - LE_FAULT           Function failed.
 1306  *  - LE_OK              Function succeeded.
 1307  *  - LE_UNSUPPORTED     Not supported by platform.
 1308  *
 1309  * @note <b>NOT multi-app safe</b>
 1310  */
 1311 //--------------------------------------------------------------------------------------------------
 1312 le_result_t le_mrc_SetRatPreferences
 1313 (
 1314     le_mrc_RatBitMask_t ratMask
 1315         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1316 );
 1317 
 1318 //--------------------------------------------------------------------------------------------------
 1319 /**
 1320  * Get the Radio Access Technology preferences
 1321  *
 1322  * @return
 1323  * - LE_FAULT  Function failed.
 1324  * - LE_OK     Function succeeded.
 1325  *
 1326  * @note <b>multi-app safe</b>
 1327  */
 1328 //--------------------------------------------------------------------------------------------------
 1329 le_result_t le_mrc_GetRatPreferences
 1330 (
 1331     le_mrc_RatBitMask_t* ratMaskPtrPtr
 1332         ///< [OUT] Bit mask for the Radio Access Technology preferences.
 1333 );
 1334 
 1335 //--------------------------------------------------------------------------------------------------
 1336 /**
 1337  * Set the 2G/3G Band preferences by using a bit mask.
 1338  *
 1339  * @return
 1340  *  - LE_FAULT  Function failed.
 1341  *  - LE_OK     Function succeeded.
 1342  *
 1343  * @note <b>NOT multi-app safe</b>
 1344  */
 1345 //--------------------------------------------------------------------------------------------------
 1346 le_result_t le_mrc_SetBandPreferences
 1347 (
 1348     le_mrc_BandBitMask_t bandMask
 1349         ///< [IN] Bit mask for 2G/3G Band preferences.
 1350 );
 1351 
 1352 //--------------------------------------------------------------------------------------------------
 1353 /**
 1354  * Get the Bit mask for 2G/3G Band preferences.
 1355  *
 1356  * @return
 1357  *  - LE_FAULT  Function failed.
 1358  *  - LE_OK     Function succeeded.
 1359  *
 1360  * @note <b>multi-app safe</b>
 1361  */
 1362 //--------------------------------------------------------------------------------------------------
 1363 le_result_t le_mrc_GetBandPreferences
 1364 (
 1365     le_mrc_BandBitMask_t* bandMaskPtrPtr
 1366         ///< [OUT] Bit mask for 2G/3G Band preferences.
 1367 );
 1368 
 1369 //--------------------------------------------------------------------------------------------------
 1370 /**
 1371  * Set the LTE Band preferences by using a bit mask.
 1372  *
 1373  * @return
 1374  *  - LE_FAULT        Function failed.
 1375  *  - LE_OK           Function succeeded.
 1376  *  - LE_UNSUPPORTED  The platform doesn't support setting LTE Band preferences.
 1377  *
 1378  * @note <b>NOT multi-app safe</b>
 1379  */
 1380 //--------------------------------------------------------------------------------------------------
 1381 le_result_t le_mrc_SetLteBandPreferences
 1382 (
 1383     le_mrc_LteBandBitMask_t bandMask
 1384         ///< [IN] Bit mask for LTE Band preferences.
 1385 );
 1386 
 1387 //--------------------------------------------------------------------------------------------------
 1388 /**
 1389  * Get the Bit mask for LTE Band preferences.
 1390  *
 1391  * @return
 1392  *  - LE_FAULT  Function failed.
 1393  *  - LE_OK     Function succeeded.
 1394  *
 1395  * @note <b>multi-app safe</b>
 1396  */
 1397 //--------------------------------------------------------------------------------------------------
 1398 le_result_t le_mrc_GetLteBandPreferences
 1399 (
 1400     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 1401         ///< [OUT] Bit mask for LTE Band preferences.
 1402 );
 1403 
 1404 //--------------------------------------------------------------------------------------------------
 1405 /**
 1406  * Set the TD-SCDMA Band preferences by using a bit mask.
 1407  *
 1408  * @return
 1409  *  - LE_OK           Function succeeded.
 1410  *  - LE_FAULT        Function failed.
 1411  *  - LE_UNSUPPORTED  The platform doesn't support setting TD-SCDMA Band preferences.
 1412  *
 1413  * @note <b>NOT multi-app safe</b>
 1414  */
 1415 //--------------------------------------------------------------------------------------------------
 1416 le_result_t le_mrc_SetTdScdmaBandPreferences
 1417 (
 1418     le_mrc_TdScdmaBandBitMask_t bandMask
 1419         ///< [IN] Bit mask for TD-SCDMA Band preferences.
 1420 );
 1421 
 1422 //--------------------------------------------------------------------------------------------------
 1423 /**
 1424  * Get the Bit mask for TD-SCDMA Band preferences.
 1425  *
 1426  * @return
 1427  *  - LE_OK           Function succeeded.
 1428  *  - LE_FAULT        Function failed.
 1429  *  - LE_UNSUPPORTED  The platform doesn't support getting TD-SCDMA Band preferences.
 1430  *
 1431  * @note <b>multi-app safe</b>
 1432  */
 1433 //--------------------------------------------------------------------------------------------------
 1434 le_result_t le_mrc_GetTdScdmaBandPreferences
 1435 (
 1436     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 1437         ///< [OUT] Bit mask for TD-SCDMA Band preferences.
 1438 );
 1439 
 1440 //--------------------------------------------------------------------------------------------------
 1441 /**
 1442  * Add a preferred operator by specifying the MCC/MNC and the Radio Access Technology.
 1443  *
 1444  * @return
 1445  *  - LE_UNSUPPORTED   List of User Preferred operators not available.
 1446  *  - LE_FAULT         Function failed.
 1447  *  - LE_BAD_PARAMETER RAT mask is invalid.
 1448  *  - LE_OK            Function succeeded.
 1449  *
 1450  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1451  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1452  *       won't return.
 1453  *
 1454  * @note <b>NOT multi-app safe</b>
 1455  */
 1456 //--------------------------------------------------------------------------------------------------
 1457 le_result_t le_mrc_AddPreferredOperator
 1458 (
 1459     const char* LE_NONNULL mcc,
 1460         ///< [IN] Mobile Country Code
 1461     const char* LE_NONNULL mnc,
 1462         ///< [IN] Mobile Network Code
 1463     le_mrc_RatBitMask_t ratMask
 1464         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1465 );
 1466 
 1467 //--------------------------------------------------------------------------------------------------
 1468 /**
 1469  * Remove a preferred operator by specifying the MCC/MNC.
 1470  *
 1471  * @return
 1472  *  - LE_UNSUPPORTED    List of User Preferred operators not available.
 1473  *  - LE_NOT_FOUND      Operator not found in the User Preferred operators list.
 1474  *  - LE_FAULT          Function failed.
 1475  *  - LE_OK             Function succeeded.
 1476  *
 1477  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1478  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1479  *       won't return.
 1480  *
 1481  * @note <b>NOT multi-app safe</b>
 1482  */
 1483 //--------------------------------------------------------------------------------------------------
 1484 le_result_t le_mrc_RemovePreferredOperator
 1485 (
 1486     const char* LE_NONNULL mcc,
 1487         ///< [IN] Mobile Country Code
 1488     const char* LE_NONNULL mnc
 1489         ///< [IN] Mobile Network Code
 1490 );
 1491 
 1492 //--------------------------------------------------------------------------------------------------
 1493 /**
 1494  * This function must be called to retrieve a list of the preferred operators.
 1495  *
 1496  * @return
 1497  * - Reference to the List object.
 1498  * - Null pointer if there is no preferences list.
 1499  *
 1500  * @note <b>multi-app safe</b>
 1501  */
 1502 //--------------------------------------------------------------------------------------------------
 1503 le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList
 1504 (
 1505     void
 1506 );
 1507 
 1508 //--------------------------------------------------------------------------------------------------
 1509 /**
 1510  * This function must be called to get the first Operator object reference in the list of the
 1511  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1512  *
 1513  * @return
 1514  *  - NULL                          No operator information found.
 1515  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1516  *
 1517  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1518  *       function won't return.
 1519  *
 1520  * @note <b>multi-app safe</b>
 1521  */
 1522 //--------------------------------------------------------------------------------------------------
 1523 le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator
 1524 (
 1525     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1526         ///< [IN] The list of the preferred operators.
 1527 );
 1528 
 1529 //--------------------------------------------------------------------------------------------------
 1530 /**
 1531  * This function must be called to get the next Operator object reference in the list of the
 1532  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1533  *
 1534  * @return
 1535  *  - NULL                          No operator information found.
 1536  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1537  *
 1538  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1539  *       function won't return.
 1540  *
 1541  * @note <b>multi-app safe</b>
 1542  */
 1543 //--------------------------------------------------------------------------------------------------
 1544 le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator
 1545 (
 1546     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1547         ///< [IN] The list of the preferred operators.
 1548 );
 1549 
 1550 //--------------------------------------------------------------------------------------------------
 1551 /**
 1552  * This function must be called to delete the list of the preferred operators retrieved with
 1553  * le_mrc_GetPreferredOperators().
 1554  *
 1555  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1556  *       reference for validity.
 1557  *
 1558  * @note <b>multi-app safe</b>
 1559  */
 1560 //--------------------------------------------------------------------------------------------------
 1561 void le_mrc_DeletePreferredOperatorsList
 1562 (
 1563     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1564         ///< [IN] The list of the preferred operators.
 1565 );
 1566 
 1567 //--------------------------------------------------------------------------------------------------
 1568 /**
 1569  * This function must be called to get the Operator information details.
 1570  *
 1571  * @return
 1572  *      - LE_OK on success
 1573  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 1574  *      - LE_FAULT for all other errors
 1575  *
 1576  * @note <b>multi-app safe</b>
 1577  */
 1578 //--------------------------------------------------------------------------------------------------
 1579 le_result_t le_mrc_GetPreferredOperatorDetails
 1580 (
 1581     le_mrc_PreferredOperatorRef_t preferredOperatorRef,
 1582         ///< [IN] Operator object reference.
 1583     char* mccPtr,
 1584         ///< [OUT] Mobile Country Code.
 1585     size_t mccPtrSize,
 1586         ///< [IN]
 1587     char* mncPtr,
 1588         ///< [OUT] Mobile Network Code.
 1589     size_t mncPtrSize,
 1590         ///< [IN]
 1591     le_mrc_RatBitMask_t* ratMaskPtr
 1592         ///< [OUT] Bit mask for the RAT preferences.
 1593 );
 1594 
 1595 //--------------------------------------------------------------------------------------------------
 1596 /**
 1597  * Get the network registration state.
 1598  *
 1599  * @return LE_FAULT         The function failed to get the Network registration state.
 1600  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1601  * @return LE_OK            The function succeeded.
 1602  *
 1603  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1604  *       function won't return.
 1605  *
 1606  * @note <b>multi-app safe</b>
 1607  */
 1608 //--------------------------------------------------------------------------------------------------
 1609 le_result_t le_mrc_GetNetRegState
 1610 (
 1611     le_mrc_NetRegState_t* statePtr
 1612         ///< [OUT] Network Registration state.
 1613 );
 1614 
 1615 //--------------------------------------------------------------------------------------------------
 1616 /**
 1617  * Get the signal quality.
 1618  *
 1619  * @return LE_FAULT         The function failed to get the Signal Quality information.
 1620  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1621  * @return LE_OK            The function succeeded.
 1622  *
 1623  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1624  *       function won't return.
 1625  *
 1626  * @note <b>multi-app safe</b>
 1627  */
 1628 //--------------------------------------------------------------------------------------------------
 1629 le_result_t le_mrc_GetSignalQual
 1630 (
 1631     uint32_t* qualityPtr
 1632         ///< [OUT] [OUT] Received signal strength quality (0 = no signal strength,
 1633         ///<        5 = very good signal strength).
 1634 );
 1635 
 1636 //--------------------------------------------------------------------------------------------------
 1637 /**
 1638  * Set the power of the Radio Module.
 1639  *
 1640  * @return LE_BAD_PARAMETER Bad power mode specified.
 1641  * @return LE_FAULT         Function failed.
 1642  * @return LE_OK            Function succeed.
 1643  *
 1644  * @note <b>NOT multi-app safe</b>
 1645  */
 1646 //--------------------------------------------------------------------------------------------------
 1647 le_result_t le_mrc_SetRadioPower
 1648 (
 1649     le_onoff_t power
 1650         ///< [IN] The power state.
 1651 );
 1652 
 1653 //--------------------------------------------------------------------------------------------------
 1654 /**
 1655  * Must be called to get the Radio Module power state.
 1656  *
 1657  * @return LE_FAULT         The function failed to get the Radio Module power state.
 1658  * @return LE_BAD_PARAMETER if powerPtr is NULL.
 1659  * @return LE_OK            The function succeed.
 1660  *
 1661  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1662  *       function won't return.
 1663  *
 1664  * @note <b>multi-app safe</b>
 1665  */
 1666 //--------------------------------------------------------------------------------------------------
 1667 le_result_t le_mrc_GetRadioPower
 1668 (
 1669     le_onoff_t* powerPtr
 1670         ///< [OUT] Power state.
 1671 );
 1672 
 1673 //--------------------------------------------------------------------------------------------------
 1674 /**
 1675  * This function must be called to perform a cellular network scan.
 1676  *
 1677  * @return Reference to the List object. Null pointer if the scan failed.
 1678  *
 1679  * @note <b>multi-app safe</b>
 1680  */
 1681 //--------------------------------------------------------------------------------------------------
 1682 le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan
 1683 (
 1684     le_mrc_RatBitMask_t ratMask
 1685         ///< [IN] Radio Access Technology mask
 1686 );
 1687 
 1688 //--------------------------------------------------------------------------------------------------
 1689 /**
 1690  * This function must be called to perform a cellular network scan asynchronously. This function
 1691  * is not blocking, the response will be returned with a handler function.
 1692  *
 1693  *@note <b>multi-app safe</b>
 1694  *
 1695  */
 1696 //--------------------------------------------------------------------------------------------------
 1697 void le_mrc_PerformCellularNetworkScanAsync
 1698 (
 1699     le_mrc_RatBitMask_t ratMask,
 1700         ///< [IN] Radio Access Technology mask
 1701     le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr,
 1702         ///< [IN] handler for sending result.
 1703     void* contextPtr
 1704         ///< [IN]
 1705 );
 1706 
 1707 //--------------------------------------------------------------------------------------------------
 1708 /**
 1709  * This function must be called to get the first Scan Information object reference in the list of
 1710  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
 1711  *
 1712  * @return NULL                         No scan information found.
 1713  * @return le_mrc_ScanInformationRef_t  The Scan Information object reference.
 1714  *
 1715  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1716  *       function won't return.
 1717  *
 1718  * @note <b>multi-app safe</b>
 1719  */
 1720 //--------------------------------------------------------------------------------------------------
 1721 le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan
 1722 (
 1723     le_mrc_ScanInformationListRef_t scanInformationListRef
 1724         ///< [IN] The list of scan information.
 1725 );
 1726 
 1727 //--------------------------------------------------------------------------------------------------
 1728 /**
 1729  * This function must be called to get the next Scan Information object reference in the list of
 1730  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
 1731  *
 1732  * @return NULL                         No scan information found.
 1733  * @return le_mrc_ScanInformationRef_t  The Scan Information object reference.
 1734  *
 1735  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1736  *       function won't return.
 1737  *
 1738  * @note <b>multi-app safe</b>
 1739  */
 1740 //--------------------------------------------------------------------------------------------------
 1741 le_mrc_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan
 1742 (
 1743     le_mrc_ScanInformationListRef_t scanInformationListRef
 1744         ///< [IN] The list of scan information.
 1745 );
 1746 
 1747 //--------------------------------------------------------------------------------------------------
 1748 /**
 1749  * This function must be called to delete the list of the Scan Information retrieved with
 1750  * le_mrc_PerformCellularNetworkScan().
 1751  *
 1752  * @note
 1753  *      On failure, the process exits, so you don't have to worry about checking the returned
 1754  *      reference for validity.
 1755  *
 1756  * @note <b>multi-app safe</b>
 1757  */
 1758 //--------------------------------------------------------------------------------------------------
 1759 void le_mrc_DeleteCellularNetworkScan
 1760 (
 1761     le_mrc_ScanInformationListRef_t scanInformationListRef
 1762         ///< [IN] The list of scan information.
 1763 );
 1764 
 1765 //--------------------------------------------------------------------------------------------------
 1766 /**
 1767  * This function must be called to get the Cellular Network Code [mcc:mnc]
 1768  *
 1769  * @return
 1770  *      - LE_OK on success
 1771  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 1772  *      - LE_FAULT for all other errors
 1773  *
 1774  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1775  *       reference for validity.
 1776  *
 1777  * @note <b>multi-app safe</b>
 1778  */
 1779 //--------------------------------------------------------------------------------------------------
 1780 le_result_t le_mrc_GetCellularNetworkMccMnc
 1781 (
 1782     le_mrc_ScanInformationRef_t scanInformationRef,
 1783         ///< [IN] Scan information reference
 1784     char* mccPtr,
 1785         ///< [OUT] Mobile Country Code
 1786     size_t mccPtrSize,
 1787         ///< [IN]
 1788     char* mncPtr,
 1789         ///< [OUT] Mobile Network Code
 1790     size_t mncPtrSize
 1791         ///< [IN]
 1792 );
 1793 
 1794 //--------------------------------------------------------------------------------------------------
 1795 /**
 1796  * This function must be called to get the Cellular Network Name.
 1797  *
 1798  * @return
 1799  *      - LE_OK on success
 1800  *      - LE_OVERFLOW if the operator name would not fit in buffer
 1801  *      - LE_FAULT for all other errors
 1802  *
 1803  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1804  *       reference for validity.
 1805  *
 1806  * @note <b>multi-app safe</b>
 1807  */
 1808 //--------------------------------------------------------------------------------------------------
 1809 le_result_t le_mrc_GetCellularNetworkName
 1810 (
 1811     le_mrc_ScanInformationRef_t scanInformationRef,
 1812         ///< [IN] Scan information reference
 1813     char* namePtr,
 1814         ///< [OUT] Name of operator
 1815     size_t namePtrSize
 1816         ///< [IN]
 1817 );
 1818 
 1819 //--------------------------------------------------------------------------------------------------
 1820 /**
 1821  * This function must be called to get the radio access technology of a scanInformationRef.
 1822  *
 1823  * @return the radio access technology
 1824  *
 1825  * @note On failure, the process exits.
 1826  *
 1827  * @note <b>multi-app safe</b>
 1828  */
 1829 //--------------------------------------------------------------------------------------------------
 1830 le_mrc_Rat_t le_mrc_GetCellularNetworkRat
 1831 (
 1832     le_mrc_ScanInformationRef_t scanInformationRef
 1833         ///< [IN] Scan information reference
 1834 );
 1835 
 1836 //--------------------------------------------------------------------------------------------------
 1837 /**
 1838  * This function must be called to check if a cellular network is currently in use.
 1839  *
 1840  * @return true     The network is in use
 1841  * @return false    The network isn't in use
 1842  *
 1843  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1844  *       reference for validity.
 1845  *
 1846  * @note <b>multi-app safe</b>
 1847  */
 1848 //--------------------------------------------------------------------------------------------------
 1849 bool le_mrc_IsCellularNetworkInUse
 1850 (
 1851     le_mrc_ScanInformationRef_t scanInformationRef
 1852         ///< [IN] Scan information reference
 1853 );
 1854 
 1855 //--------------------------------------------------------------------------------------------------
 1856 /**
 1857  * This function must be called to check if a cellular network is available.
 1858  *
 1859  * @return true     The network is available
 1860  * @return false    The network isn't available
 1861  *
 1862  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1863  *       reference for validity.
 1864  *
 1865  * @note <b>multi-app safe</b>
 1866  */
 1867 //--------------------------------------------------------------------------------------------------
 1868 bool le_mrc_IsCellularNetworkAvailable
 1869 (
 1870     le_mrc_ScanInformationRef_t scanInformationRef
 1871         ///< [IN] Scan information reference
 1872 );
 1873 
 1874 //--------------------------------------------------------------------------------------------------
 1875 /**
 1876  * This function must be called to check if a cellular network is currently in home mode.
 1877  *
 1878  * @return true     The network is home
 1879  * @return false    The network is roaming
 1880  *
 1881  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1882  *       reference for validity.
 1883  *
 1884  * @note <b>multi-app safe</b>
 1885  */
 1886 //--------------------------------------------------------------------------------------------------
 1887 bool le_mrc_IsCellularNetworkHome
 1888 (
 1889     le_mrc_ScanInformationRef_t scanInformationRef
 1890         ///< [IN] Scan information reference
 1891 );
 1892 
 1893 //--------------------------------------------------------------------------------------------------
 1894 /**
 1895  * This function must be called to check if a cellular network is forbidden by the operator.
 1896  *
 1897  * @return true     The network is forbidden
 1898  * @return false    The network is allowed
 1899  *
 1900  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1901  *       reference for validity.
 1902  *
 1903  * @note <b>multi-app safe</b>
 1904  */
 1905 //--------------------------------------------------------------------------------------------------
 1906 bool le_mrc_IsCellularNetworkForbidden
 1907 (
 1908     le_mrc_ScanInformationRef_t scanInformationRef
 1909         ///< [IN] Scan information reference
 1910 );
 1911 
 1912 //--------------------------------------------------------------------------------------------------
 1913 /**
 1914  * This function must be called to get the current network name information.
 1915  *
 1916  * @return
 1917  *      - LE_OK             on success
 1918  *      - LE_BAD_PARAMETER  if nameStr is NULL
 1919  *      - LE_OVERFLOW       if the Home Network Name can't fit in nameStr
 1920  *      - LE_FAULT          on any other failure
 1921  *
 1922  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1923  *       function won't return.
 1924  *
 1925  * @note <b>multi-app safe</b>
 1926  */
 1927 //--------------------------------------------------------------------------------------------------
 1928 le_result_t le_mrc_GetCurrentNetworkName
 1929 (
 1930     char* nameStr,
 1931         ///< [OUT] the home network Name
 1932     size_t nameStrSize
 1933         ///< [IN]
 1934 );
 1935 
 1936 //--------------------------------------------------------------------------------------------------
 1937 /**
 1938  * This function must be called to get the current network PLMN information.
 1939  *
 1940  * @return
 1941  *      - LE_OK       on success
 1942  *      - LE_FAULT    on any other failure
 1943  *
 1944  * @note <b>multi-app safe</b>
 1945  */
 1946 //--------------------------------------------------------------------------------------------------
 1947 le_result_t le_mrc_GetCurrentNetworkMccMnc
 1948 (
 1949     char* mccStr,
 1950         ///< [OUT] the mobile country code
 1951     size_t mccStrSize,
 1952         ///< [IN]
 1953     char* mncStr,
 1954         ///< [OUT] the mobile network code
 1955     size_t mncStrSize
 1956         ///< [IN]
 1957 );
 1958 
 1959 //--------------------------------------------------------------------------------------------------
 1960 /**
 1961  * This function must be called to get the current Radio Access Technology in use.
 1962  *
 1963  * @return LE_OK            Function succeeded.
 1964  * @return LE_BAD_PARAMETER Invalid parameter.
 1965  * @return LE_FAULT         Function failed to get the Radio Access Technology.
 1966  *
 1967  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1968  *       function won't return.
 1969  *
 1970  * @note The API returns the RAT only if the device is registered on the network.
 1971  *
 1972  * @note <b>multi-app safe</b>
 1973  */
 1974 //--------------------------------------------------------------------------------------------------
 1975 le_result_t le_mrc_GetRadioAccessTechInUse
 1976 (
 1977     le_mrc_Rat_t* ratPtr
 1978         ///< [OUT] The Radio Access Technology.
 1979 );
 1980 
 1981 //--------------------------------------------------------------------------------------------------
 1982 /**
 1983  * This function must be called to retrieve the Neighboring Cells information. It creates and
 1984  * returns a reference to the Neighboring Cells information.
 1985  *
 1986  * @return A reference to the Neighboring Cells information.
 1987  * @return NULL if no Cells Information are available.
 1988  *
 1989  * @note <b>multi-app safe</b>
 1990  */
 1991 //--------------------------------------------------------------------------------------------------
 1992 le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo
 1993 (
 1994     void
 1995 );
 1996 
 1997 //--------------------------------------------------------------------------------------------------
 1998 /**
 1999  * This function must be called to delete the Neighboring Cells information.
 2000  *
 2001  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2002  *       reference for validity.
 2003  *
 2004  * @note <b>multi-app safe</b>
 2005  */
 2006 //--------------------------------------------------------------------------------------------------
 2007 void le_mrc_DeleteNeighborCellsInfo
 2008 (
 2009     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2010         ///< [IN] Neighboring Cells reference.
 2011 );
 2012 
 2013 //--------------------------------------------------------------------------------------------------
 2014 /**
 2015  * This function must be called to get the first Cell Information reference in the list of
 2016  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 2017  *
 2018  * @return NULL                   No Cell information object found.
 2019  * @return le_mrc_CellInfoRef_t   The Cell information object reference.
 2020  *
 2021  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2022  *       function won't return.
 2023  *
 2024  * @note <b>multi-app safe</b>
 2025  */
 2026 //--------------------------------------------------------------------------------------------------
 2027 le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo
 2028 (
 2029     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2030         ///< [IN] Neighboring Cells reference.
 2031 );
 2032 
 2033 //--------------------------------------------------------------------------------------------------
 2034 /**
 2035  * This function must be called to get the next Cell Information reference in the list of
 2036  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 2037  *
 2038  * @return NULL                   No Cell information object found.
 2039  * @return le_mrc_CellInfoRef_t   Cell information object reference.
 2040  *
 2041  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2042  *       function won't return.
 2043  *
 2044  * @note <b>multi-app safe</b>
 2045  */
 2046 //--------------------------------------------------------------------------------------------------
 2047 le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo
 2048 (
 2049     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2050         ///< [IN] Neighboring Cells reference.
 2051 );
 2052 
 2053 //--------------------------------------------------------------------------------------------------
 2054 /**
 2055  * This function must be called to get the Cell Identifier.
 2056  *
 2057  * @return The Cell Identifier. UINT32_MAX value is returned if the Cell Identifier is not
 2058  * available.
 2059  *
 2060  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2061  *       function won't return.
 2062  *
 2063  * @note <b>multi-app safe</b>
 2064  */
 2065 //--------------------------------------------------------------------------------------------------
 2066 uint32_t le_mrc_GetNeighborCellId
 2067 (
 2068     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2069         ///< [IN] Cell information reference.
 2070 );
 2071 
 2072 //--------------------------------------------------------------------------------------------------
 2073 /**
 2074  * This function must be called to get the Location Area Code of a cell.
 2075  *
 2076  * @return The Location Area Code of a cell. UINT16_MAX value is returned if the value is not
 2077  * available.
 2078  *
 2079  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2080  *       function won't return.
 2081  *
 2082  * @note <b>multi-app safe</b>
 2083  */
 2084 //--------------------------------------------------------------------------------------------------
 2085 uint32_t le_mrc_GetNeighborCellLocAreaCode
 2086 (
 2087     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2088         ///< [IN] Cell information reference.
 2089 );
 2090 
 2091 //--------------------------------------------------------------------------------------------------
 2092 /**
 2093  * This function must be called to get the signal strength of a cell.
 2094  *
 2095  * @return The signal strength of a cell in dBm.
 2096  *
 2097  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2098  *       function won't return.
 2099  *
 2100  * @note <b>multi-app safe</b>
 2101  */
 2102 //--------------------------------------------------------------------------------------------------
 2103 int32_t le_mrc_GetNeighborCellRxLevel
 2104 (
 2105     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2106         ///< [IN] Cell information reference.
 2107 );
 2108 
 2109 //--------------------------------------------------------------------------------------------------
 2110 /**
 2111  * This function must be called to get the Radio Access Technology of a cell.
 2112  *
 2113  * @return The Radio Access Technology of a cell.
 2114  *
 2115  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2116  *       function won't return.
 2117  *
 2118  * @note <b>multi-app safe</b>
 2119  */
 2120 //--------------------------------------------------------------------------------------------------
 2121 le_mrc_Rat_t le_mrc_GetNeighborCellRat
 2122 (
 2123     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2124         ///< [IN] Cell information reference.
 2125 );
 2126 
 2127 //--------------------------------------------------------------------------------------------------
 2128 /**
 2129  * This function must be called to get the Ec/Io; the received energy per chip divided by the power
 2130  * density in the band measured in dBm on the primary CPICH channel of serving cell (negative value)
 2131  *
 2132  * @return
 2133  *  - The Ec/Io of a cell given in dB with 1 decimal place. (only applicable for UMTS network).
 2134  *  - INT32_MAX when the value isn't available.
 2135  *
 2136  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2137  *       function won't return.
 2138  *
 2139  * @note <b>multi-app safe</b>
 2140  */
 2141 //--------------------------------------------------------------------------------------------------
 2142 int32_t le_mrc_GetNeighborCellUmtsEcIo
 2143 (
 2144     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2145         ///< [IN] Cell information reference.
 2146 );
 2147 
 2148 //--------------------------------------------------------------------------------------------------
 2149 /**
 2150  * This function must be called to get the RSRP and RSRQ of the Intrafrequency of a LTE cell.
 2151  *
 2152  * @return
 2153  *      - LE_OK on success
 2154  *      - LE_FAULT on failure
 2155  *
 2156  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2157  *       function won't return.
 2158  *
 2159  * @note <b>multi-app safe</b>
 2160  */
 2161 //--------------------------------------------------------------------------------------------------
 2162 le_result_t le_mrc_GetNeighborCellLteIntraFreq
 2163 (
 2164     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2165         ///< [IN] Cell information reference.
 2166     int32_t* rsrqPtr,
 2167         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2168         ///< place
 2169     int32_t* rsrpPtr
 2170         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2171         ///< place
 2172 );
 2173 
 2174 //--------------------------------------------------------------------------------------------------
 2175 /**
 2176  * This function must be called to get the RSRP and RSRQ of the Interfrequency of a LTE cell.
 2177  *
 2178  * @return
 2179  *      - LE_OK on success
 2180  *      - LE_FAULT on failure
 2181  *
 2182  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2183  *       function won't return.
 2184  *
 2185  * @note <b>multi-app safe</b>
 2186  */
 2187 //--------------------------------------------------------------------------------------------------
 2188 le_result_t le_mrc_GetNeighborCellLteInterFreq
 2189 (
 2190     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2191         ///< [IN] Cell information reference.
 2192     int32_t* rsrqPtr,
 2193         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2194         ///< place
 2195     int32_t* rsrpPtr
 2196         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2197         ///< place
 2198 );
 2199 
 2200 //--------------------------------------------------------------------------------------------------
 2201 /**
 2202  * This function must be called to measure the signal metrics. It creates and returns a reference
 2203  * to the signal metrics.
 2204  *
 2205  * @return A reference to the signal metrics.
 2206  * @return NULL if no signal metrics are available.
 2207  *
 2208  * @note <b>multi-app safe</b>
 2209  */
 2210 //--------------------------------------------------------------------------------------------------
 2211 le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics
 2212 (
 2213     void
 2214 );
 2215 
 2216 //--------------------------------------------------------------------------------------------------
 2217 /**
 2218  * This function must be called to delete the the signal metrics.
 2219  *
 2220  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2221  *       reference for validity.
 2222  *
 2223  * @note <b>multi-app safe</b>
 2224  */
 2225 //--------------------------------------------------------------------------------------------------
 2226 void le_mrc_DeleteSignalMetrics
 2227 (
 2228     le_mrc_MetricsRef_t MetricsRef
 2229         ///< [IN] Signal metrics reference.
 2230 );
 2231 
 2232 //--------------------------------------------------------------------------------------------------
 2233 /**
 2234  * This function returns the Radio Access Technology of the signal metrics.
 2235  *
 2236  * @return The Radio Access Technology of the signal measure.
 2237  *
 2238  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2239  *       function won't return.
 2240  *
 2241  * @note <b>multi-app safe</b>
 2242  */
 2243 //--------------------------------------------------------------------------------------------------
 2244 le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics
 2245 (
 2246     le_mrc_MetricsRef_t MetricsRef
 2247         ///< [IN] Signal metrics reference.
 2248 );
 2249 
 2250 //--------------------------------------------------------------------------------------------------
 2251 /**
 2252  * This function returns the signal strength in dBm and the bit error rate measured on GSM network.
 2253  *
 2254  * @return
 2255  *      - LE_OK on success
 2256  *      - LE_FAULT on failure
 2257  *
 2258  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2259  *       function won't return.
 2260  *
 2261  * @note <b>multi-app safe</b>
 2262  */
 2263 //--------------------------------------------------------------------------------------------------
 2264 le_result_t le_mrc_GetGsmSignalMetrics
 2265 (
 2266     le_mrc_MetricsRef_t MetricsRef,
 2267         ///< [IN] Signal metrics reference.
 2268     int32_t* rssiPtr,
 2269         ///< [OUT] Signal strength in dBm
 2270     uint32_t* berPtr
 2271         ///< [OUT] Bit error rate.
 2272 );
 2273 
 2274 //--------------------------------------------------------------------------------------------------
 2275 /**
 2276  * This function returns the signal metrics measured on UMTS or TD-SCDMA networks.
 2277  *
 2278  * @return
 2279  *      - LE_OK on success
 2280  *      - LE_FAULT on failure
 2281  *
 2282  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2283  *       function won't return.
 2284  *
 2285  * @note <b>multi-app safe</b>
 2286  */
 2287 //--------------------------------------------------------------------------------------------------
 2288 le_result_t le_mrc_GetUmtsSignalMetrics
 2289 (
 2290     le_mrc_MetricsRef_t MetricsRef,
 2291         ///< [IN] Signal metrics reference.
 2292     int32_t* ssPtr,
 2293         ///< [OUT] Signal strength in dBm
 2294     uint32_t* blerPtr,
 2295         ///< [OUT] Block error rate
 2296     int32_t* ecioPtr,
 2297         ///< [OUT] Ec/Io value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2298         ///< value)
 2299     int32_t* rscpPtr,
 2300         ///< [OUT] Measured RSCP in dBm (negative value, value INT32_MAX means
 2301         ///< that RSCP is not available)
 2302     int32_t* sinrPtr
 2303         ///< [OUT] Measured SINR in dB (only applicable for TD-SCDMA network, value
 2304         ///< INT32_MAX means that the SINR is not available)
 2305 );
 2306 
 2307 //--------------------------------------------------------------------------------------------------
 2308 /**
 2309  * This function returns the signal metrics measured on LTE network.
 2310  *
 2311  * @return
 2312  *      - LE_OK on success
 2313  *      - LE_FAULT on failure
 2314  *      - sinrPtr and ioPtr return INT32_MAX when the value isn't available.
 2315  *
 2316  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2317  *       function won't return.
 2318  *
 2319  * @note <b>multi-app safe</b>
 2320  */
 2321 //--------------------------------------------------------------------------------------------------
 2322 le_result_t le_mrc_GetLteSignalMetrics
 2323 (
 2324     le_mrc_MetricsRef_t MetricsRef,
 2325         ///< [IN] Signal metrics reference.
 2326     int32_t* ssPtr,
 2327         ///< [OUT] Signal strength in dBm
 2328     uint32_t* blerPtr,
 2329         ///< [OUT] Block error rate
 2330     int32_t* rsrqPtr,
 2331         ///< [OUT] RSRQ value in dB as measured by L1 with 1 decimal place
 2332     int32_t* rsrpPtr,
 2333         ///< [OUT] Current RSRP in dBm as measured by L1 with 1 decimal place
 2334     int32_t* snrPtr
 2335         ///< [OUT] SNR level in dB with 1 decimal place (15 = 1.5 dB)
 2336 );
 2337 
 2338 //--------------------------------------------------------------------------------------------------
 2339 /**
 2340  * This function returns the signal metrics measured on CDMA network.
 2341  *
 2342  * @return
 2343  *      - LE_OK on success
 2344  *      - LE_FAULT on failure
 2345  *      - rscpPtr and sinrPtr return INT32_MAX when the value isn't available.
 2346  *
 2347  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2348  *       function won't return.
 2349  *
 2350  * @note <b>multi-app safe</b>
 2351  */
 2352 //--------------------------------------------------------------------------------------------------
 2353 le_result_t le_mrc_GetCdmaSignalMetrics
 2354 (
 2355     le_mrc_MetricsRef_t MetricsRef,
 2356         ///< [IN] Signal metrics reference.
 2357     int32_t* ssPtr,
 2358         ///< [OUT] Signal strength in dBm
 2359     uint32_t* erPtr,
 2360         ///< [OUT] Frame/Packet error rate
 2361     int32_t* ecioPtr,
 2362         ///< [OUT] ECIO value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2363         ///< value)
 2364     int32_t* sinrPtr,
 2365         ///< [OUT] SINR level in dB with 1 decimal place, (only applicable for
 2366         ///< 1xEV-DO, value INT32_MAX means that the value is not available)
 2367     int32_t* ioPtr
 2368         ///< [OUT] Received IO in dBm (only applicable for 1xEV-DO, value INT32_MAX
 2369         ///< means that the value is not available)
 2370 );
 2371 
 2372 //--------------------------------------------------------------------------------------------------
 2373 /**
 2374  * This function must be called to get the serving Cell Identifier.
 2375  *
 2376  * @return The Cell Identifier. UINT32_MAX value is returned if the value is not available.
 2377  *
 2378  * @note When the module is in UMTS network, the API returns the serving UTRAN Cell Identity (UC-Id)
 2379  * which is used to identify the cell uniquely.
 2380  * It is composed of the Controlling Radio Network Controller Identifier (CRNC-Id, 12 bits) and the
 2381  * Cell Identifier (C-Id, 16 bits). (3GPP 25.401, section 6.1.5)
 2382  * The Cell Identifier is coded in the lower 2 bytes of the 4 bytes UC-Id and the CRNC-Id is coded
 2383  * in the upper 2 bytes.
 2384  * Example: the API returns 7807609 -> 0x772279 (CRNC-Id = 0x77 , cell ID = 0x2279)
 2385  *
 2386  * @note <b>multi-app safe</b>
 2387  */
 2388 //--------------------------------------------------------------------------------------------------
 2389 uint32_t le_mrc_GetServingCellId
 2390 (
 2391     void
 2392 );
 2393 
 2394 //--------------------------------------------------------------------------------------------------
 2395 /**
 2396  * This function must be called to get the Location Area Code of the serving cell.
 2397  *
 2398  * @return The Location Area Code. UINT32_MAX value is returned if the value is not available.
 2399  *
 2400  * @note <b>multi-app safe</b>
 2401  */
 2402 //--------------------------------------------------------------------------------------------------
 2403 uint32_t le_mrc_GetServingCellLocAreaCode
 2404 (
 2405     void
 2406 );
 2407 
 2408 //--------------------------------------------------------------------------------------------------
 2409 /**
 2410  * This function must be called to get the Tracking Area Code of the serving cell (LTE only).
 2411  *
 2412  * @return The Tracking Area Code. UINT16_MAX value is returned if the value is not available.
 2413  *
 2414  * @note <b>multi-app safe</b>
 2415  */
 2416 //--------------------------------------------------------------------------------------------------
 2417 uint16_t le_mrc_GetServingCellLteTracAreaCode
 2418 (
 2419     void
 2420 );
 2421 
 2422 //--------------------------------------------------------------------------------------------------
 2423 /**
 2424  * Get the Bit mask for 2G/3G Band capabilities.
 2425  *
 2426  * @return
 2427  *  - LE_OK              on success
 2428  *  - LE_FAULT           on failure
 2429  *  - LE_UNSUPPORTED     Unable to get the 2G/3G Band capabilities on this platform
 2430  *
 2431  * @note <b>multi-app safe</b>
 2432  */
 2433 //--------------------------------------------------------------------------------------------------
 2434 le_result_t le_mrc_GetBandCapabilities
 2435 (
 2436     le_mrc_BandBitMask_t* bandMaskPtrPtr
 2437         ///< [OUT] Bit mask for 2G/3G Band capabilities.
 2438 );
 2439 
 2440 //--------------------------------------------------------------------------------------------------
 2441 /**
 2442  * Get the Bit mask for LTE Band capabilities.
 2443  *
 2444  * @return
 2445  *  - LE_OK              on success
 2446  *  - LE_FAULT           on failure
 2447  *  - LE_UNSUPPORTED     Unable to get the LTE Band capabilities on this platform
 2448  *
 2449  * @note <b>multi-app safe</b>
 2450  */
 2451 //--------------------------------------------------------------------------------------------------
 2452 le_result_t le_mrc_GetLteBandCapabilities
 2453 (
 2454     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 2455         ///< [OUT] Bit mask for LTE Band capabilities.
 2456 );
 2457 
 2458 //--------------------------------------------------------------------------------------------------
 2459 /**
 2460  * Get the Bit mask for TD-SCDMA Band capabilities.
 2461  *
 2462  * @return
 2463  *  - LE_OK              on success
 2464  *  - LE_FAULT           on failure
 2465  *  - LE_UNSUPPORTED     Unable to get the TD-SCDMA Band Capabilities on this platform
 2466  *
 2467  * @note <b>multi-app safe</b>
 2468  */
 2469 //--------------------------------------------------------------------------------------------------
 2470 le_result_t le_mrc_GetTdScdmaBandCapabilities
 2471 (
 2472     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 2473         ///< [OUT] Bit mask for TD-SCDMA Band capabilities.
 2474 );
 2475 
 2476 //--------------------------------------------------------------------------------------------------
 2477 /**
 2478  * Add handler function for EVENT 'le_mrc_NetworkReject'
 2479  *
 2480  * Event to report network reject indication.
 2481  *
 2482  */
 2483 //--------------------------------------------------------------------------------------------------
 2484 le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler
 2485 (
 2486     le_mrc_NetworkRejectHandlerFunc_t handlerPtr,
 2487         ///< [IN]
 2488     void* contextPtr
 2489         ///< [IN]
 2490 );
 2491 
 2492 //--------------------------------------------------------------------------------------------------
 2493 /**
 2494  * Remove handler function for EVENT 'le_mrc_NetworkReject'
 2495  */
 2496 //--------------------------------------------------------------------------------------------------
 2497 void le_mrc_RemoveNetworkRejectHandler
 2498 (
 2499     le_mrc_NetworkRejectHandlerRef_t handlerRef
 2500         ///< [IN]
 2501 );
 2502 
 2503 //--------------------------------------------------------------------------------------------------
 2504 /**
 2505  * Add handler function for EVENT 'le_mrc_JammingDetectionEvent'
 2506  *
 2507  * This event provides information on jamming detection.
 2508  */
 2509 //--------------------------------------------------------------------------------------------------
 2510 le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler
 2511 (
 2512     le_mrc_JammingDetectionHandlerFunc_t handlerPtr,
 2513         ///< [IN]
 2514     void* contextPtr
 2515         ///< [IN]
 2516 );
 2517 
 2518 //--------------------------------------------------------------------------------------------------
 2519 /**
 2520  * Remove handler function for EVENT 'le_mrc_JammingDetectionEvent'
 2521  */
 2522 //--------------------------------------------------------------------------------------------------
 2523 void le_mrc_RemoveJammingDetectionEventHandler
 2524 (
 2525     le_mrc_JammingDetectionEventHandlerRef_t handlerRef
 2526         ///< [IN]
 2527 );
 2528 
 2529 //--------------------------------------------------------------------------------------------------
 2530 /**
 2531  * Start the jamming detection monitoring.
 2532  *
 2533  * @warning The jamming detection feature might be limited by the platform.
 2534  *          Please refer to the platform documentation @ref platformConstraintsMdc.
 2535  *
 2536  * @return
 2537  *  - LE_OK             The function succeeded.
 2538  *  - LE_FAULT          The function failed.
 2539  *  - LE_DUPLICATE      The feature is already activated and an activation is requested.
 2540  *  - LE_UNSUPPORTED    The feature is not supported.
 2541  */
 2542 //--------------------------------------------------------------------------------------------------
 2543 le_result_t le_mrc_StartJammingDetection
 2544 (
 2545     void
 2546 );
 2547 
 2548 //--------------------------------------------------------------------------------------------------
 2549 /**
 2550  * Stop the jamming detection monitoring.
 2551  *
 2552  * @return
 2553  *  - LE_OK             The function succeeded.
 2554  *  - LE_FAULT          The function failed or the application did not start the jamming detection.
 2555  *  - LE_UNSUPPORTED    The feature is not supported.
 2556  */
 2557 //--------------------------------------------------------------------------------------------------
 2558 le_result_t le_mrc_StopJammingDetection
 2559 (
 2560     void
 2561 );
 2562 
 2563 #endif // LE_MRC_INTERFACE_H_INCLUDE_GUARD
le_mrc_GetLteBandCapabilities
le_result_t le_mrc_GetLteBandCapabilities(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
le_mrc_GetNeighborCellId
uint32_t le_mrc_GetNeighborCellId(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_GetPreferredOperatorDetails
le_result_t le_mrc_GetPreferredOperatorDetails(le_mrc_PreferredOperatorRef_t preferredOperatorRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize, le_mrc_RatBitMask_t *ratMaskPtr)
LE_MRC_RAT_TDSCDMA
TD-SCDMA networks. 
Definition: le_mrc_interface.h:769
LE_MRC_BITMASK_RAT_LTE
LTE RAT Bit Mask. 
Definition: le_mrc_interface.h:839
le_mrc_GetGsmSignalMetrics
le_result_t le_mrc_GetGsmSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *rssiPtr, uint32_t *berPtr)
LE_MRC_BITMASK_RAT_CDMA
CDMA RAT Bit Mask. 
Definition: le_mrc_interface.h:840
le_mrc_GetSignalQual
le_result_t le_mrc_GetSignalQual(uint32_t *qualityPtr)
le_mrc_GetServingCellLteTracAreaCode
uint16_t le_mrc_GetServingCellLteTracAreaCode(void)
le_mrc_DeleteNeighborCellsInfo
void le_mrc_DeleteNeighborCellsInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_GetNextNeighborCellInfo
le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_RemovePacketSwitchedChangeHandler
void le_mrc_RemovePacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef)
le_mrc_GetNetRegState
le_result_t le_mrc_GetNetRegState(le_mrc_NetRegState_t *statePtr)
le_mrc_AddRatChangeHandler
le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler(le_mrc_RatChangeHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_SetAutomaticRegisterMode
le_result_t le_mrc_SetAutomaticRegisterMode(void)
le_mrc_PreferredOperatorListRef_t
struct le_mrc_PreferredOperatorList * le_mrc_PreferredOperatorListRef_t
Definition: le_mrc_interface.h:706
le_mrc_SetSignalStrengthIndThresholds
le_result_t le_mrc_SetSignalStrengthIndThresholds(le_mrc_Rat_t rat, int32_t lowerRangeThreshold, int32_t upperRangeThreshold)
le_mrc_PreferredOperatorRef_t
struct le_mrc_PreferredOperator * le_mrc_PreferredOperatorRef_t
Definition: le_mrc_interface.h:698
le_mrc_RemovePreferredOperator
le_result_t le_mrc_RemovePreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
le_mrc_AddSignalStrengthChangeHandler
le_mrc_SignalStrengthChangeHandlerRef_t le_mrc_AddSignalStrengthChangeHandler(le_mrc_Rat_t rat, int32_t lowerRangeThreshold, int32_t upperRangeThreshold, le_mrc_SignalStrengthChangeHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_GetRadioPower
le_result_t le_mrc_GetRadioPower(le_onoff_t *powerPtr)
le_mrc_GetServingCellId
uint32_t le_mrc_GetServingCellId(void)
le_mrc_AddNetRegStateEventHandler
le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler(le_mrc_NetRegStateHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_DisconnectHandler_t
void(* le_mrc_DisconnectHandler_t)(void *)
Definition: le_mrc_interface.h:451
le_result_t
le_result_t
Definition: le_basics.h:35
le_mrc_SetRadioPower
le_result_t le_mrc_SetRadioPower(le_onoff_t power)
le_mrc_GetCurrentNetworkMccMnc
le_result_t le_mrc_GetCurrentNetworkMccMnc(char *mccStr, size_t mccStrSize, char *mncStr, size_t mncStrSize)
le_mrc_NeighborCellsRef_t
struct le_mrc_NeighborCells * le_mrc_NeighborCellsRef_t
Definition: le_mrc_interface.h:722
le_mrc_SetTdScdmaBandPreferences
le_result_t le_mrc_SetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t bandMask)
le_mrc_MetricsRef_t
struct le_mrc_Metrics * le_mrc_MetricsRef_t
Definition: le_mrc_interface.h:730
le_mrc_GetPacketSwitchedState
le_result_t le_mrc_GetPacketSwitchedState(le_mrc_NetRegState_t *statePtr)
LE_MRC_RAT_UMTS
UMTS networks. 
Definition: le_mrc_interface.h:767
LE_MRC_BITMASK_RAT_TDSCDMA
TD-SCDMA RAT Bit Mask. 
Definition: le_mrc_interface.h:838
le_mrc_GetRatOfSignalMetrics
le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_mrc_NetRegStateEventHandlerRef_t
struct le_mrc_NetRegStateEventHandler * le_mrc_NetRegStateEventHandlerRef_t
Definition: le_mrc_interface.h:852
le_mrc_GetTdScdmaBandPreferences
le_result_t le_mrc_GetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
le_mrc_DeleteSignalMetrics
void le_mrc_DeleteSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_mrc_RatChangeHandlerRef_t
struct le_mrc_RatChangeHandler * le_mrc_RatChangeHandlerRef_t
Definition: le_mrc_interface.h:860
le_mrc_GetFirstNeighborCellInfo
le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
LE_MRC_REG_ROAMING
Registered to a roaming network. 
Definition: le_mrc_interface.h:748
le_mrc_ManualSelectionHandlerFunc_t
void(* le_mrc_ManualSelectionHandlerFunc_t)(le_result_t result, void *contextPtr)
Definition: le_mrc_interface.h:974
le_mrc_GetCdmaSignalMetrics
le_result_t le_mrc_GetCdmaSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *erPtr, int32_t *ecioPtr, int32_t *sinrPtr, int32_t *ioPtr)
le_mrc_SetManualRegisterMode
le_result_t le_mrc_SetManualRegisterMode(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
le_mrc_GetNeighborCellLteIntraFreq
le_result_t le_mrc_GetNeighborCellLteIntraFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
LE_MRC_JAMMING_STATUS_NULL
No jamming suspicion; radio environment is considered normal. 
Definition: le_mrc_interface.h:810
le_mrc_ScanInformationListRef_t
struct le_mrc_ScanInformationList * le_mrc_ScanInformationListRef_t
Definition: le_mrc_interface.h:690
le_mrc_TryConnectService
le_result_t le_mrc_TryConnectService(void)
le_mrc_SetSignalStrengthIndDelta
le_result_t le_mrc_SetSignalStrengthIndDelta(le_mrc_Rat_t rat, uint16_t delta)
le_mrc_PacketSwitchedChangeHandlerFunc_t
void(* le_mrc_PacketSwitchedChangeHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:930
LE_MRC_RAT_LTE
LTE network. 
Definition: le_mrc_interface.h:771
le_mrc_RatChangeHandlerFunc_t
void(* le_mrc_RatChangeHandlerFunc_t)(le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_interface.h:916
le_mrc_GetRatPreferences
le_result_t le_mrc_GetRatPreferences(le_mrc_RatBitMask_t *ratMaskPtrPtr)
le_mrc_CellInfoRef_t
struct le_mrc_CellInfo * le_mrc_CellInfoRef_t
Definition: le_mrc_interface.h:714
le_mrc_PerformCellularNetworkScan
le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan(le_mrc_RatBitMask_t ratMask)
le_mrc_SetBandPreferences
le_result_t le_mrc_SetBandPreferences(le_mrc_BandBitMask_t bandMask)
le_mrc_SetRatPreferences
le_result_t le_mrc_SetRatPreferences(le_mrc_RatBitMask_t ratMask)
le_mrc_DeleteCellularNetworkScan
void le_mrc_DeleteCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
le_mrc_GetNeighborCellRxLevel
int32_t le_mrc_GetNeighborCellRxLevel(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_AddPacketSwitchedChangeHandler
le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr, void *contextPtr)
le_mrc_GetNeighborCellLteInterFreq
le_result_t le_mrc_GetNeighborCellLteInterFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
le_mrc_RemoveSignalStrengthChangeHandler
void le_mrc_RemoveSignalStrengthChangeHandler(le_mrc_SignalStrengthChangeHandlerRef_t handlerRef)
le_mrc_SignalStrengthChangeHandlerRef_t
struct le_mrc_SignalStrengthChangeHandler * le_mrc_SignalStrengthChangeHandlerRef_t
Definition: le_mrc_interface.h:876
le_mrc_GetNeighborCellsInfo
le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo(void)
le_mrc_GetCellularNetworkRat
le_mrc_Rat_t le_mrc_GetCellularNetworkRat(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_RemoveRatChangeHandler
void le_mrc_RemoveRatChangeHandler(le_mrc_RatChangeHandlerRef_t handlerRef)
le_mrc_NetworkRejectHandlerRef_t
struct le_mrc_NetworkRejectHandler * le_mrc_NetworkRejectHandlerRef_t
Definition: le_mrc_interface.h:884
LE_MRC_REG_HOME
Registered, home network. 
Definition: le_mrc_interface.h:742
LE_MRC_JAMMING_STATUS_HIGH
Definition: le_mrc_interface.h:818
le_mrc_JammingDetectionHandlerFunc_t
void(* le_mrc_JammingDetectionHandlerFunc_t)(le_mrc_JammingReport_t report, le_mrc_JammingStatus_t status, void *contextPtr)
Definition: le_mrc_interface.h:1005
le_mrc_GetServingCellLocAreaCode
uint32_t le_mrc_GetServingCellLocAreaCode(void)
le_mrc_GetFirstPreferredOperator
le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_PerformCellularNetworkScanAsync
void le_mrc_PerformCellularNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_GetLteSignalMetrics
le_result_t le_mrc_GetLteSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *blerPtr, int32_t *rsrqPtr, int32_t *rsrpPtr, int32_t *snrPtr)
LE_MRC_RAT_GSM
GSM network. 
Definition: le_mrc_interface.h:765
le_mrc_NetRegStateHandlerFunc_t
void(* le_mrc_NetRegStateHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:902
le_mrc_RemoveNetworkRejectHandler
void le_mrc_RemoveNetworkRejectHandler(le_mrc_NetworkRejectHandlerRef_t handlerRef)
LE_MRC_BITMASK_RAT_ALL
To Set all RAT preference Bit Mask. 
Definition: le_mrc_interface.h:841
le_mrc_RatBitMask_t
le_mrc_RatBitMask_t
Definition: le_mrc_interface.h:834
le_mrc_GetPlatformSpecificRegistrationErrorCode
int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode(void)
LE_MRC_JAMMING_REPORT_FINAL
Final jamming status report. 
Definition: le_mrc_interface.h:791
le_mrc_GetNextPreferredOperator
le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
LE_MRC_RAT_CDMA
CDMA network. 
Definition: le_mrc_interface.h:773
le_mrc_SetManualRegisterModeAsync
void le_mrc_SetManualRegisterModeAsync(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_ManualSelectionHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_Rat_t
le_mrc_Rat_t
Definition: le_mrc_interface.h:761
le_mrc_GetTdScdmaBandCapabilities
le_result_t le_mrc_GetTdScdmaBandCapabilities(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
le_mrc_GetRegisterMode
le_result_t le_mrc_GetRegisterMode(bool *isManualPtrPtr, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
LE_MRC_JAMMING_STATUS_LOW
Definition: le_mrc_interface.h:812
le_mrc_JammingReport_t
le_mrc_JammingReport_t
Definition: le_mrc_interface.h:789
LE_MRC_RAT_UNKNOWN
Unknown. 
Definition: le_mrc_interface.h:763
le_mrc_SetLteBandPreferences
le_result_t le_mrc_SetLteBandPreferences(le_mrc_LteBandBitMask_t bandMask)
le_mrc_IsCellularNetworkForbidden
bool le_mrc_IsCellularNetworkForbidden(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_ScanInformationRef_t
struct le_mrc_ScanInformation * le_mrc_ScanInformationRef_t
Definition: le_mrc_interface.h:682
le_mrc_GetNeighborCellUmtsEcIo
int32_t le_mrc_GetNeighborCellUmtsEcIo(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_GetCellularNetworkMccMnc
le_result_t le_mrc_GetCellularNetworkMccMnc(le_mrc_ScanInformationRef_t scanInformationRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
le_mrc_GetNextCellularNetworkScan
le_mrc_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
LE_MRC_JAMMING_STATUS_MEDIUM
Definition: le_mrc_interface.h:815
le_mrc_SetServerDisconnectHandler
void le_mrc_SetServerDisconnectHandler(le_mrc_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_mrc_GetCurrentNetworkName
le_result_t le_mrc_GetCurrentNetworkName(char *nameStr, size_t nameStrSize)
LE_MRC_JAMMING_REPORT_INTERMEDIATE
Intermediate jamming status report. 
Definition: le_mrc_interface.h:793
le_mrc_GetRadioAccessTechInUse
le_result_t le_mrc_GetRadioAccessTechInUse(le_mrc_Rat_t *ratPtr)
le_mrc_GetPreferredOperatorsList
le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList(void)
le_mrc_GetLteBandPreferences
le_result_t le_mrc_GetLteBandPreferences(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
le_mrc_AddPreferredOperator
le_result_t le_mrc_AddPreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_RatBitMask_t ratMask)
le_mrc_GetBandCapabilities
le_result_t le_mrc_GetBandCapabilities(le_mrc_BandBitMask_t *bandMaskPtrPtr)
le_mrc_IsCellularNetworkHome
bool le_mrc_IsCellularNetworkHome(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_GetCellularNetworkName
le_result_t le_mrc_GetCellularNetworkName(le_mrc_ScanInformationRef_t scanInformationRef, char *namePtr, size_t namePtrSize)
le_mrc_JammingStatus_t
le_mrc_JammingStatus_t
Definition: le_mrc_interface.h:806
le_mrc_ConnectService
void le_mrc_ConnectService(void)
le_mrc_DeletePreferredOperatorsList
void le_mrc_DeletePreferredOperatorsList(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_AddJammingDetectionEventHandler
le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler(le_mrc_JammingDetectionHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_StartJammingDetection
le_result_t le_mrc_StartJammingDetection(void)
legato.h
le_mrc_NetworkRejectHandlerFunc_t
void(* le_mrc_NetworkRejectHandlerFunc_t)(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_interface.h:988
LE_MRC_REG_SEARCHING
Not registered but currently searching for a new operator. 
Definition: le_mrc_interface.h:744
le_mrc_StopJammingDetection
le_result_t le_mrc_StopJammingDetection(void)
le_mrc_BandBitMask_t
le_mrc_BandBitMask_t
Definition: le_mrc_interface.h:571
le_mrc_GetUmtsSignalMetrics
le_result_t le_mrc_GetUmtsSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *blerPtr, int32_t *ecioPtr, int32_t *rscpPtr, int32_t *sinrPtr)
le_mrc_SignalStrengthChangeHandlerFunc_t
void(* le_mrc_SignalStrengthChangeHandlerFunc_t)(int32_t ss, void *contextPtr)
Definition: le_mrc_interface.h:944
le_mrc_DisconnectService
void le_mrc_DisconnectService(void)
le_mrc_IsCellularNetworkInUse
bool le_mrc_IsCellularNetworkInUse(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_CellularNetworkScanHandlerFunc_t
void(* le_mrc_CellularNetworkScanHandlerFunc_t)(le_mrc_ScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_interface.h:959
le_mrc_NetRegState_t
le_mrc_NetRegState_t
Definition: le_mrc_interface.h:738
le_mrc_GetNeighborCellLocAreaCode
uint32_t le_mrc_GetNeighborCellLocAreaCode(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_MeasureSignalMetrics
le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics(void)
le_mrc_LteBandBitMask_t
le_mrc_LteBandBitMask_t
Definition: le_mrc_interface.h:621
LE_MRC_REG_UNKNOWN
Unknown state. 
Definition: le_mrc_interface.h:750
le_mrc_IsCellularNetworkAvailable
bool le_mrc_IsCellularNetworkAvailable(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_JammingDetectionEventHandlerRef_t
struct le_mrc_JammingDetectionEventHandler * le_mrc_JammingDetectionEventHandlerRef_t
Definition: le_mrc_interface.h:892
LE_MRC_REG_DENIED
Registration was denied, usually because of invalid access credentials. 
Definition: le_mrc_interface.h:746
LE_MRC_BITMASK_RAT_UMTS
UMTS RAT Bit Mask. 
Definition: le_mrc_interface.h:837
le_mrc_TdScdmaBandBitMask_t
le_mrc_TdScdmaBandBitMask_t
Definition: le_mrc_interface.h:665
LE_MRC_REG_NONE
Not registered and not currently searching for new operator. 
Definition: le_mrc_interface.h:740
le_mrc_RemoveJammingDetectionEventHandler
void le_mrc_RemoveJammingDetectionEventHandler(le_mrc_JammingDetectionEventHandlerRef_t handlerRef)
LE_MRC_BITMASK_RAT_GSM
GSM RAT Bit Mask. 
Definition: le_mrc_interface.h:836
le_mrc_AddNetworkRejectHandler
le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler(le_mrc_NetworkRejectHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_GetBandPreferences
le_result_t le_mrc_GetBandPreferences(le_mrc_BandBitMask_t *bandMaskPtrPtr)
le_mrc_PacketSwitchedChangeHandlerRef_t
struct le_mrc_PacketSwitchedChangeHandler * le_mrc_PacketSwitchedChangeHandlerRef_t
Definition: le_mrc_interface.h:868
le_mrc_RemoveNetRegStateEventHandler
void le_mrc_RemoveNetRegStateEventHandler(le_mrc_NetRegStateEventHandlerRef_t handlerRef)
le_mrc_GetFirstCellularNetworkScan
le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
LE_MRC_JAMMING_STATUS_UNKNOWN
Status is unknown. 
Definition: le_mrc_interface.h:808
le_mrc_GetNeighborCellRat
le_mrc_Rat_t le_mrc_GetNeighborCellRat(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_onoff_t
le_onoff_t
Definition: le_basics.h:70
LE_MRC_JAMMING_STATUS_JAMMED
Definition: le_mrc_interface.h:822