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