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