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