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_PcinetworkScan PCI Network Scan
  300  *
  301  * Call le_mrc_PerformPciNetworkScan() to fill a list of all neighboring cells.
  302  * The Pci scan is used to get the according MCC/MNC for each neightboring cells ID. Not that a cell
  303  * may contain more than one MCC/MNC when sevral plmn sharing the same cell.
  304  *
  305  * You can go through all Scan Information by calling le_mrc_GetFirstPciScanInfo() and
  306  * le_mrc_GetNextPciScanInfo(). Note that each cell info contains a list of mcc/mnc, you can go
  307  * through all mcc/mnc Information for each cell by calling le_mrc_GetFirstPlmnInfo()
  308  * and le_mrc_GetNextPlmnInfo(), this two APIs return a reference to PlmnInformation, then use
  309  * le_mrc_GetPciScanMccMnc() by giving this reference as parameter to get the Mcc/Mnc of the Plmn.
  310  *
  311  * Call le_mrc_PerformPciNetworkScanAsync()to start a pci scan asynchronously. The
  312  * function is not blocking. The scan list reference will be returned with the handler function
  313  * response (@c le_mrc_PciNetworkScanHandlerFunc_t).
  314  *
  315  *
  316  * For Pci Network Scan Information, you can call:
  317  *
  318  *  - le_mrc_GetPciScanCellId() to get the physical id of each cell.
  319  *  - le_mrc_GetPciScanGlobalCellId() to get the global id of each cell.
  320  *  - le_mrc_GetPciScanMccMnc() to get the Mcc/Mnc of each plmn on each cell.
  321  *  - le_mrc_DeletePciNetworkScan() should be called when you do not need the list anymore.
  322  *
  323  * A sample code can be seen in the following page:
  324  * - @subpage c_mrcPciScan
  325  *
  326  * @section le_mrc_ngbr Neighboring Cells Information
  327  *
  328  * @warning The following functions do not apply to CDMA network.
  329  *
  330  * You must call le_mrc_GetNeighborCellsInfo() to retrieve the neighboring cells
  331  * information. It returns a reference of le_mrc_NeighborCellsRef_t type.
  332  *
  333  * When the neighboring cells information is no longer needed, you must call
  334  * le_mrc_DeleteNeighborCellsInfo() to free all allocated resources associated with the
  335  * object.
  336  *
  337  * Then, you can use the following function to get the information:
  338  * - le_mrc_GetFirstNeighborCellInfo() and le_mrc_GetFirstNeighborCellInfo() allow to go among
  339  *   the single cell information retrieved with le_mrc_GetNeighborCellsInfo(). These two functions
  340  *   return a reference of le_mrc_CellInfoRef_t type.
  341  * - le_mrc_GetNeighborCellId() gets the identifier of the cell specified with the
  342  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT32_MAX value is
  343  *   returned if the value is not available.
  344  * - le_mrc_GetNeighborCellLocAreaCode() gets the location area code of the cell specified with the
  345  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT16_MAX value is
  346  *   returned if the value is not available.
  347  * - le_mrc_GetNeighborCellRxLevel() gets the signal strength (in dBm) of the cell specified with
  348  *   the le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT).
  349  * - le_mrc_GetNeighborCellRat() gets the Radio Access Technology of the cell specified with
  350  *   the le_mrc_CellInfoRef_t parameter.
  351  * - le_mrc_GetNeighborCellUmtsEcIo() gets the Ec/Io (the received energy per chip divided by the
  352  *   power density in the band measured in dBm on the primary CPICH channel of serving cell) of the
  353  *   cell specified with the le_mrc_CellInfoRef_t parameter.
  354  * - le_mrc_GetNeighborCellLteIntraFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  355  *   specified with the le_mrc_CellInfoRef_t parameter.
  356  * - le_mrc_GetNeighborCellLteInterFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  357  *   specified with the le_mrc_CellInfoRef_t parameter.
  358  *
  359  * A sample code can be seen in the following page:
  360  * - @subpage c_mrcNeighborCells
  361  *
  362  * @section le_mrc_jamming Jamming detection
  363  *
  364  * The jamming detection algorithm is based on power measurements and cell synchronization actions
  365  * performed during a GSM network scan procedure.
  366  * During this procedure some intermediate results are reported, that allows user to take some
  367  * preventive actions if necessary.
  368  * This result is reported as a jammed state probability. See @ref le_mrc_JammingStatus_t
  369  * enumeration for probability description.
  370  * Each time the jamming status changes during the scan procedure, it is reported to the user.
  371  * See @ref le_mrc_JammingReport_t enumeration for details.
  372  *
  373  * The jamming status is reported:
  374  * - In an unsolicited way, each time the protocol stack initiates a scan for PLMN selection or
  375  * reselection.
  376  * - On user demand, when a user PLMN scan is performed.
  377  *
  378  * Call le_mrc_StartJammingDetection() to launch jamming monitoring.
  379  * By registering a handler by calling le_mrc_AddJammingDetectionEventHandler(), the notification
  380  * on jamming detection can be sent to the registered application.
  381  *
  382  * For each jamming detection monitoring, the following APIs can be called:
  383  * - le_mrc_StartJammingDetection() to start the jamming monitoring.
  384  * - le_mrc_StopJammingDetection() to stop the jamming monitoring.
  385  * - le_mrc_AddJammingDetectionEventHandler() to register an event handler.
  386  * - le_mrc_RemoveJammingDetectionEventHandler() to remove an event handler.
  387  *
  388  * @section le_mrc_sar SAR backoff
  389  * SAR (Specific Absorption Rate) is a measure of RF energy absorption by the human body.
  390  * Users can dynamically select a pre-configured SAR backoff state so they can adjust the SAR
  391  * depending on their needs.  To manage SAR backoff, these API should be used:
  392  * - le_mrc_SetSarBackoffState() to set a new SAR backoff state.
  393  * - le_mrc_GetSarBackoffState() to get the current SAR backoff state.
  394  * This feature may be unsupported by some targets. Also, the number of supported states may vary
  395  * depending on the target. Please refer to @ref platformConstraintsMdc for further details.
  396  *
  397  * <HR>
  398  *
  399  * Copyright (C) Sierra Wireless Inc.
  400  */
  401 /**
  402  * @page c_mrcRadioPower Sample code for Radio Power Management
  403  *
  404  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Radio Power
  405  */
  406 /**
  407  * @page c_mrcRadioConfigurationPreferences Sample code for Radio Configuration Preferences
  408  *
  409  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Preferences
  410  *
  411  */
  412 /**
  413  * @page c_mrcRAT Sample code for Radio Access Technology
  414  *
  415  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT in Use
  416  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT Preferences
  417  *
  418  */
  419 /**
  420  * @page c_mrcNetworkRegistration Sample code for Network Registration
  421  *
  422  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Register
  423  *
  424  */
  425 /**
  426  * @page c_mrcQuality Sample code for Signal Quality
  427  *
  428  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Signal Quality
  429  *
  430  */
  431 /**
  432  * @page c_mrcLocationinformation Sample code for Location information
  433  *
  434  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Loc information
  435  *
  436  */
  437 /**
  438  * @page c_mrcBandCapabilities Sample code for Band Capabilities
  439  *
  440  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Capabilities
  441  *
  442  */
  443 /**
  444  * @page c_mrcGetCurrentNetwork Sample code for Get Current Network Information
  445  *
  446  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Get Network
  447  *
  448  */
  449 /**
  450  * @page c_mrcNetworkScan Sample code for Network Scan
  451  *
  452  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Network Scan
  453  *
  454  */
  455 /**
  456  * @page c_mrcPciScan Sample code for LTE PCI Scan
  457  *
  458  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" PCI Scan
  459  *
  460  */
  461 /**
  462  * @page c_mrcNeighborCells Sample code for Neighboring Cells Information
  463  *
  464  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Neighbor Cells
  465  *
  466  */
  467 /**
  468  * @page c_mrcGetService Sample code for Get the Current Packet Switched state
  469  *
  470  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Service State
  471  *
  472  */
  473 /**
  474  * @file le_mrc_interface.h
  475  *
  476  * Legato @ref c_mrc include file.
  477  *
  478  * Copyright (C) Sierra Wireless Inc.
  479  */
  480 
  481 #ifndef LE_MRC_INTERFACE_H_INCLUDE_GUARD
  482 #define LE_MRC_INTERFACE_H_INCLUDE_GUARD
  483 
  484 
  485 #include "legato.h"
  486 
  487 
  488 //--------------------------------------------------------------------------------------------------
  489 /**
  490  * Type for handler called when a server disconnects.
  491  */
  492 //--------------------------------------------------------------------------------------------------
  493 typedef void (*le_mrc_DisconnectHandler_t)(void *);
  494 
  495 //--------------------------------------------------------------------------------------------------
  496 /**
  497  *
  498  * Connect the current client thread to the service providing this API. Block until the service is
  499  * available.
  500  *
  501  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  502  * called before any other functions in this API.  Normally, ConnectService is automatically called
  503  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  504  *
  505  * This function is created automatically.
  506  */
  507 //--------------------------------------------------------------------------------------------------
  508 void le_mrc_ConnectService
  509 (
  510     void
  511 );
  512 
  513 //--------------------------------------------------------------------------------------------------
  514 /**
  515  *
  516  * Try to connect the current client thread to the service providing this API. Return with an error
  517  * if the service is not available.
  518  *
  519  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  520  * called before any other functions in this API.  Normally, ConnectService is automatically called
  521  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  522  *
  523  * This function is created automatically.
  524  *
  525  * @return
  526  *  - LE_OK if the client connected successfully to the service.
  527  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  528  *    bound.
  529  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  530  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  531  */
  532 //--------------------------------------------------------------------------------------------------
  533 le_result_t le_mrc_TryConnectService
  534 (
  535     void
  536 );
  537 
  538 //--------------------------------------------------------------------------------------------------
  539 /**
  540  * Set handler called when server disconnection is detected.
  541  *
  542  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  543  * to continue without exiting, it should call longjmp() from inside the handler.
  544  */
  545 //--------------------------------------------------------------------------------------------------
  546 void le_mrc_SetServerDisconnectHandler
  547 (
  548     le_mrc_DisconnectHandler_t disconnectHandler,
  549     void *contextPtr
  550 );
  551 
  552 //--------------------------------------------------------------------------------------------------
  553 /**
  554  *
  555  * Disconnect the current client thread from the service providing this API.
  556  *
  557  * Normally, this function doesn't need to be called. After this function is called, there's no
  558  * longer a connection to the service, and the functions in this API can't be used. For details, see
  559  * @ref apiFilesC_client.
  560  *
  561  * This function is created automatically.
  562  */
  563 //--------------------------------------------------------------------------------------------------
  564 void le_mrc_DisconnectService
  565 (
  566     void
  567 );
  568 
  569 
  570 //--------------------------------------------------------------------------------------------------
  571 /**
  572  * Mobile Country Code length
  573  */
  574 //--------------------------------------------------------------------------------------------------
  575 #define LE_MRC_MCC_LEN 3
  576 
  577 //--------------------------------------------------------------------------------------------------
  578 /**
  579  * Mobile Country Code length
  580  * One extra byte is added for the null character.
  581  */
  582 //--------------------------------------------------------------------------------------------------
  583 #define LE_MRC_MCC_BYTES 4
  584 
  585 //--------------------------------------------------------------------------------------------------
  586 /**
  587  * Mobile Network Code length
  588  */
  589 //--------------------------------------------------------------------------------------------------
  590 #define LE_MRC_MNC_LEN 3
  591 
  592 //--------------------------------------------------------------------------------------------------
  593 /**
  594  * Mobile Network Code length
  595  * One extra byte is added for the null character.
  596  */
  597 //--------------------------------------------------------------------------------------------------
  598 #define LE_MRC_MNC_BYTES 4
  599 
  600 //--------------------------------------------------------------------------------------------------
  601 /**
  602  * Cellular Network length.
  603  *
  604  */
  605 //--------------------------------------------------------------------------------------------------
  606 #define LE_MRC_NETWORK_NAME_MAX_LEN 100
  607 
  608 //--------------------------------------------------------------------------------------------------
  609 /**
  610  * 2G/3G Band Bit Mask (64 bits)
  611  */
  612 //--------------------------------------------------------------------------------------------------
  613 typedef enum
  614 {
  615     LE_MRC_BITMASK_BAND_CLASS_0_A_SYSTEM = 0x1,
  616     LE_MRC_BITMASK_BAND_CLASS_0_B_SYSTEM = 0x2,
  617     LE_MRC_BITMASK_BAND_CLASS_1_ALL_BLOCKS = 0x4,
  618     LE_MRC_BITMASK_BAND_CLASS_2_PLACEHOLDER = 0x8,
  619     LE_MRC_BITMASK_BAND_CLASS_3_A_SYSTEM = 0x10,
  620     LE_MRC_BITMASK_BAND_CLASS_4_ALL_BLOCKS = 0x20,
  621     LE_MRC_BITMASK_BAND_CLASS_5_ALL_BLOCKS = 0x40,
  622     LE_MRC_BITMASK_BAND_CLASS_6 = 0x80,
  623     LE_MRC_BITMASK_BAND_CLASS_7 = 0x100,
  624     LE_MRC_BITMASK_BAND_CLASS_8 = 0x200,
  625     LE_MRC_BITMASK_BAND_CLASS_9 = 0x400,
  626     LE_MRC_BITMASK_BAND_CLASS_10 = 0x800,
  627     LE_MRC_BITMASK_BAND_CLASS_11 = 0x1000,
  628     LE_MRC_BITMASK_BAND_CLASS_12 = 0x2000,
  629     LE_MRC_BITMASK_BAND_CLASS_14 = 0x4000,
  630     LE_MRC_BITMASK_BAND_CLASS_15 = 0x8000,
  631     LE_MRC_BITMASK_BAND_CLASS_16 = 0x10000,
  632     LE_MRC_BITMASK_BAND_CLASS_17 = 0x20000,
  633     LE_MRC_BITMASK_BAND_CLASS_18 = 0x40000,
  634     LE_MRC_BITMASK_BAND_CLASS_19 = 0x80000,
  635     LE_MRC_BITMASK_BAND_GSM_DCS_1800 = 0x100000,
  636     LE_MRC_BITMASK_BAND_EGSM_900 = 0x200000,
  637     LE_MRC_BITMASK_BAND_PRI_GSM_900 = 0x400000,
  638     LE_MRC_BITMASK_BAND_GSM_450 = 0x800000,
  639     LE_MRC_BITMASK_BAND_GSM_480 = 0x1000000,
  640     LE_MRC_BITMASK_BAND_GSM_750 = 0x2000000,
  641     LE_MRC_BITMASK_BAND_GSM_850 = 0x4000000,
  642     LE_MRC_BITMASK_BAND_GSMR_900 = 0x8000000,
  643     LE_MRC_BITMASK_BAND_GSM_PCS_1900 = 0x10000000,
  644     LE_MRC_BITMASK_BAND_WCDMA_EU_J_CH_IMT_2100 = 0x20000000,
  645     LE_MRC_BITMASK_BAND_WCDMA_US_PCS_1900 = 0x40000000,
  646     LE_MRC_BITMASK_BAND_WCDMA_EU_CH_DCS_1800 = 0x80000000,
  647     LE_MRC_BITMASK_BAND_WCDMA_US_1700 = 0x100000000,
  648     LE_MRC_BITMASK_BAND_WCDMA_US_850 = 0x200000000,
  649     LE_MRC_BITMASK_BAND_WCDMA_J_800 = 0x400000000,
  650     LE_MRC_BITMASK_BAND_WCDMA_EU_2600 = 0x800000000,
  651     LE_MRC_BITMASK_BAND_WCDMA_EU_J_900 = 0x1000000000,
  652     LE_MRC_BITMASK_BAND_WCDMA_J_1700 = 0x2000000000
  653 }
  654 le_mrc_BandBitMask_t;
  655 
  656 
  657 //--------------------------------------------------------------------------------------------------
  658 /**
  659  * LTE Band Bit Mask (64 bits)
  660  *
  661  */
  662 //--------------------------------------------------------------------------------------------------
  663 typedef enum
  664 {
  665     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_1 = 0x1,
  666     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_2 = 0x2,
  667     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_3 = 0x4,
  668     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_4 = 0x8,
  669     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_5 = 0x10,
  670     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_6 = 0x20,
  671     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_7 = 0x40,
  672     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_8 = 0x80,
  673     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_9 = 0x100,
  674     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_10 = 0x200,
  675     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_11 = 0x400,
  676     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_12 = 0x800,
  677     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_13 = 0x1000,
  678     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_14 = 0x2000,
  679     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_17 = 0x4000,
  680     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_18 = 0x8000,
  681     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_19 = 0x10000,
  682     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_20 = 0x20000,
  683     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_21 = 0x40000,
  684     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_24 = 0x80000,
  685     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_25 = 0x100000,
  686     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_26 = 0x200000,
  687     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_28 = 0x400000,
  688     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_33 = 0x800000,
  689     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_34 = 0x1000000,
  690     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_35 = 0x2000000,
  691     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_36 = 0x4000000,
  692     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_37 = 0x8000000,
  693     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_38 = 0x10000000,
  694     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_39 = 0x20000000,
  695     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_40 = 0x40000000,
  696     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_41 = 0x80000000,
  697     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_42 = 0x100000000,
  698     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_43 = 0x200000000
  699 }
  700 le_mrc_LteBandBitMask_t;
  701 
  702 
  703 //--------------------------------------------------------------------------------------------------
  704 /**
  705  * TDSCDMA Band Bit Mask
  706  *
  707  */
  708 //--------------------------------------------------------------------------------------------------
  709 typedef enum
  710 {
  711     LE_MRC_BITMASK_TDSCDMA_BAND_A = 0x1,
  712     LE_MRC_BITMASK_TDSCDMA_BAND_B = 0x2,
  713     LE_MRC_BITMASK_TDSCDMA_BAND_C = 0x4,
  714     LE_MRC_BITMASK_TDSCDMA_BAND_D = 0x8,
  715     LE_MRC_BITMASK_TDSCDMA_BAND_E = 0x10,
  716     LE_MRC_BITMASK_TDSCDMA_BAND_F = 0x20
  717 }
  718 le_mrc_TdScdmaBandBitMask_t;
  719 
  720 
  721 //--------------------------------------------------------------------------------------------------
  722 /**
  723  * Reference type for referring to MRC Scan Information objects.
  724  */
  725 //--------------------------------------------------------------------------------------------------
  726 typedef struct le_mrc_ScanInformation* le_mrc_ScanInformationRef_t;
  727 
  728 
  729 //--------------------------------------------------------------------------------------------------
  730 /**
  731  * Reference type for Scan Information Listing.
  732  */
  733 //--------------------------------------------------------------------------------------------------
  734 typedef struct le_mrc_ScanInformationList* le_mrc_ScanInformationListRef_t;
  735 
  736 
  737 //--------------------------------------------------------------------------------------------------
  738 /**
  739  * Reference type for PCI Scan Information Listing.
  740  */
  741 //--------------------------------------------------------------------------------------------------
  742 typedef struct le_mrc_PciScanInformationList* le_mrc_PciScanInformationListRef_t;
  743 
  744 
  745 //--------------------------------------------------------------------------------------------------
  746 /**
  747  * Reference type for PCI Scan Information .
  748  */
  749 //--------------------------------------------------------------------------------------------------
  750 typedef struct le_mrc_PciScanInformation* le_mrc_PciScanInformationRef_t;
  751 
  752 
  753 //--------------------------------------------------------------------------------------------------
  754 /**
  755  * Reference type for PLMN Information .
  756  */
  757 //--------------------------------------------------------------------------------------------------
  758 typedef struct le_mrc_PlmnInformation* le_mrc_PlmnInformationRef_t;
  759 
  760 
  761 //--------------------------------------------------------------------------------------------------
  762 /**
  763  * Reference type for referring to the Preferred Operator objects.
  764  */
  765 //--------------------------------------------------------------------------------------------------
  766 typedef struct le_mrc_PreferredOperator* le_mrc_PreferredOperatorRef_t;
  767 
  768 
  769 //--------------------------------------------------------------------------------------------------
  770 /**
  771  * Reference type for Preferred Operator Listing.
  772  */
  773 //--------------------------------------------------------------------------------------------------
  774 typedef struct le_mrc_PreferredOperatorList* le_mrc_PreferredOperatorListRef_t;
  775 
  776 
  777 //--------------------------------------------------------------------------------------------------
  778 /**
  779  *  Reference type for one Cell Information.
  780  */
  781 //--------------------------------------------------------------------------------------------------
  782 typedef struct le_mrc_CellInfo* le_mrc_CellInfoRef_t;
  783 
  784 
  785 //--------------------------------------------------------------------------------------------------
  786 /**
  787  *  Reference type for all Neighboring Cells Information.
  788  */
  789 //--------------------------------------------------------------------------------------------------
  790 typedef struct le_mrc_NeighborCells* le_mrc_NeighborCellsRef_t;
  791 
  792 
  793 //--------------------------------------------------------------------------------------------------
  794 /**
  795  *  Reference type for the signal metrics.
  796  */
  797 //--------------------------------------------------------------------------------------------------
  798 typedef struct le_mrc_Metrics* le_mrc_MetricsRef_t;
  799 
  800 
  801 //--------------------------------------------------------------------------------------------------
  802 /**
  803  * Network Registration states.
  804  */
  805 //--------------------------------------------------------------------------------------------------
  806 typedef enum
  807 {
  808     LE_MRC_REG_NONE = 0,
  809         ///< Not registered and not currently searching for new operator.
  810     LE_MRC_REG_HOME = 1,
  811         ///< Registered, home network.
  812     LE_MRC_REG_SEARCHING = 2,
  813         ///< Not registered but currently searching for a new operator.
  814     LE_MRC_REG_DENIED = 3,
  815         ///< Registration was denied, usually because of invalid access credentials.
  816     LE_MRC_REG_ROAMING = 4,
  817         ///< Registered to a roaming network.
  818     LE_MRC_REG_UNKNOWN = 5
  819         ///< Unknown state.
  820 }
  821 le_mrc_NetRegState_t;
  822 
  823 
  824 //--------------------------------------------------------------------------------------------------
  825 /**
  826  * Radio Access Technology enum
  827  */
  828 //--------------------------------------------------------------------------------------------------
  829 typedef enum
  830 {
  831     LE_MRC_RAT_UNKNOWN = 0,
  832         ///< Unknown
  833     LE_MRC_RAT_GSM = 1,
  834         ///< GSM network
  835     LE_MRC_RAT_UMTS = 2,
  836         ///< UMTS networks
  837     LE_MRC_RAT_TDSCDMA = 3,
  838         ///< TD-SCDMA networks
  839     LE_MRC_RAT_LTE = 4,
  840         ///< LTE network
  841     LE_MRC_RAT_CDMA = 5
  842         ///< CDMA network
  843 }
  844 le_mrc_Rat_t;
  845 
  846 
  847 //--------------------------------------------------------------------------------------------------
  848 /**
  849  * Jamming detection report type enum
  850  *
  851  * @note If the reported status is the final status (end of the procedure), this shall be indicated
  852  * within the status report.
  853  * @note Other reports, called intermediate reports, gives only intermediate results issuing from
  854  * the algorithm
  855  */
  856 //--------------------------------------------------------------------------------------------------
  857 typedef enum
  858 {
  859     LE_MRC_JAMMING_REPORT_FINAL = 0,
  860         ///< Final jamming status report
  861     LE_MRC_JAMMING_REPORT_INTERMEDIATE = 1
  862         ///< Intermediate jamming status report
  863 }
  864 le_mrc_JammingReport_t;
  865 
  866 
  867 //--------------------------------------------------------------------------------------------------
  868 /**
  869  * Jamming detection status type enum
  870  *
  871  * @note The final status can be only NULL or JAMMED.
  872  */
  873 //--------------------------------------------------------------------------------------------------
  874 typedef enum
  875 {
  876     LE_MRC_JAMMING_STATUS_UNKNOWN = 0,
  877         ///< Status is unknown
  878     LE_MRC_JAMMING_STATUS_NULL = 1,
  879         ///< No jamming suspicion; radio environment is considered normal
  880     LE_MRC_JAMMING_STATUS_LOW = 2,
  881         ///< Low probability that the device is jammed, but some radio
  882         ///< environment parameters are considered abnormal
  883     LE_MRC_JAMMING_STATUS_MEDIUM = 3,
  884         ///< Medium probability that the device is jammed; a lot of
  885         ///< interferences in the radio spectrum
  886     LE_MRC_JAMMING_STATUS_HIGH = 4,
  887         ///< High probability that the device is jammed; radio environment is
  888         ///< considered jammed, but there is still a possibility that the module
  889         ///< succeeds in synchronizing a cell
  890     LE_MRC_JAMMING_STATUS_JAMMED = 5
  891         ///< Module is jammed; cell synchronization impossible while sufficient
  892         ///< power level is detected on a large number of frequencies
  893 }
  894 le_mrc_JammingStatus_t;
  895 
  896 
  897 //--------------------------------------------------------------------------------------------------
  898 /**
  899  * Radio Bitmask Access Technology Bit Mask
  900  */
  901 //--------------------------------------------------------------------------------------------------
  902 typedef enum
  903 {
  904     LE_MRC_BITMASK_RAT_GSM = 0x1,        ///< GSM RAT Bit Mask
  905     LE_MRC_BITMASK_RAT_UMTS = 0x2,        ///< UMTS RAT Bit Mask
  906     LE_MRC_BITMASK_RAT_TDSCDMA = 0x4,        ///< TD-SCDMA RAT Bit Mask
  907     LE_MRC_BITMASK_RAT_LTE = 0x8,        ///< LTE RAT Bit Mask
  908     LE_MRC_BITMASK_RAT_CDMA = 0x10,        ///< CDMA RAT Bit Mask
  909     LE_MRC_BITMASK_RAT_ALL = 0x20,        ///< To Set all RAT preference Bit Mask
  910     LE_MRC_BITMASK_RAT_MAX = 0x40
  911 }
  912 le_mrc_RatBitMask_t;
  913 
  914 
  915 //--------------------------------------------------------------------------------------------------
  916 /**
  917  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegStateEvent'
  918  */
  919 //--------------------------------------------------------------------------------------------------
  920 typedef struct le_mrc_NetRegStateEventHandler* le_mrc_NetRegStateEventHandlerRef_t;
  921 
  922 
  923 //--------------------------------------------------------------------------------------------------
  924 /**
  925  * Reference type used by Add/Remove functions for EVENT 'le_mrc_RatChange'
  926  */
  927 //--------------------------------------------------------------------------------------------------
  928 typedef struct le_mrc_RatChangeHandler* le_mrc_RatChangeHandlerRef_t;
  929 
  930 
  931 //--------------------------------------------------------------------------------------------------
  932 /**
  933  * Reference type used by Add/Remove functions for EVENT 'le_mrc_PacketSwitchedChange'
  934  */
  935 //--------------------------------------------------------------------------------------------------
  936 typedef struct le_mrc_PacketSwitchedChangeHandler* le_mrc_PacketSwitchedChangeHandlerRef_t;
  937 
  938 
  939 //--------------------------------------------------------------------------------------------------
  940 /**
  941  * Reference type used by Add/Remove functions for EVENT 'le_mrc_SignalStrengthChange'
  942  */
  943 //--------------------------------------------------------------------------------------------------
  944 typedef struct le_mrc_SignalStrengthChangeHandler* le_mrc_SignalStrengthChangeHandlerRef_t;
  945 
  946 
  947 //--------------------------------------------------------------------------------------------------
  948 /**
  949  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetworkReject'
  950  */
  951 //--------------------------------------------------------------------------------------------------
  952 typedef struct le_mrc_NetworkRejectHandler* le_mrc_NetworkRejectHandlerRef_t;
  953 
  954 
  955 //--------------------------------------------------------------------------------------------------
  956 /**
  957  * Reference type used by Add/Remove functions for EVENT 'le_mrc_JammingDetectionEvent'
  958  */
  959 //--------------------------------------------------------------------------------------------------
  960 typedef struct le_mrc_JammingDetectionEventHandler* le_mrc_JammingDetectionEventHandlerRef_t;
  961 
  962 
  963 //--------------------------------------------------------------------------------------------------
  964 /**
  965  * Handler for Network registration state changes.
  966  *
  967  */
  968 //--------------------------------------------------------------------------------------------------
  969 typedef void (*le_mrc_NetRegStateHandlerFunc_t)
  970 (
  971     le_mrc_NetRegState_t state,
  972         ///< Parameter ready to receive the Network Registration state.
  973     void* contextPtr
  974         ///<
  975 );
  976 
  977 //--------------------------------------------------------------------------------------------------
  978 /**
  979  * Handler for Radio Access Technology changes.
  980  *
  981  */
  982 //--------------------------------------------------------------------------------------------------
  983 typedef void (*le_mrc_RatChangeHandlerFunc_t)
  984 (
  985     le_mrc_Rat_t rat,
  986         ///< Parameter ready to receive the Radio Access Technology.
  987     void* contextPtr
  988         ///<
  989 );
  990 
  991 //--------------------------------------------------------------------------------------------------
  992 /**
  993  * Handler for Packet Switched service state changes.
  994  *
  995  */
  996 //--------------------------------------------------------------------------------------------------
  997 typedef void (*le_mrc_PacketSwitchedChangeHandlerFunc_t)
  998 (
  999     le_mrc_NetRegState_t state,
 1000         ///< Parameter ready to receive the Packet Switched service state.
 1001     void* contextPtr
 1002         ///<
 1003 );
 1004 
 1005 //--------------------------------------------------------------------------------------------------
 1006 /**
 1007  * Handler for Signal Strength value changes.
 1008  *
 1009  */
 1010 //--------------------------------------------------------------------------------------------------
 1011 typedef void (*le_mrc_SignalStrengthChangeHandlerFunc_t)
 1012 (
 1013     int32_t ss,
 1014         ///< Signal strength in dBm
 1015     void* contextPtr
 1016         ///<
 1017 );
 1018 
 1019 //--------------------------------------------------------------------------------------------------
 1020 /**
 1021  * Handler for cellular asynchronous network scan Sending result.
 1022  *  Returns the reference to the List object. Null pointer if the scan failed.
 1023  *
 1024  */
 1025 //--------------------------------------------------------------------------------------------------
 1026 typedef void (*le_mrc_CellularNetworkScanHandlerFunc_t)
 1027 (
 1028     le_mrc_ScanInformationListRef_t listRef,
 1029         ///< Reference to the List object. Null pointer if the
 1030         ///< scan failed.
 1031     void* contextPtr
 1032         ///<
 1033 );
 1034 
 1035 //--------------------------------------------------------------------------------------------------
 1036 /**
 1037  * Handler for PCI asynchronous network scan Sending result.
 1038  *  Returns the reference to the List object. Null pointer if the scan failed.
 1039  *
 1040  */
 1041 //--------------------------------------------------------------------------------------------------
 1042 typedef void (*le_mrc_PciNetworkScanHandlerFunc_t)
 1043 (
 1044     le_mrc_PciScanInformationListRef_t listRef,
 1045         ///< Reference to the List object. Null pointer if the
 1046         ///< scan failed.
 1047     void* contextPtr
 1048         ///<
 1049 );
 1050 
 1051 //--------------------------------------------------------------------------------------------------
 1052 /**
 1053  * Handler for asynchronous manual selection response
 1054  *
 1055  */
 1056 //--------------------------------------------------------------------------------------------------
 1057 typedef void (*le_mrc_ManualSelectionHandlerFunc_t)
 1058 (
 1059     le_result_t result,
 1060         ///< Manual selection response
 1061     void* contextPtr
 1062         ///<
 1063 );
 1064 
 1065 //--------------------------------------------------------------------------------------------------
 1066 /**
 1067  * Handler to report network reject indication.
 1068  *
 1069  */
 1070 //--------------------------------------------------------------------------------------------------
 1071 typedef void (*le_mrc_NetworkRejectHandlerFunc_t)
 1072 (
 1073     const char* LE_NONNULL mcc,
 1074         ///< Mobile Country Code
 1075     const char* LE_NONNULL mnc,
 1076         ///< Mobile Network Code
 1077     le_mrc_Rat_t rat,
 1078         ///< Radio Access Technology.
 1079     void* contextPtr
 1080         ///<
 1081 );
 1082 
 1083 //--------------------------------------------------------------------------------------------------
 1084 /**
 1085  * Handler for jamming detection event.
 1086  */
 1087 //--------------------------------------------------------------------------------------------------
 1088 typedef void (*le_mrc_JammingDetectionHandlerFunc_t)
 1089 (
 1090     le_mrc_JammingReport_t report,
 1091         ///< Report type.
 1092     le_mrc_JammingStatus_t status,
 1093         ///< Jamming detection status.
 1094     void* contextPtr
 1095         ///<
 1096 );
 1097 
 1098 //--------------------------------------------------------------------------------------------------
 1099 /**
 1100  * Add handler function for EVENT 'le_mrc_NetRegStateEvent'
 1101  *
 1102  * This event provides information on network registration state changes.
 1103  *
 1104  * @note <b>multi-app safe</b>
 1105  */
 1106 //--------------------------------------------------------------------------------------------------
 1107 le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler
 1108 (
 1109     le_mrc_NetRegStateHandlerFunc_t handlerPtr,
 1110         ///< [IN]
 1111     void* contextPtr
 1112         ///< [IN]
 1113 );
 1114 
 1115 //--------------------------------------------------------------------------------------------------
 1116 /**
 1117  * Remove handler function for EVENT 'le_mrc_NetRegStateEvent'
 1118  */
 1119 //--------------------------------------------------------------------------------------------------
 1120 void le_mrc_RemoveNetRegStateEventHandler
 1121 (
 1122     le_mrc_NetRegStateEventHandlerRef_t handlerRef
 1123         ///< [IN]
 1124 );
 1125 
 1126 //--------------------------------------------------------------------------------------------------
 1127 /**
 1128  * Add handler function for EVENT 'le_mrc_RatChange'
 1129  *
 1130  * This event provides information on Radio Access Technology changes.
 1131  *
 1132  * @note <b>multi-app safe</b>
 1133  */
 1134 //--------------------------------------------------------------------------------------------------
 1135 le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler
 1136 (
 1137     le_mrc_RatChangeHandlerFunc_t handlerPtr,
 1138         ///< [IN]
 1139     void* contextPtr
 1140         ///< [IN]
 1141 );
 1142 
 1143 //--------------------------------------------------------------------------------------------------
 1144 /**
 1145  * Remove handler function for EVENT 'le_mrc_RatChange'
 1146  */
 1147 //--------------------------------------------------------------------------------------------------
 1148 void le_mrc_RemoveRatChangeHandler
 1149 (
 1150     le_mrc_RatChangeHandlerRef_t handlerRef
 1151         ///< [IN]
 1152 );
 1153 
 1154 //--------------------------------------------------------------------------------------------------
 1155 /**
 1156  * Add handler function for EVENT 'le_mrc_PacketSwitchedChange'
 1157  *
 1158  * This event provides information on Packet Switched service changes.
 1159  *
 1160  * @note <b>multi-app safe</b>
 1161  */
 1162 //--------------------------------------------------------------------------------------------------
 1163 le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler
 1164 (
 1165     le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr,
 1166         ///< [IN]
 1167     void* contextPtr
 1168         ///< [IN]
 1169 );
 1170 
 1171 //--------------------------------------------------------------------------------------------------
 1172 /**
 1173  * Remove handler function for EVENT 'le_mrc_PacketSwitchedChange'
 1174  */
 1175 //--------------------------------------------------------------------------------------------------
 1176 void le_mrc_RemovePacketSwitchedChangeHandler
 1177 (
 1178     le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef
 1179         ///< [IN]
 1180 );
 1181 
 1182 //--------------------------------------------------------------------------------------------------
 1183 /**
 1184  * Add handler function for EVENT 'le_mrc_SignalStrengthChange'
 1185  *
 1186  * This event provides information on Signal Strength value changes.
 1187  *
 1188  * @note <b>NOT multi-app safe</b>
 1189  */
 1190 //--------------------------------------------------------------------------------------------------
 1191 le_mrc_SignalStrengthChangeHandlerRef_t le_mrc_AddSignalStrengthChangeHandler
 1192 (
 1193     le_mrc_Rat_t rat,
 1194         ///< [IN] Radio Access Technology
 1195     int32_t lowerRangeThreshold,
 1196         ///< [IN] Lower-range Signal strength threshold in dBm
 1197     int32_t upperRangeThreshold,
 1198         ///< [IN] Upper-range Signal strength threshold in dBm
 1199     le_mrc_SignalStrengthChangeHandlerFunc_t handlerPtr,
 1200         ///< [IN]
 1201     void* contextPtr
 1202         ///< [IN]
 1203 );
 1204 
 1205 //--------------------------------------------------------------------------------------------------
 1206 /**
 1207  * Remove handler function for EVENT 'le_mrc_SignalStrengthChange'
 1208  */
 1209 //--------------------------------------------------------------------------------------------------
 1210 void le_mrc_RemoveSignalStrengthChangeHandler
 1211 (
 1212     le_mrc_SignalStrengthChangeHandlerRef_t handlerRef
 1213         ///< [IN]
 1214 );
 1215 
 1216 //--------------------------------------------------------------------------------------------------
 1217 /**
 1218  * This function sets signal strength indication thresholds for a specific RAT.
 1219  *
 1220  * @return
 1221  *  - LE_OK             Function succeeded.
 1222  *  - LE_BAD_PARAMETER  Bad parameters
 1223  *  - LE_FAULT          Function failed.
 1224  *
 1225  * @note <b>NOT multi-app safe</b>
 1226  */
 1227 //--------------------------------------------------------------------------------------------------
 1228 le_result_t le_mrc_SetSignalStrengthIndThresholds
 1229 (
 1230     le_mrc_Rat_t rat,
 1231         ///< [IN] Radio Access Technology
 1232     int32_t lowerRangeThreshold,
 1233         ///< [IN] Lower-range Signal strength threshold in dBm
 1234     int32_t upperRangeThreshold
 1235         ///< [IN] Upper-range Signal strength threshold in dBm
 1236 );
 1237 
 1238 //--------------------------------------------------------------------------------------------------
 1239 /**
 1240  * This function sets a signal strength indication delta for a specific RAT.
 1241  *
 1242  * @return
 1243  *  - LE_OK             Function succeeded.
 1244  *  - LE_BAD_PARAMETER  Bad parameters.
 1245  *  - LE_FAULT          Function failed.
 1246  *
 1247  * @note The signal delta is set in units of 0.1 dBm. For example, to set a delta of 10.6 dBm, the
 1248  *       delta value must be set to 106.
 1249  *
 1250  * @warning The signal delta resolution is platform dependent. Please refer to
 1251  *          @ref platformConstraintsMdc section for full details.
 1252  */
 1253 //--------------------------------------------------------------------------------------------------
 1254 le_result_t le_mrc_SetSignalStrengthIndDelta
 1255 (
 1256     le_mrc_Rat_t rat,
 1257         ///< [IN] Radio Access Technology
 1258     uint16_t delta
 1259         ///< [IN] Signal delta in units of 0.1 dBm
 1260 );
 1261 
 1262 //--------------------------------------------------------------------------------------------------
 1263 /**
 1264  * Enable the automatic Selection Register mode.
 1265  *
 1266  * @return
 1267  *  - LE_FAULT  Function failed.
 1268  *  - LE_OK     Function succeeded.
 1269  *
 1270  * @note <b>NOT multi-app safe</b>
 1271  */
 1272 //--------------------------------------------------------------------------------------------------
 1273 le_result_t le_mrc_SetAutomaticRegisterMode
 1274 (
 1275     void
 1276 );
 1277 
 1278 //--------------------------------------------------------------------------------------------------
 1279 /**
 1280  * Set the manual Selection Register mode with the MCC/MNC parameters.
 1281  *
 1282  * @return
 1283  *  - LE_FAULT  Function failed.
 1284  *  - LE_OK     Function succeeded.
 1285  *
 1286  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1287  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1288  *       won't return.
 1289  *
 1290  * @note <b>NOT multi-app safe</b>
 1291  */
 1292 //--------------------------------------------------------------------------------------------------
 1293 le_result_t le_mrc_SetManualRegisterMode
 1294 (
 1295     const char* LE_NONNULL mcc,
 1296         ///< [IN] Mobile Country Code
 1297     const char* LE_NONNULL mnc
 1298         ///< [IN] Mobile Network Code
 1299 );
 1300 
 1301 //--------------------------------------------------------------------------------------------------
 1302 /**
 1303  * Set the manual selection register mode asynchronously. This function is not blocking,
 1304  *  the response will be returned with a handler function.
 1305  *
 1306  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1307  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1308  *       won't return.
 1309  *
 1310  *@note <b>NOT multi-app safe</b>
 1311  *
 1312  */
 1313 //--------------------------------------------------------------------------------------------------
 1314 void le_mrc_SetManualRegisterModeAsync
 1315 (
 1316     const char* LE_NONNULL mcc,
 1317         ///< [IN] Mobile Country Code
 1318     const char* LE_NONNULL mnc,
 1319         ///< [IN] Mobile Network Code
 1320     le_mrc_ManualSelectionHandlerFunc_t handlerPtr,
 1321         ///< [IN] handler for sending result
 1322     void* contextPtr
 1323         ///< [IN]
 1324 );
 1325 
 1326 //--------------------------------------------------------------------------------------------------
 1327 /**
 1328  * Get the selected Selection Register mode.
 1329  *
 1330  * @return
 1331  *  - LE_FAULT  Function failed.
 1332  *  - LE_OK     Function succeeded.
 1333  *
 1334  * @note <b>multi-app safe</b>
 1335  */
 1336 //--------------------------------------------------------------------------------------------------
 1337 le_result_t le_mrc_GetRegisterMode
 1338 (
 1339     bool* isManualPtrPtr,
 1340         ///< [OUT] true if the scan mode is manual, false if the scan mode is automatic.
 1341     char* mccPtr,
 1342         ///< [OUT] Mobile Country Code
 1343     size_t mccPtrSize,
 1344         ///< [IN]
 1345     char* mncPtr,
 1346         ///< [OUT] Mobile Network Code
 1347     size_t mncPtrSize
 1348         ///< [IN]
 1349 );
 1350 
 1351 //--------------------------------------------------------------------------------------------------
 1352 /**
 1353  * Get the Packet Switched state.
 1354  *
 1355  * @return
 1356  *  - LE_FAULT  Function failed.
 1357  *  - LE_OK     Function succeeded.
 1358  *
 1359  * @note <b>multi-app safe</b>
 1360  */
 1361 //--------------------------------------------------------------------------------------------------
 1362 le_result_t le_mrc_GetPacketSwitchedState
 1363 (
 1364     le_mrc_NetRegState_t* statePtr
 1365         ///< [OUT] The current Packet switched state.
 1366 );
 1367 
 1368 //--------------------------------------------------------------------------------------------------
 1369 /**
 1370  * Get the platform specific network registration error code.
 1371  *
 1372  * Refer to @ref platformConstraintsSpecificErrorCodes for platform specific
 1373  * registration error code description.
 1374  *
 1375  * @return the platform specific registration error code
 1376  *
 1377  */
 1378 //--------------------------------------------------------------------------------------------------
 1379 int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode
 1380 (
 1381     void
 1382 );
 1383 
 1384 //--------------------------------------------------------------------------------------------------
 1385 /**
 1386  * Set the Radio Access Technology preferences by using a bit mask.
 1387  *
 1388  * @return
 1389  *  - LE_FAULT           Function failed.
 1390  *  - LE_OK              Function succeeded.
 1391  *  - LE_UNSUPPORTED     Not supported by platform.
 1392  *
 1393  * @note <b>NOT multi-app safe</b>
 1394  */
 1395 //--------------------------------------------------------------------------------------------------
 1396 le_result_t le_mrc_SetRatPreferences
 1397 (
 1398     le_mrc_RatBitMask_t ratMask
 1399         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1400 );
 1401 
 1402 //--------------------------------------------------------------------------------------------------
 1403 /**
 1404  * Get the Radio Access Technology preferences
 1405  *
 1406  * @return
 1407  * - LE_FAULT  Function failed.
 1408  * - LE_OK     Function succeeded.
 1409  *
 1410  * @note <b>multi-app safe</b>
 1411  */
 1412 //--------------------------------------------------------------------------------------------------
 1413 le_result_t le_mrc_GetRatPreferences
 1414 (
 1415     le_mrc_RatBitMask_t* ratMaskPtrPtr
 1416         ///< [OUT] Bit mask for the Radio Access Technology preferences.
 1417 );
 1418 
 1419 //--------------------------------------------------------------------------------------------------
 1420 /**
 1421  * Set the 2G/3G Band preferences by using a bit mask.
 1422  *
 1423  * @return
 1424  *  - LE_FAULT  Function failed.
 1425  *  - LE_OK     Function succeeded.
 1426  *
 1427  * @note <b>NOT multi-app safe</b>
 1428  */
 1429 //--------------------------------------------------------------------------------------------------
 1430 le_result_t le_mrc_SetBandPreferences
 1431 (
 1432     le_mrc_BandBitMask_t bandMask
 1433         ///< [IN] Bit mask for 2G/3G Band preferences.
 1434 );
 1435 
 1436 //--------------------------------------------------------------------------------------------------
 1437 /**
 1438  * Get the Bit mask for 2G/3G Band preferences.
 1439  *
 1440  * @return
 1441  *  - LE_FAULT  Function failed.
 1442  *  - LE_OK     Function succeeded.
 1443  *
 1444  * @note <b>multi-app safe</b>
 1445  */
 1446 //--------------------------------------------------------------------------------------------------
 1447 le_result_t le_mrc_GetBandPreferences
 1448 (
 1449     le_mrc_BandBitMask_t* bandMaskPtrPtr
 1450         ///< [OUT] Bit mask for 2G/3G Band preferences.
 1451 );
 1452 
 1453 //--------------------------------------------------------------------------------------------------
 1454 /**
 1455  * Set the LTE Band preferences by using a bit mask.
 1456  *
 1457  * @return
 1458  *  - LE_FAULT        Function failed.
 1459  *  - LE_OK           Function succeeded.
 1460  *  - LE_UNSUPPORTED  The platform doesn't support setting LTE Band preferences.
 1461  *
 1462  * @note <b>NOT multi-app safe</b>
 1463  */
 1464 //--------------------------------------------------------------------------------------------------
 1465 le_result_t le_mrc_SetLteBandPreferences
 1466 (
 1467     le_mrc_LteBandBitMask_t bandMask
 1468         ///< [IN] Bit mask for LTE Band preferences.
 1469 );
 1470 
 1471 //--------------------------------------------------------------------------------------------------
 1472 /**
 1473  * Get the Bit mask for LTE Band preferences.
 1474  *
 1475  * @return
 1476  *  - LE_FAULT  Function failed.
 1477  *  - LE_OK     Function succeeded.
 1478  *
 1479  * @note <b>multi-app safe</b>
 1480  */
 1481 //--------------------------------------------------------------------------------------------------
 1482 le_result_t le_mrc_GetLteBandPreferences
 1483 (
 1484     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 1485         ///< [OUT] Bit mask for LTE Band preferences.
 1486 );
 1487 
 1488 //--------------------------------------------------------------------------------------------------
 1489 /**
 1490  * Set the TD-SCDMA Band preferences by using a bit mask.
 1491  *
 1492  * @return
 1493  *  - LE_OK           Function succeeded.
 1494  *  - LE_FAULT        Function failed.
 1495  *  - LE_UNSUPPORTED  The platform doesn't support setting TD-SCDMA Band preferences.
 1496  *
 1497  * @note <b>NOT multi-app safe</b>
 1498  */
 1499 //--------------------------------------------------------------------------------------------------
 1500 le_result_t le_mrc_SetTdScdmaBandPreferences
 1501 (
 1502     le_mrc_TdScdmaBandBitMask_t bandMask
 1503         ///< [IN] Bit mask for TD-SCDMA Band preferences.
 1504 );
 1505 
 1506 //--------------------------------------------------------------------------------------------------
 1507 /**
 1508  * Get the Bit mask for TD-SCDMA Band preferences.
 1509  *
 1510  * @return
 1511  *  - LE_OK           Function succeeded.
 1512  *  - LE_FAULT        Function failed.
 1513  *  - LE_UNSUPPORTED  The platform doesn't support getting TD-SCDMA Band preferences.
 1514  *
 1515  * @note <b>multi-app safe</b>
 1516  */
 1517 //--------------------------------------------------------------------------------------------------
 1518 le_result_t le_mrc_GetTdScdmaBandPreferences
 1519 (
 1520     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 1521         ///< [OUT] Bit mask for TD-SCDMA Band preferences.
 1522 );
 1523 
 1524 //--------------------------------------------------------------------------------------------------
 1525 /**
 1526  * Add a preferred operator by specifying the MCC/MNC and the Radio Access Technology.
 1527  *
 1528  * @return
 1529  *  - LE_UNSUPPORTED   List of User Preferred operators not available.
 1530  *  - LE_FAULT         Function failed.
 1531  *  - LE_BAD_PARAMETER RAT mask is invalid.
 1532  *  - LE_OK            Function succeeded.
 1533  *
 1534  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1535  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1536  *       won't return.
 1537  *
 1538  * @note <b>NOT multi-app safe</b>
 1539  */
 1540 //--------------------------------------------------------------------------------------------------
 1541 le_result_t le_mrc_AddPreferredOperator
 1542 (
 1543     const char* LE_NONNULL mcc,
 1544         ///< [IN] Mobile Country Code
 1545     const char* LE_NONNULL mnc,
 1546         ///< [IN] Mobile Network Code
 1547     le_mrc_RatBitMask_t ratMask
 1548         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1549 );
 1550 
 1551 //--------------------------------------------------------------------------------------------------
 1552 /**
 1553  * Remove a preferred operator by specifying the MCC/MNC.
 1554  *
 1555  * @return
 1556  *  - LE_UNSUPPORTED    List of User Preferred operators not available.
 1557  *  - LE_NOT_FOUND      Operator not found in the User Preferred operators list.
 1558  *  - LE_FAULT          Function failed.
 1559  *  - LE_OK             Function succeeded.
 1560  *
 1561  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1562  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1563  *       won't return.
 1564  *
 1565  * @note <b>NOT multi-app safe</b>
 1566  */
 1567 //--------------------------------------------------------------------------------------------------
 1568 le_result_t le_mrc_RemovePreferredOperator
 1569 (
 1570     const char* LE_NONNULL mcc,
 1571         ///< [IN] Mobile Country Code
 1572     const char* LE_NONNULL mnc
 1573         ///< [IN] Mobile Network Code
 1574 );
 1575 
 1576 //--------------------------------------------------------------------------------------------------
 1577 /**
 1578  * This function must be called to retrieve a list of the preferred operators.
 1579  *
 1580  * @return
 1581  * - Reference to the List object.
 1582  * - Null pointer if there is no preferences list.
 1583  *
 1584  * @note <b>multi-app safe</b>
 1585  */
 1586 //--------------------------------------------------------------------------------------------------
 1587 le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList
 1588 (
 1589     void
 1590 );
 1591 
 1592 //--------------------------------------------------------------------------------------------------
 1593 /**
 1594  * This function must be called to get the first Operator object reference in the list of the
 1595  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1596  *
 1597  * @return
 1598  *  - NULL                          No operator information found.
 1599  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1600  *
 1601  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1602  *       function won't return.
 1603  *
 1604  * @note <b>multi-app safe</b>
 1605  */
 1606 //--------------------------------------------------------------------------------------------------
 1607 le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator
 1608 (
 1609     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1610         ///< [IN] The list of the preferred operators.
 1611 );
 1612 
 1613 //--------------------------------------------------------------------------------------------------
 1614 /**
 1615  * This function must be called to get the next Operator object reference in the list of the
 1616  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1617  *
 1618  * @return
 1619  *  - NULL                          No operator information found.
 1620  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1621  *
 1622  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1623  *       function won't return.
 1624  *
 1625  * @note <b>multi-app safe</b>
 1626  */
 1627 //--------------------------------------------------------------------------------------------------
 1628 le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator
 1629 (
 1630     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1631         ///< [IN] The list of the preferred operators.
 1632 );
 1633 
 1634 //--------------------------------------------------------------------------------------------------
 1635 /**
 1636  * This function must be called to delete the list of the preferred operators retrieved with
 1637  * le_mrc_GetPreferredOperators().
 1638  *
 1639  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1640  *       reference for validity.
 1641  *
 1642  * @note <b>multi-app safe</b>
 1643  */
 1644 //--------------------------------------------------------------------------------------------------
 1645 void le_mrc_DeletePreferredOperatorsList
 1646 (
 1647     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1648         ///< [IN] The list of the preferred operators.
 1649 );
 1650 
 1651 //--------------------------------------------------------------------------------------------------
 1652 /**
 1653  * This function must be called to get the Operator information details.
 1654  *
 1655  * @return
 1656  *      - LE_OK on success
 1657  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 1658  *      - LE_FAULT for all other errors
 1659  *
 1660  * @note <b>multi-app safe</b>
 1661  */
 1662 //--------------------------------------------------------------------------------------------------
 1663 le_result_t le_mrc_GetPreferredOperatorDetails
 1664 (
 1665     le_mrc_PreferredOperatorRef_t preferredOperatorRef,
 1666         ///< [IN] Operator object reference.
 1667     char* mccPtr,
 1668         ///< [OUT] Mobile Country Code.
 1669     size_t mccPtrSize,
 1670         ///< [IN]
 1671     char* mncPtr,
 1672         ///< [OUT] Mobile Network Code.
 1673     size_t mncPtrSize,
 1674         ///< [IN]
 1675     le_mrc_RatBitMask_t* ratMaskPtr
 1676         ///< [OUT] Bit mask for the RAT preferences.
 1677 );
 1678 
 1679 //--------------------------------------------------------------------------------------------------
 1680 /**
 1681  * Get the network registration state.
 1682  *
 1683  * @return LE_FAULT         The function failed to get the Network registration state.
 1684  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1685  * @return LE_OK            The function succeeded.
 1686  *
 1687  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1688  *       function won't return.
 1689  *
 1690  * @note <b>multi-app safe</b>
 1691  */
 1692 //--------------------------------------------------------------------------------------------------
 1693 le_result_t le_mrc_GetNetRegState
 1694 (
 1695     le_mrc_NetRegState_t* statePtr
 1696         ///< [OUT] Network Registration state.
 1697 );
 1698 
 1699 //--------------------------------------------------------------------------------------------------
 1700 /**
 1701  * Get the signal quality.
 1702  *
 1703  * @return LE_FAULT         The function failed to get the Signal Quality information.
 1704  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1705  * @return LE_OK            The function succeeded.
 1706  *
 1707  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1708  *       function won't return.
 1709  *
 1710  * @note <b>multi-app safe</b>
 1711  */
 1712 //--------------------------------------------------------------------------------------------------
 1713 le_result_t le_mrc_GetSignalQual
 1714 (
 1715     uint32_t* qualityPtr
 1716         ///< [OUT] [OUT] Received signal strength quality (0 = no signal strength,
 1717         ///<        5 = very good signal strength).
 1718 );
 1719 
 1720 //--------------------------------------------------------------------------------------------------
 1721 /**
 1722  * Set the power of the Radio Module.
 1723  *
 1724  * @return LE_BAD_PARAMETER Bad power mode specified.
 1725  * @return LE_FAULT         Function failed.
 1726  * @return LE_OK            Function succeed.
 1727  *
 1728  * @note <b>NOT multi-app safe</b>
 1729  */
 1730 //--------------------------------------------------------------------------------------------------
 1731 le_result_t le_mrc_SetRadioPower
 1732 (
 1733     le_onoff_t power
 1734         ///< [IN] The power state.
 1735 );
 1736 
 1737 //--------------------------------------------------------------------------------------------------
 1738 /**
 1739  * Must be called to get the Radio Module power state.
 1740  *
 1741  * @return LE_FAULT         The function failed to get the Radio Module power state.
 1742  * @return LE_BAD_PARAMETER if powerPtr is NULL.
 1743  * @return LE_OK            The function succeed.
 1744  *
 1745  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1746  *       function won't return.
 1747  *
 1748  * @note <b>multi-app safe</b>
 1749  */
 1750 //--------------------------------------------------------------------------------------------------
 1751 le_result_t le_mrc_GetRadioPower
 1752 (
 1753     le_onoff_t* powerPtr
 1754         ///< [OUT] Power state.
 1755 );
 1756 
 1757 //--------------------------------------------------------------------------------------------------
 1758 /**
 1759  * This function must be called to perform a cellular network scan.
 1760  *
 1761  * @return Reference to the List object. Null pointer if the scan failed.
 1762  *
 1763  * @note <b>multi-app safe</b>
 1764  */
 1765 //--------------------------------------------------------------------------------------------------
 1766 le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan
 1767 (
 1768     le_mrc_RatBitMask_t ratMask
 1769         ///< [IN] Radio Access Technology mask
 1770 );
 1771 
 1772 //--------------------------------------------------------------------------------------------------
 1773 /**
 1774  * This function must be called to perform a PCI network scan.
 1775  *
 1776  * @return Reference to the List object. Null pointer if the scan failed.
 1777  *
 1778  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
 1779  *          details.
 1780  *
 1781  * @note <b>multi-app safe</b>
 1782  */
 1783 //--------------------------------------------------------------------------------------------------
 1784 le_mrc_PciScanInformationListRef_t le_mrc_PerformPciNetworkScan
 1785 (
 1786     le_mrc_RatBitMask_t ratMask
 1787         ///< [IN] Radio Access Technology mask
 1788 );
 1789 
 1790 //--------------------------------------------------------------------------------------------------
 1791 /**
 1792  * This function must be called to perform a cellular network scan asynchronously. This function
 1793  * is not blocking, the response will be returned with a handler function.
 1794  *
 1795  *@note <b>multi-app safe</b>
 1796  *
 1797  */
 1798 //--------------------------------------------------------------------------------------------------
 1799 void le_mrc_PerformCellularNetworkScanAsync
 1800 (
 1801     le_mrc_RatBitMask_t ratMask,
 1802         ///< [IN] Radio Access Technology mask
 1803     le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr,
 1804         ///< [IN] handler for sending result.
 1805     void* contextPtr
 1806         ///< [IN]
 1807 );
 1808 
 1809 //--------------------------------------------------------------------------------------------------
 1810 /**
 1811  * This function must be called to perform a PCI network scan asynchronously. This function
 1812  * is not blocking, the response will be returned with a handler function.
 1813  *
 1814  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
 1815  *          details.
 1816  *
 1817  *@note <b>multi-app safe</b>
 1818  *
 1819  */
 1820 //--------------------------------------------------------------------------------------------------
 1821 void le_mrc_PerformPciNetworkScanAsync
 1822 (
 1823     le_mrc_RatBitMask_t ratMask,
 1824         ///< [IN] Radio Access Technology mask
 1825     le_mrc_PciNetworkScanHandlerFunc_t handlerPtr,
 1826         ///< [IN] handler for sending result.
 1827     void* contextPtr
 1828         ///< [IN]
 1829 );
 1830 
 1831 //--------------------------------------------------------------------------------------------------
 1832 /**
 1833  * This function must be called to get the first Scan Information object reference in the list of
 1834  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
 1835  *
 1836  * @return NULL                         No scan information found.
 1837  * @return le_mrc_ScanInformationRef_t  The Scan Information object reference.
 1838  *
 1839  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1840  *       function won't return.
 1841  *
 1842  * @note <b>multi-app safe</b>
 1843  */
 1844 //--------------------------------------------------------------------------------------------------
 1845 le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan
 1846 (
 1847     le_mrc_ScanInformationListRef_t scanInformationListRef
 1848         ///< [IN] The list of scan information.
 1849 );
 1850 
 1851 //--------------------------------------------------------------------------------------------------
 1852 /**
 1853  * This function must be called to get the next Scan Information object reference in the list of
 1854  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
 1855  *
 1856  * @return NULL                         No scan information found.
 1857  * @return le_mrc_ScanInformationRef_t  The Scan Information object reference.
 1858  *
 1859  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1860  *       function won't return.
 1861  *
 1862  * @note <b>multi-app safe</b>
 1863  */
 1864 //--------------------------------------------------------------------------------------------------
 1865 le_mrc_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan
 1866 (
 1867     le_mrc_ScanInformationListRef_t scanInformationListRef
 1868         ///< [IN] The list of scan information.
 1869 );
 1870 
 1871 //--------------------------------------------------------------------------------------------------
 1872 /**
 1873  * This function must be called to get the first Pci Scan Information object reference in the list of
 1874  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
 1875  *
 1876  * @return NULL                         No scan information found.
 1877  * @return The Scan Information object reference.
 1878  *
 1879  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1880  *       function won't return.
 1881  *
 1882  * @note <b>multi-app safe</b>
 1883  */
 1884 //--------------------------------------------------------------------------------------------------
 1885 le_mrc_PciScanInformationRef_t le_mrc_GetFirstPciScanInfo
 1886 (
 1887     le_mrc_PciScanInformationListRef_t scanInformationListRef
 1888         ///< [IN] The list of scan information.
 1889 );
 1890 
 1891 //--------------------------------------------------------------------------------------------------
 1892 /**
 1893  * This function must be called to get the next Scan Information object reference in the list of
 1894  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
 1895  *
 1896  * @return NULL                         No scan information found.
 1897  * @return The Scan Information object reference.
 1898  *
 1899  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1900  *       function won't return.
 1901  *
 1902  * @note <b>multi-app safe</b>
 1903  */
 1904 //--------------------------------------------------------------------------------------------------
 1905 le_mrc_PciScanInformationRef_t le_mrc_GetNextPciScanInfo
 1906 (
 1907     le_mrc_PciScanInformationListRef_t scanInformationListRef
 1908         ///< [IN] The list of scan information.
 1909 );
 1910 
 1911 //--------------------------------------------------------------------------------------------------
 1912 /**
 1913  * This function must be called to get the first Plmn Information object reference in the list of
 1914  * Plmn on each cell.
 1915  *
 1916  * @return NULL                         No scan information found.
 1917  * @return le_mrc_PlmnInformationRef_t  The Plmn Information object reference.
 1918  *
 1919  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1920  *       function won't return.
 1921  *
 1922  */
 1923 //--------------------------------------------------------------------------------------------------
 1924 le_mrc_PlmnInformationRef_t le_mrc_GetFirstPlmnInfo
 1925 (
 1926     le_mrc_PciScanInformationRef_t pciScanInformationRef
 1927         ///< [IN] [IN] The reference to the cell information.
 1928 );
 1929 
 1930 //--------------------------------------------------------------------------------------------------
 1931 /**
 1932  * This function must be called to get the next Plmn Information object reference in the list of
 1933  * Plmn on each cell.
 1934  *
 1935  * @return NULL                         No scan information found.
 1936  * @return le_mrc_PlmnInformationRef_t  The Plmn Information object reference.
 1937  *
 1938  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1939  *       function won't return.
 1940  *
 1941  */
 1942 //--------------------------------------------------------------------------------------------------
 1943 le_mrc_PlmnInformationRef_t le_mrc_GetNextPlmnInfo
 1944 (
 1945     le_mrc_PciScanInformationRef_t plmnRef
 1946         ///< [IN] [IN] The reference to the cell information.
 1947 );
 1948 
 1949 //--------------------------------------------------------------------------------------------------
 1950 /**
 1951  * This function must be called to get the physical cell id referenced by PciScanInformation which
 1952  * is returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
 1953  *
 1954  * @return The Physical Cell Identifier.
 1955  *
 1956  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1957  *       function won't return.
 1958  */
 1959 //--------------------------------------------------------------------------------------------------
 1960 uint16_t le_mrc_GetPciScanCellId
 1961 (
 1962     le_mrc_PciScanInformationRef_t pciScanInformationRef
 1963         ///< [IN] [IN] The reference to the cell information.
 1964 );
 1965 
 1966 //--------------------------------------------------------------------------------------------------
 1967 /**
 1968  * This function must be called to get the global cell id referenced by PciScanInformation which is
 1969  * returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
 1970  *
 1971  * @return The Global Cell Identifier.
 1972  *
 1973  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1974  *       function won't return.
 1975  */
 1976 //--------------------------------------------------------------------------------------------------
 1977 uint32_t le_mrc_GetPciScanGlobalCellId
 1978 (
 1979     le_mrc_PciScanInformationRef_t pciScanInformationRef
 1980         ///< [IN] [IN] The reference to the cell information.
 1981 );
 1982 
 1983 //--------------------------------------------------------------------------------------------------
 1984 /**
 1985  * This function must be called to get the Mcc/Mnc of each PLMN referenced in the list of
 1986  * Plmn Information retrieved with le_mrc_GetFirstPlmnInfo() and le_mrc_GetNextPlmnInfo().
 1987  *
 1988  * @return
 1989  *      - LE_OK on success
 1990  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 1991  *      - LE_FAULT for all other errors
 1992  *
 1993  *
 1994  */
 1995 //--------------------------------------------------------------------------------------------------
 1996 le_result_t le_mrc_GetPciScanMccMnc
 1997 (
 1998     le_mrc_PlmnInformationRef_t plmnRef,
 1999         ///< [IN] [IN] The reference to the cell information.
 2000     char* mccPtr,
 2001         ///< [OUT] Mobile Country Code
 2002     size_t mccPtrSize,
 2003         ///< [IN]
 2004     char* mncPtr,
 2005         ///< [OUT] Mobile Network Code
 2006     size_t mncPtrSize
 2007         ///< [IN]
 2008 );
 2009 
 2010 //--------------------------------------------------------------------------------------------------
 2011 /**
 2012  * This function must be called to delete the list of the Scan Information retrieved with
 2013  * le_mrc_PerformCellularNetworkScan().
 2014  *
 2015  * @note
 2016  *      On failure, the process exits, so you don't have to worry about checking the returned
 2017  *      reference for validity.
 2018  *
 2019  * @note <b>multi-app safe</b>
 2020  */
 2021 //--------------------------------------------------------------------------------------------------
 2022 void le_mrc_DeleteCellularNetworkScan
 2023 (
 2024     le_mrc_ScanInformationListRef_t scanInformationListRef
 2025         ///< [IN] The list of scan information.
 2026 );
 2027 
 2028 //--------------------------------------------------------------------------------------------------
 2029 /**
 2030  * This function must be called to delete the list of the Pci Scan Information retrieved with
 2031  * le_mrc_PerformPciNetworkScan().
 2032  *
 2033  * @note
 2034  *      On failure, the process exits, so you don't have to worry about checking the returned
 2035  *      reference for validity.
 2036  *
 2037  */
 2038 //--------------------------------------------------------------------------------------------------
 2039 void le_mrc_DeletePciNetworkScan
 2040 (
 2041     le_mrc_PciScanInformationListRef_t scanInformationListRef
 2042         ///< [IN] The list of scan information.
 2043 );
 2044 
 2045 //--------------------------------------------------------------------------------------------------
 2046 /**
 2047  * This function must be called to get the Cellular Network Code [mcc:mnc]
 2048  *
 2049  * @return
 2050  *      - LE_OK on success
 2051  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 2052  *      - LE_FAULT for all other errors
 2053  *
 2054  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2055  *       reference for validity.
 2056  *
 2057  * @note <b>multi-app safe</b>
 2058  */
 2059 //--------------------------------------------------------------------------------------------------
 2060 le_result_t le_mrc_GetCellularNetworkMccMnc
 2061 (
 2062     le_mrc_ScanInformationRef_t scanInformationRef,
 2063         ///< [IN] Scan information reference
 2064     char* mccPtr,
 2065         ///< [OUT] Mobile Country Code
 2066     size_t mccPtrSize,
 2067         ///< [IN]
 2068     char* mncPtr,
 2069         ///< [OUT] Mobile Network Code
 2070     size_t mncPtrSize
 2071         ///< [IN]
 2072 );
 2073 
 2074 //--------------------------------------------------------------------------------------------------
 2075 /**
 2076  * This function must be called to get the Cellular Network Name.
 2077  *
 2078  * @return
 2079  *      - LE_OK on success
 2080  *      - LE_OVERFLOW if the operator name would not fit in buffer
 2081  *      - LE_FAULT for all other errors
 2082  *
 2083  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2084  *       reference for validity.
 2085  *
 2086  * @note <b>multi-app safe</b>
 2087  */
 2088 //--------------------------------------------------------------------------------------------------
 2089 le_result_t le_mrc_GetCellularNetworkName
 2090 (
 2091     le_mrc_ScanInformationRef_t scanInformationRef,
 2092         ///< [IN] Scan information reference
 2093     char* namePtr,
 2094         ///< [OUT] Name of operator
 2095     size_t namePtrSize
 2096         ///< [IN]
 2097 );
 2098 
 2099 //--------------------------------------------------------------------------------------------------
 2100 /**
 2101  * This function must be called to get the radio access technology of a scanInformationRef.
 2102  *
 2103  * @return the radio access technology
 2104  *
 2105  * @note On failure, the process exits.
 2106  *
 2107  * @note <b>multi-app safe</b>
 2108  */
 2109 //--------------------------------------------------------------------------------------------------
 2110 le_mrc_Rat_t le_mrc_GetCellularNetworkRat
 2111 (
 2112     le_mrc_ScanInformationRef_t scanInformationRef
 2113         ///< [IN] Scan information reference
 2114 );
 2115 
 2116 //--------------------------------------------------------------------------------------------------
 2117 /**
 2118  * This function must be called to check if a cellular network is currently in use.
 2119  *
 2120  * @return true     The network is in use
 2121  * @return false    The network isn't in use
 2122  *
 2123  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2124  *       reference for validity.
 2125  *
 2126  * @note <b>multi-app safe</b>
 2127  */
 2128 //--------------------------------------------------------------------------------------------------
 2129 bool le_mrc_IsCellularNetworkInUse
 2130 (
 2131     le_mrc_ScanInformationRef_t scanInformationRef
 2132         ///< [IN] Scan information reference
 2133 );
 2134 
 2135 //--------------------------------------------------------------------------------------------------
 2136 /**
 2137  * This function must be called to check if a cellular network is available.
 2138  *
 2139  * @return true     The network is available
 2140  * @return false    The network isn't available
 2141  *
 2142  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2143  *       reference for validity.
 2144  *
 2145  * @note <b>multi-app safe</b>
 2146  */
 2147 //--------------------------------------------------------------------------------------------------
 2148 bool le_mrc_IsCellularNetworkAvailable
 2149 (
 2150     le_mrc_ScanInformationRef_t scanInformationRef
 2151         ///< [IN] Scan information reference
 2152 );
 2153 
 2154 //--------------------------------------------------------------------------------------------------
 2155 /**
 2156  * This function must be called to check if a cellular network is currently in home mode.
 2157  *
 2158  * @return true     The network is home
 2159  * @return false    The network is roaming
 2160  *
 2161  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2162  *       reference for validity.
 2163  *
 2164  * @note <b>multi-app safe</b>
 2165  */
 2166 //--------------------------------------------------------------------------------------------------
 2167 bool le_mrc_IsCellularNetworkHome
 2168 (
 2169     le_mrc_ScanInformationRef_t scanInformationRef
 2170         ///< [IN] Scan information reference
 2171 );
 2172 
 2173 //--------------------------------------------------------------------------------------------------
 2174 /**
 2175  * This function must be called to check if a cellular network is forbidden by the operator.
 2176  *
 2177  * @return true     The network is forbidden
 2178  * @return false    The network is allowed
 2179  *
 2180  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2181  *       reference for validity.
 2182  *
 2183  * @note <b>multi-app safe</b>
 2184  */
 2185 //--------------------------------------------------------------------------------------------------
 2186 bool le_mrc_IsCellularNetworkForbidden
 2187 (
 2188     le_mrc_ScanInformationRef_t scanInformationRef
 2189         ///< [IN] Scan information reference
 2190 );
 2191 
 2192 //--------------------------------------------------------------------------------------------------
 2193 /**
 2194  * This function must be called to get the current network name information.
 2195  *
 2196  * @return
 2197  *      - LE_OK             on success
 2198  *      - LE_BAD_PARAMETER  if nameStr is NULL
 2199  *      - LE_OVERFLOW       if the Home Network Name can't fit in nameStr
 2200  *      - LE_FAULT          on any other failure
 2201  *
 2202  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2203  *       function won't return.
 2204  *
 2205  * @note <b>multi-app safe</b>
 2206  */
 2207 //--------------------------------------------------------------------------------------------------
 2208 le_result_t le_mrc_GetCurrentNetworkName
 2209 (
 2210     char* nameStr,
 2211         ///< [OUT] the home network Name
 2212     size_t nameStrSize
 2213         ///< [IN]
 2214 );
 2215 
 2216 //--------------------------------------------------------------------------------------------------
 2217 /**
 2218  * This function must be called to get the current network PLMN information.
 2219  *
 2220  * @return
 2221  *      - LE_OK       on success
 2222  *      - LE_FAULT    on any other failure
 2223  *
 2224  * @note <b>multi-app safe</b>
 2225  */
 2226 //--------------------------------------------------------------------------------------------------
 2227 le_result_t le_mrc_GetCurrentNetworkMccMnc
 2228 (
 2229     char* mccStr,
 2230         ///< [OUT] the mobile country code
 2231     size_t mccStrSize,
 2232         ///< [IN]
 2233     char* mncStr,
 2234         ///< [OUT] the mobile network code
 2235     size_t mncStrSize
 2236         ///< [IN]
 2237 );
 2238 
 2239 //--------------------------------------------------------------------------------------------------
 2240 /**
 2241  * This function must be called to get the current Radio Access Technology in use.
 2242  *
 2243  * @return LE_OK            Function succeeded.
 2244  * @return LE_BAD_PARAMETER Invalid parameter.
 2245  * @return LE_FAULT         Function failed to get the Radio Access Technology.
 2246  *
 2247  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2248  *       function won't return.
 2249  *
 2250  * @note The API returns the RAT only if the device is registered on the network.
 2251  *       le_mrc_GetNetRegState() function can be called first to obtain the network registration
 2252  *       state.
 2253  *
 2254  * @note <b>multi-app safe</b>
 2255  */
 2256 //--------------------------------------------------------------------------------------------------
 2257 le_result_t le_mrc_GetRadioAccessTechInUse
 2258 (
 2259     le_mrc_Rat_t* ratPtr
 2260         ///< [OUT] The Radio Access Technology.
 2261 );
 2262 
 2263 //--------------------------------------------------------------------------------------------------
 2264 /**
 2265  * This function must be called to retrieve the Neighboring Cells information. It creates and
 2266  * returns a reference to the Neighboring Cells information.
 2267  *
 2268  * @return A reference to the Neighboring Cells information.
 2269  * @return NULL if no Cells Information are available.
 2270  *
 2271  * @note <b>multi-app safe</b>
 2272  */
 2273 //--------------------------------------------------------------------------------------------------
 2274 le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo
 2275 (
 2276     void
 2277 );
 2278 
 2279 //--------------------------------------------------------------------------------------------------
 2280 /**
 2281  * This function must be called to delete the Neighboring Cells information.
 2282  *
 2283  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2284  *       reference for validity.
 2285  *
 2286  * @note <b>multi-app safe</b>
 2287  */
 2288 //--------------------------------------------------------------------------------------------------
 2289 void le_mrc_DeleteNeighborCellsInfo
 2290 (
 2291     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2292         ///< [IN] Neighboring Cells reference.
 2293 );
 2294 
 2295 //--------------------------------------------------------------------------------------------------
 2296 /**
 2297  * This function must be called to get the first Cell Information reference in the list of
 2298  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 2299  *
 2300  * @return NULL                   No Cell information object found.
 2301  * @return le_mrc_CellInfoRef_t   The Cell information object reference.
 2302  *
 2303  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2304  *       function won't return.
 2305  *
 2306  * @note <b>multi-app safe</b>
 2307  */
 2308 //--------------------------------------------------------------------------------------------------
 2309 le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo
 2310 (
 2311     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2312         ///< [IN] Neighboring Cells reference.
 2313 );
 2314 
 2315 //--------------------------------------------------------------------------------------------------
 2316 /**
 2317  * This function must be called to get the next Cell Information reference in the list of
 2318  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 2319  *
 2320  * @return NULL                   No Cell information object found.
 2321  * @return le_mrc_CellInfoRef_t   Cell information object reference.
 2322  *
 2323  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2324  *       function won't return.
 2325  *
 2326  * @note <b>multi-app safe</b>
 2327  */
 2328 //--------------------------------------------------------------------------------------------------
 2329 le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo
 2330 (
 2331     le_mrc_NeighborCellsRef_t ngbrCellsRef
 2332         ///< [IN] Neighboring Cells reference.
 2333 );
 2334 
 2335 //--------------------------------------------------------------------------------------------------
 2336 /**
 2337  * This function must be called to get the Physical Cell Identifier.
 2338  *
 2339  * @return The Physical Cell Identifier. UINT32_MAX value is returned if the Cell Identifier is not
 2340  * available.
 2341  *
 2342  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2343  *       function won't return.
 2344  *
 2345  * @note <b>multi-app safe</b>
 2346  */
 2347 //--------------------------------------------------------------------------------------------------
 2348 uint32_t le_mrc_GetNeighborCellId
 2349 (
 2350     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2351         ///< [IN] Cell information reference.
 2352 );
 2353 
 2354 //--------------------------------------------------------------------------------------------------
 2355 /**
 2356  * This function must be called to get the Location Area Code of a cell.
 2357  *
 2358  * @return The Location Area Code of a cell. UINT16_MAX value is returned if the value is not
 2359  * available.
 2360  *
 2361  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2362  *       function won't return.
 2363  *
 2364  * @note <b>multi-app safe</b>
 2365  */
 2366 //--------------------------------------------------------------------------------------------------
 2367 uint32_t le_mrc_GetNeighborCellLocAreaCode
 2368 (
 2369     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2370         ///< [IN] Cell information reference.
 2371 );
 2372 
 2373 //--------------------------------------------------------------------------------------------------
 2374 /**
 2375  * This function must be called to get the signal strength of a cell.
 2376  *
 2377  * @return The signal strength of a cell in dBm.
 2378  *
 2379  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2380  *       function won't return.
 2381  *
 2382  * @note <b>multi-app safe</b>
 2383  */
 2384 //--------------------------------------------------------------------------------------------------
 2385 int32_t le_mrc_GetNeighborCellRxLevel
 2386 (
 2387     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2388         ///< [IN] Cell information reference.
 2389 );
 2390 
 2391 //--------------------------------------------------------------------------------------------------
 2392 /**
 2393  * This function must be called to get the Radio Access Technology of a cell.
 2394  *
 2395  * @return The Radio Access Technology of a cell.
 2396  *
 2397  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2398  *       function won't return.
 2399  *
 2400  * @note <b>multi-app safe</b>
 2401  */
 2402 //--------------------------------------------------------------------------------------------------
 2403 le_mrc_Rat_t le_mrc_GetNeighborCellRat
 2404 (
 2405     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2406         ///< [IN] Cell information reference.
 2407 );
 2408 
 2409 //--------------------------------------------------------------------------------------------------
 2410 /**
 2411  * This function must be called to get the Ec/Io; the received energy per chip divided by the power
 2412  * density in the band measured in dBm on the primary CPICH channel of serving cell (negative value)
 2413  *
 2414  * @return
 2415  *  - The Ec/Io of a cell given in dB with 1 decimal place. (only applicable for UMTS network).
 2416  *  - INT32_MAX when the value isn't available.
 2417  *
 2418  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2419  *       function won't return.
 2420  *
 2421  * @note <b>multi-app safe</b>
 2422  */
 2423 //--------------------------------------------------------------------------------------------------
 2424 int32_t le_mrc_GetNeighborCellUmtsEcIo
 2425 (
 2426     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2427         ///< [IN] Cell information reference.
 2428 );
 2429 
 2430 //--------------------------------------------------------------------------------------------------
 2431 /**
 2432  * This function must be called to get the RSRP and RSRQ of the Intrafrequency of a LTE cell.
 2433  *
 2434  * @return
 2435  *      - LE_OK on success
 2436  *      - LE_FAULT on failure
 2437  *
 2438  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2439  *       function won't return.
 2440  *
 2441  * @note <b>multi-app safe</b>
 2442  */
 2443 //--------------------------------------------------------------------------------------------------
 2444 le_result_t le_mrc_GetNeighborCellLteIntraFreq
 2445 (
 2446     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2447         ///< [IN] Cell information reference.
 2448     int32_t* rsrqPtr,
 2449         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2450         ///< place
 2451     int32_t* rsrpPtr
 2452         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2453         ///< place
 2454 );
 2455 
 2456 //--------------------------------------------------------------------------------------------------
 2457 /**
 2458  * This function must be called to get the RSRP and RSRQ of the Interfrequency of a LTE cell.
 2459  *
 2460  * @return
 2461  *      - LE_OK on success
 2462  *      - LE_FAULT on failure
 2463  *
 2464  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2465  *       function won't return.
 2466  *
 2467  * @note <b>multi-app safe</b>
 2468  */
 2469 //--------------------------------------------------------------------------------------------------
 2470 le_result_t le_mrc_GetNeighborCellLteInterFreq
 2471 (
 2472     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2473         ///< [IN] Cell information reference.
 2474     int32_t* rsrqPtr,
 2475         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2476         ///< place
 2477     int32_t* rsrpPtr
 2478         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2479         ///< place
 2480 );
 2481 
 2482 //--------------------------------------------------------------------------------------------------
 2483 /**
 2484  * This function must be called to measure the signal metrics. It creates and returns a reference
 2485  * to the signal metrics.
 2486  *
 2487  * @return A reference to the signal metrics.
 2488  * @return NULL if no signal metrics are available.
 2489  *
 2490  * @note <b>multi-app safe</b>
 2491  */
 2492 //--------------------------------------------------------------------------------------------------
 2493 le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics
 2494 (
 2495     void
 2496 );
 2497 
 2498 //--------------------------------------------------------------------------------------------------
 2499 /**
 2500  * This function must be called to delete the the signal metrics.
 2501  *
 2502  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2503  *       reference for validity.
 2504  *
 2505  * @note <b>multi-app safe</b>
 2506  */
 2507 //--------------------------------------------------------------------------------------------------
 2508 void le_mrc_DeleteSignalMetrics
 2509 (
 2510     le_mrc_MetricsRef_t MetricsRef
 2511         ///< [IN] Signal metrics reference.
 2512 );
 2513 
 2514 //--------------------------------------------------------------------------------------------------
 2515 /**
 2516  * This function returns the Radio Access Technology of the signal metrics.
 2517  *
 2518  * @return The Radio Access Technology of the signal measure.
 2519  *
 2520  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2521  *       function won't return.
 2522  *
 2523  * @note <b>multi-app safe</b>
 2524  */
 2525 //--------------------------------------------------------------------------------------------------
 2526 le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics
 2527 (
 2528     le_mrc_MetricsRef_t MetricsRef
 2529         ///< [IN] Signal metrics reference.
 2530 );
 2531 
 2532 //--------------------------------------------------------------------------------------------------
 2533 /**
 2534  * This function returns the signal strength in dBm and the bit error rate measured on GSM network.
 2535  *
 2536  * @return
 2537  *      - LE_OK on success
 2538  *      - LE_FAULT on failure
 2539  *
 2540  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2541  *       function won't return.
 2542  *
 2543  * @note <b>multi-app safe</b>
 2544  */
 2545 //--------------------------------------------------------------------------------------------------
 2546 le_result_t le_mrc_GetGsmSignalMetrics
 2547 (
 2548     le_mrc_MetricsRef_t MetricsRef,
 2549         ///< [IN] Signal metrics reference.
 2550     int32_t* rssiPtr,
 2551         ///< [OUT] Signal strength in dBm
 2552     uint32_t* berPtr
 2553         ///< [OUT] Bit error rate.
 2554 );
 2555 
 2556 //--------------------------------------------------------------------------------------------------
 2557 /**
 2558  * This function returns the signal metrics measured on UMTS or TD-SCDMA networks.
 2559  *
 2560  * @return
 2561  *      - LE_OK on success
 2562  *      - LE_FAULT on failure
 2563  *
 2564  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2565  *       function won't return.
 2566  *
 2567  * @note <b>multi-app safe</b>
 2568  */
 2569 //--------------------------------------------------------------------------------------------------
 2570 le_result_t le_mrc_GetUmtsSignalMetrics
 2571 (
 2572     le_mrc_MetricsRef_t MetricsRef,
 2573         ///< [IN] Signal metrics reference.
 2574     int32_t* ssPtr,
 2575         ///< [OUT] Signal strength in dBm
 2576     uint32_t* blerPtr,
 2577         ///< [OUT] Block error rate
 2578     int32_t* ecioPtr,
 2579         ///< [OUT] Ec/Io value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2580         ///< value)
 2581     int32_t* rscpPtr,
 2582         ///< [OUT] Measured RSCP in dBm (negative value, value INT32_MAX means
 2583         ///< that RSCP is not available)
 2584     int32_t* sinrPtr
 2585         ///< [OUT] Measured SINR in dB (only applicable for TD-SCDMA network, value
 2586         ///< INT32_MAX means that the SINR is not available)
 2587 );
 2588 
 2589 //--------------------------------------------------------------------------------------------------
 2590 /**
 2591  * This function returns the signal metrics measured on LTE network.
 2592  *
 2593  * @return
 2594  *      - LE_OK on success
 2595  *      - LE_FAULT on failure
 2596  *      - sinrPtr and ioPtr return INT32_MAX when the value isn't available.
 2597  *
 2598  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2599  *       function won't return.
 2600  *
 2601  * @note <b>multi-app safe</b>
 2602  */
 2603 //--------------------------------------------------------------------------------------------------
 2604 le_result_t le_mrc_GetLteSignalMetrics
 2605 (
 2606     le_mrc_MetricsRef_t MetricsRef,
 2607         ///< [IN] Signal metrics reference.
 2608     int32_t* ssPtr,
 2609         ///< [OUT] Signal strength in dBm
 2610     uint32_t* blerPtr,
 2611         ///< [OUT] Block error rate
 2612     int32_t* rsrqPtr,
 2613         ///< [OUT] RSRQ value in dB as measured by L1 with 1 decimal place
 2614     int32_t* rsrpPtr,
 2615         ///< [OUT] Current RSRP in dBm as measured by L1 with 1 decimal place
 2616     int32_t* snrPtr
 2617         ///< [OUT] SNR level in dB with 1 decimal place (15 = 1.5 dB)
 2618 );
 2619 
 2620 //--------------------------------------------------------------------------------------------------
 2621 /**
 2622  * This function returns the signal metrics measured on CDMA network.
 2623  *
 2624  * @return
 2625  *      - LE_OK on success
 2626  *      - LE_FAULT on failure
 2627  *      - rscpPtr and sinrPtr return INT32_MAX when the value isn't available.
 2628  *
 2629  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2630  *       function won't return.
 2631  *
 2632  * @note <b>multi-app safe</b>
 2633  */
 2634 //--------------------------------------------------------------------------------------------------
 2635 le_result_t le_mrc_GetCdmaSignalMetrics
 2636 (
 2637     le_mrc_MetricsRef_t MetricsRef,
 2638         ///< [IN] Signal metrics reference.
 2639     int32_t* ssPtr,
 2640         ///< [OUT] Signal strength in dBm
 2641     uint32_t* erPtr,
 2642         ///< [OUT] Frame/Packet error rate
 2643     int32_t* ecioPtr,
 2644         ///< [OUT] ECIO value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2645         ///< value)
 2646     int32_t* sinrPtr,
 2647         ///< [OUT] SINR level in dB with 1 decimal place, (only applicable for
 2648         ///< 1xEV-DO, value INT32_MAX means that the value is not available)
 2649     int32_t* ioPtr
 2650         ///< [OUT] Received IO in dBm (only applicable for 1xEV-DO, value INT32_MAX
 2651         ///< means that the value is not available)
 2652 );
 2653 
 2654 //--------------------------------------------------------------------------------------------------
 2655 /**
 2656  * This function must be called to get the serving Cell Identifier.
 2657  *
 2658  * @return The Cell Identifier. UINT32_MAX value is returned if the value is not available.
 2659  *
 2660  * @note When the module is in UMTS network, the API returns the serving UTRAN Cell Identity (UC-Id)
 2661  * which is used to identify the cell uniquely.
 2662  * It is composed of the Controlling Radio Network Controller Identifier (CRNC-Id, 12 bits) and the
 2663  * Cell Identifier (C-Id, 16 bits). (3GPP 25.401, section 6.1.5)
 2664  * The Cell Identifier is coded in the lower 2 bytes of the 4 bytes UC-Id and the CRNC-Id is coded
 2665  * in the upper 2 bytes.
 2666  * Example: the API returns 7807609 -> 0x772279 (CRNC-Id = 0x77 , cell ID = 0x2279)
 2667  *
 2668  * @note <b>multi-app safe</b>
 2669  */
 2670 //--------------------------------------------------------------------------------------------------
 2671 uint32_t le_mrc_GetServingCellId
 2672 (
 2673     void
 2674 );
 2675 
 2676 //--------------------------------------------------------------------------------------------------
 2677 /**
 2678  * This function must be called to get the Location Area Code of the serving cell.
 2679  *
 2680  * @return The Location Area Code. UINT32_MAX value is returned if the value is not available.
 2681  *
 2682  * @note <b>multi-app safe</b>
 2683  */
 2684 //--------------------------------------------------------------------------------------------------
 2685 uint32_t le_mrc_GetServingCellLocAreaCode
 2686 (
 2687     void
 2688 );
 2689 
 2690 //--------------------------------------------------------------------------------------------------
 2691 /**
 2692  * This function must be called to get the Tracking Area Code of the serving cell (LTE only).
 2693  *
 2694  * @return The Tracking Area Code. UINT16_MAX value is returned if the value is not available.
 2695  *
 2696  * @note <b>multi-app safe</b>
 2697  */
 2698 //--------------------------------------------------------------------------------------------------
 2699 uint16_t le_mrc_GetServingCellLteTracAreaCode
 2700 (
 2701     void
 2702 );
 2703 
 2704 //--------------------------------------------------------------------------------------------------
 2705 /**
 2706  * Get the Bit mask for 2G/3G Band capabilities.
 2707  *
 2708  * @return
 2709  *  - LE_OK              on success
 2710  *  - LE_FAULT           on failure
 2711  *  - LE_UNSUPPORTED     Unable to get the 2G/3G Band capabilities on this platform
 2712  *
 2713  * @note <b>multi-app safe</b>
 2714  */
 2715 //--------------------------------------------------------------------------------------------------
 2716 le_result_t le_mrc_GetBandCapabilities
 2717 (
 2718     le_mrc_BandBitMask_t* bandMaskPtrPtr
 2719         ///< [OUT] Bit mask for 2G/3G Band capabilities.
 2720 );
 2721 
 2722 //--------------------------------------------------------------------------------------------------
 2723 /**
 2724  * Get the Bit mask for LTE Band capabilities.
 2725  *
 2726  * @return
 2727  *  - LE_OK              on success
 2728  *  - LE_FAULT           on failure
 2729  *  - LE_UNSUPPORTED     Unable to get the LTE Band capabilities on this platform
 2730  *
 2731  * @note <b>multi-app safe</b>
 2732  */
 2733 //--------------------------------------------------------------------------------------------------
 2734 le_result_t le_mrc_GetLteBandCapabilities
 2735 (
 2736     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 2737         ///< [OUT] Bit mask for LTE Band capabilities.
 2738 );
 2739 
 2740 //--------------------------------------------------------------------------------------------------
 2741 /**
 2742  * Get the Bit mask for TD-SCDMA Band capabilities.
 2743  *
 2744  * @return
 2745  *  - LE_OK              on success
 2746  *  - LE_FAULT           on failure
 2747  *  - LE_UNSUPPORTED     Unable to get the TD-SCDMA Band Capabilities on this platform
 2748  *
 2749  * @note <b>multi-app safe</b>
 2750  */
 2751 //--------------------------------------------------------------------------------------------------
 2752 le_result_t le_mrc_GetTdScdmaBandCapabilities
 2753 (
 2754     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 2755         ///< [OUT] Bit mask for TD-SCDMA Band capabilities.
 2756 );
 2757 
 2758 //--------------------------------------------------------------------------------------------------
 2759 /**
 2760  * Add handler function for EVENT 'le_mrc_NetworkReject'
 2761  *
 2762  * Event to report network reject indication.
 2763  *
 2764  */
 2765 //--------------------------------------------------------------------------------------------------
 2766 le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler
 2767 (
 2768     le_mrc_NetworkRejectHandlerFunc_t handlerPtr,
 2769         ///< [IN]
 2770     void* contextPtr
 2771         ///< [IN]
 2772 );
 2773 
 2774 //--------------------------------------------------------------------------------------------------
 2775 /**
 2776  * Remove handler function for EVENT 'le_mrc_NetworkReject'
 2777  */
 2778 //--------------------------------------------------------------------------------------------------
 2779 void le_mrc_RemoveNetworkRejectHandler
 2780 (
 2781     le_mrc_NetworkRejectHandlerRef_t handlerRef
 2782         ///< [IN]
 2783 );
 2784 
 2785 //--------------------------------------------------------------------------------------------------
 2786 /**
 2787  * Add handler function for EVENT 'le_mrc_JammingDetectionEvent'
 2788  *
 2789  * This event provides information on jamming detection.
 2790  */
 2791 //--------------------------------------------------------------------------------------------------
 2792 le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler
 2793 (
 2794     le_mrc_JammingDetectionHandlerFunc_t handlerPtr,
 2795         ///< [IN]
 2796     void* contextPtr
 2797         ///< [IN]
 2798 );
 2799 
 2800 //--------------------------------------------------------------------------------------------------
 2801 /**
 2802  * Remove handler function for EVENT 'le_mrc_JammingDetectionEvent'
 2803  */
 2804 //--------------------------------------------------------------------------------------------------
 2805 void le_mrc_RemoveJammingDetectionEventHandler
 2806 (
 2807     le_mrc_JammingDetectionEventHandlerRef_t handlerRef
 2808         ///< [IN]
 2809 );
 2810 
 2811 //--------------------------------------------------------------------------------------------------
 2812 /**
 2813  * Start the jamming detection monitoring.
 2814  *
 2815  * @warning The jamming detection feature might be limited by the platform.
 2816  *          Please refer to the platform documentation @ref platformConstraintsMdc.
 2817  *
 2818  * @return
 2819  *  - LE_OK             The function succeeded.
 2820  *  - LE_FAULT          The function failed.
 2821  *  - LE_DUPLICATE      The feature is already activated and an activation is requested.
 2822  *  - LE_UNSUPPORTED    The feature is not supported.
 2823  */
 2824 //--------------------------------------------------------------------------------------------------
 2825 le_result_t le_mrc_StartJammingDetection
 2826 (
 2827     void
 2828 );
 2829 
 2830 //--------------------------------------------------------------------------------------------------
 2831 /**
 2832  * Stop the jamming detection monitoring.
 2833  *
 2834  * @return
 2835  *  - LE_OK             The function succeeded.
 2836  *  - LE_FAULT          The function failed or the application did not start the jamming detection.
 2837  *  - LE_UNSUPPORTED    The feature is not supported.
 2838  */
 2839 //--------------------------------------------------------------------------------------------------
 2840 le_result_t le_mrc_StopJammingDetection
 2841 (
 2842     void
 2843 );
 2844 
 2845 //--------------------------------------------------------------------------------------------------
 2846 /**
 2847  * Set the SAR backoff state
 2848  *
 2849  * @warning The SAR backoff feature might be unsupported by some platforms.
 2850  *          Please refer to the platform documentation @ref platformConstraintsMdc.
 2851  *
 2852  * @return
 2853  *  - LE_OK             The function succeeded.
 2854  *  - LE_FAULT          The function failed.
 2855  *  - LE_UNSUPPORTED    The feature is not supported.
 2856  *  - LE_OUT_OF_RANGE   The provided index is out of range.
 2857  */
 2858 //--------------------------------------------------------------------------------------------------
 2859 le_result_t le_mrc_SetSarBackoffState
 2860 (
 2861     uint8_t state
 2862         ///< [IN] New state to enable. By default, SAR is disabled (state = 0).
 2863         ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
 2864 );
 2865 
 2866 //--------------------------------------------------------------------------------------------------
 2867 /**
 2868  * Get the SAR backoff state
 2869  *
 2870  * @warning The SAR backoff feature might be unsupported by some platforms.
 2871  *          Please refer to the platform documentation @ref platformConstraintsMdc.
 2872  *
 2873  * @return
 2874  *  - LE_OK             The function succeeded.
 2875  *  - LE_FAULT          The function failed.
 2876  *  - LE_UNSUPPORTED    The feature is not supported.
 2877  */
 2878 //--------------------------------------------------------------------------------------------------
 2879 le_result_t le_mrc_GetSarBackoffState
 2880 (
 2881     uint8_t* statePtr
 2882         ///< [OUT] Current state. By default, SAR is disabled (state = 0).
 2883         ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
 2884 );
 2885 
 2886 #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:837
