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