LE_MRC_BITMASK_RAT_LTE
LTE RAT Bit Mask. 
Definition: le_mrc_interface.h:907
le_mrc_PciScanInformationListRef_t
struct le_mrc_PciScanInformationList * le_mrc_PciScanInformationListRef_t
Definition: le_mrc_interface.h:742
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:908
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:774
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:766
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:493
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_GetFirstPlmnInfo
le_mrc_PlmnInformationRef_t le_mrc_GetFirstPlmnInfo(le_mrc_PciScanInformationRef_t pciScanInformationRef)
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:790
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:798
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:835
LE_MRC_BITMASK_RAT_TDSCDMA
TD-SCDMA RAT Bit Mask. 
Definition: le_mrc_interface.h:906
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:920
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:928
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:816
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_GetNextPlmnInfo
le_mrc_PlmnInformationRef_t le_mrc_GetNextPlmnInfo(le_mrc_PciScanInformationRef_t plmnRef)
LE_MRC_JAMMING_STATUS_NULL
No jamming suspicion; radio environment is considered normal. 
Definition: le_mrc_interface.h:878
le_mrc_ScanInformationListRef_t
struct le_mrc_ScanInformationList * le_mrc_ScanInformationListRef_t
Definition: le_mrc_interface.h:734
le_mrc_TryConnectService
le_result_t le_mrc_TryConnectService(void)
le_mrc_PciNetworkScanHandlerFunc_t
void(* le_mrc_PciNetworkScanHandlerFunc_t)(le_mrc_PciScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_interface.h:1043
le_mrc_SetSignalStrengthIndDelta
le_result_t le_mrc_SetSignalStrengthIndDelta(le_mrc_Rat_t rat, uint16_t delta)
LE_MRC_RAT_LTE
LTE network. 
Definition: le_mrc_interface.h:839
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:782
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_SetSarBackoffState
le_result_t le_mrc_SetSarBackoffState(uint8_t state)
le_mrc_SignalStrengthChangeHandlerRef_t
struct le_mrc_SignalStrengthChangeHandler * le_mrc_SignalStrengthChangeHandlerRef_t
Definition: le_mrc_interface.h:944
le_mrc_GetNeighborCellsInfo
le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo(void)
le_mrc_GetPciScanMccMnc
le_result_t le_mrc_GetPciScanMccMnc(le_mrc_PlmnInformationRef_t plmnRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
le_mrc_GetCellularNetworkRat
le_mrc_Rat_t le_mrc_GetCellularNetworkRat(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_GetPciScanGlobalCellId
uint32_t le_mrc_GetPciScanGlobalCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
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:952
le_mrc_PlmnInformationRef_t
struct le_mrc_PlmnInformation * le_mrc_PlmnInformationRef_t
Definition: le_mrc_interface.h:758
LE_MRC_REG_HOME
Registered, home network. 
Definition: le_mrc_interface.h:810
LE_MRC_JAMMING_STATUS_HIGH
Definition: le_mrc_interface.h:886
le_mrc_GetSarBackoffState
le_result_t le_mrc_GetSarBackoffState(uint8_t *statePtr)
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_GetFirstPciScanInfo
le_mrc_PciScanInformationRef_t le_mrc_GetFirstPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
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:833
le_mrc_RemoveNetworkRejectHandler
void le_mrc_RemoveNetworkRejectHandler(le_mrc_NetworkRejectHandlerRef_t handlerRef)
le_mrc_RatChangeHandlerFunc_t
void(* le_mrc_RatChangeHandlerFunc_t)(le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_interface.h:984
le_mrc_GetNextPciScanInfo
le_mrc_PciScanInformationRef_t le_mrc_GetNextPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
LE_MRC_BITMASK_RAT_ALL
To Set all RAT preference Bit Mask. 
Definition: le_mrc_interface.h:909
le_mrc_RatBitMask_t
le_mrc_RatBitMask_t
Definition: le_mrc_interface.h:902
le_mrc_GetPlatformSpecificRegistrationErrorCode
int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode(void)
LE_MRC_JAMMING_REPORT_FINAL
Final jamming status report. 
Definition: le_mrc_interface.h:859
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:841
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:829
le_mrc_GetTdScdmaBandCapabilities
le_result_t le_mrc_GetTdScdmaBandCapabilities(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
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:1072
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:880
le_mrc_JammingReport_t
le_mrc_JammingReport_t
Definition: le_mrc_interface.h:857
LE_MRC_RAT_UNKNOWN
Unknown. 
Definition: le_mrc_interface.h:831
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:726
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_JammingDetectionHandlerFunc_t
void(* le_mrc_JammingDetectionHandlerFunc_t)(le_mrc_JammingReport_t report, le_mrc_JammingStatus_t status, void *contextPtr)
Definition: le_mrc_interface.h:1089
LE_MRC_JAMMING_STATUS_MEDIUM
Definition: le_mrc_interface.h:883
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:861
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_PerformPciNetworkScan
le_mrc_PciScanInformationListRef_t le_mrc_PerformPciNetworkScan(le_mrc_RatBitMask_t ratMask)
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:874
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_NetRegStateHandlerFunc_t
void(* le_mrc_NetRegStateHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:970
LE_MRC_REG_SEARCHING
Not registered but currently searching for a new operator. 
Definition: le_mrc_interface.h:812
le_mrc_StopJammingDetection
le_result_t le_mrc_StopJammingDetection(void)
le_mrc_BandBitMask_t
le_mrc_BandBitMask_t
Definition: le_mrc_interface.h:613
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_DisconnectService
void le_mrc_DisconnectService(void)
le_mrc_IsCellularNetworkInUse
bool le_mrc_IsCellularNetworkInUse(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_PerformPciNetworkScanAsync
void le_mrc_PerformPciNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_PciNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_ManualSelectionHandlerFunc_t
void(* le_mrc_ManualSelectionHandlerFunc_t)(le_result_t result, void *contextPtr)
Definition: le_mrc_interface.h:1058
le_mrc_NetRegState_t
le_mrc_NetRegState_t
Definition: le_mrc_interface.h:806
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:663
LE_MRC_REG_UNKNOWN
Unknown state. 
Definition: le_mrc_interface.h:818
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:960
LE_MRC_REG_DENIED
Registration was denied, usually because of invalid access credentials. 
Definition: le_mrc_interface.h:814
LE_MRC_BITMASK_RAT_UMTS
UMTS RAT Bit Mask. 
Definition: le_mrc_interface.h:905
le_mrc_DeletePciNetworkScan
void le_mrc_DeletePciNetworkScan(le_mrc_PciScanInformationListRef_t scanInformationListRef)
le_mrc_GetPciScanCellId
uint16_t le_mrc_GetPciScanCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
le_mrc_SignalStrengthChangeHandlerFunc_t
void(* le_mrc_SignalStrengthChangeHandlerFunc_t)(int32_t ss, void *contextPtr)
Definition: le_mrc_interface.h:1012
le_mrc_TdScdmaBandBitMask_t
le_mrc_TdScdmaBandBitMask_t
Definition: le_mrc_interface.h:709
LE_MRC_REG_NONE
Not registered and not currently searching for new operator. 
Definition: le_mrc_interface.h:808
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:904
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:936
le_mrc_CellularNetworkScanHandlerFunc_t
void(* le_mrc_CellularNetworkScanHandlerFunc_t)(le_mrc_ScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_interface.h:1027
le_mrc_PacketSwitchedChangeHandlerFunc_t
void(* le_mrc_PacketSwitchedChangeHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:998
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:876
le_mrc_PciScanInformationRef_t
struct le_mrc_PciScanInformation * le_mrc_PciScanInformationRef_t
Definition: le_mrc_interface.h:750
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:890