le_mrc_interface.h

    1 
    2 
    3 /*
    4  * ====================== WARNING ======================
    5  *
    6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    7  * DO NOT MODIFY IN ANY WAY.
    8  *
    9  * ====================== WARNING ======================
   10  */
   11 
   12 /**
   13  * @page c_mrc Modem Radio Control
   14  *
   15  * @ref le_mrc_interface.h "API Reference"
   16  *
   17  * <HR>
   18  *
   19  * The Modem Radio Control (MRC) APIs is used to control cellular network environments.
   20  *
   21  * It's important for many M2M apps to know details about cellular network environments (like
   22  * network registration and signal quality).
   23  * It allows you to limit some M2M services based on the reliability of the network environment, and
   24  * provides information to control power consumption (power on or shutdown the radio module).
   25  *
   26  * @section le_mrc_binding IPC interfaces binding
   27  *
   28  * All the functions of this API are provided by the @b modemService service.
   29  *
   30  * Here's a code sample binding to modem services:
   31  * @verbatim
   32    bindings:
   33    {
   34       clientExe.clientComponent.le_mrc -> modemService.le_mrc
   35    }
   36    @endverbatim
   37  *
   38  * @section le_mrc_power Radio Power Management
   39  * le_mrc_SetRadioPower() API allows the application to power up or shutdown the radio module.
   40  *
   41  * le_mrc_GetRadioPower() API displays radio module power state.
   42  *
   43  * A sample code can be seen in the following page:
   44  * - @subpage c_mrcRadioPower
   45  *
   46  * @section le_mrc_configuration Radio Configuration preferences
   47  *
   48  * The following functions let you configure and retrieve the radio configuration preferences:
   49  * le_mrc_SetAutomaticRegisterMode(), le_mrc_SetManualRegisterMode() and le_mrc_GetRegisterMode()
   50  * let you set/get the selected Scan mode.
   51  *
   52  * le_mrc_SetBandPreferences(), le_mrc_GetBandPreferences() let you set/get the 2G/3G band
   53  * preferences by using a bit mask built with @c le_mrc_BandBitMask_t
   54  *
   55  * The 2G/3G band preferences can be:
   56  * - Band-Class-0-A-System
   57  * - Band-Class-0-B-System
   58  * - Band-Class-1-All-Blocks
   59  * - Band-Class-2-Placeholder
   60  * - Band-Class-3-A-System
   61  * - Band-Class-4-All-Blocks
   62  * - Band-Class-5-All-Blocks
   63  * - Band-Class-6
   64  * - Band-Class-7
   65  * - Band-Class-8
   66  * - Band-Class-9
   67  * - Band-Class-10
   68  * - Band-Class-11
   69  * - Band-Class-12
   70  * - Band-Class-13
   71  * - Band-Class-14
   72  * - Band-Class-15
   73  * - Band-Class-16
   74  * - Band-Class-17
   75  * - Band-Class-18
   76  * - Band-Class-19
   77  * - GSM-DCS-1800
   78  * - E-GSM-900 (for Extended GSM 900 band)
   79  * - Primary-GSM-900
   80  * - GSM-450
   81  * - GSM-480
   82  * - GSM-750
   83  * - GSM-850
   84  * - GSMR-900 (for GSM Railways GSM 900 band)
   85  * - GSM-PCS-1900
   86  * - WCDMA-EU-J-CH-IMT-2100 (for WCDMA Europe, Japan, and China IMT 2100 band)
   87  * - WCDMA-US-PCS-1900 (for WCDMA U.S. PCS 1900 band)
   88  * - WCDMA-EU-CH-DCS-1800 (for WCDMA Europe and China DCS 1800 band)
   89  * - WCDMA-US-1700 (for WCDMA U.S. 1700 band)
   90  * - WCDMA-US-850 (for WCDMA U.S. 850 band)
   91  * - WCDMA-J-800 (for WCDMA Japan 800 band)
   92  * - WCDMA-EU-2600 (for WCDMA Europe 2600 band)
   93  * - WCDMA-EU-J-900 (for WCDMA Europe and Japan 900 band)
   94  * - WCDMA-J-1700 (for WCDMA Japan 1700 band)
   95  *
   96  * le_mrc_SetLteBandPreferences(), le_mrc_GetLteBandPreferences() let you set/get the LTE band
   97  * preferences by using a bit mask built with @c le_mrc_LteBandBitMask_t.
   98  *
   99  * The LTE band preferences can be 0 to 43 except 15, 16, 22, 23, and 26 to 32.
  100  *
  101  * le_mrc_SetTdScdmaBandPreferences(), le_mrc_GetTdScdmaBandPreferences() let you set/get the
  102  * TD-SCDMA band preferences by using a bit mask built with @c le_mrc_TdScdmaBandBitMask_t
  103  *
  104  * The TD-SCDMA band preferences can be 'A' to 'F'
  105  *
  106  * @warning Ensure to check the supported preferences for your specific platform.
  107  *
  108  * le_mrc_AddPreferredOperator() , le_mrc_RemovePreferredOperator() to add/remove a preferred
  109  * operator by specifying the MCC/MNC and the Radio Access Technology.
  110  *
  111  * le_mrc_GetPreferredOperatorsList(), le_mrc_GetFirstPreferredOperator(),
  112  * le_mrc_GetNextPreferredOperator(), le_mrc_DeletePreferredOperatorsList(),
  113  * le_mrc_GetPreferredOperatorDetails() let you retrieve a list of the selected preferred
  114  * operators and get their details.
  115  *
  116  * A sample code can be seen in the following page:
  117  * - @subpage c_mrcRadioConfigurationPreferences
  118  *
  119  * @section le_mrc_NetworkRejectHandler Report Network Reject Indication
  120  *
  121  * The application can register a handler function to report network reject with MNC/MCC code and
  122  * the Radio Access Technology using le_mrc_AddNetworkRejectHandler() API.
  123  *
  124  * le_mrc_RemoveNetworkRejectHandler() API uninstalls the handler function.
  125  *
  126  * @section le_mrc_capabilities Radio Capabilities
  127  *
  128  * le_mrc_GetBandCapabilities() let you get the 2G/3G band capabilities by retrieving a bit mask
  129  * built with @c le_mrc_BandBitMask_t
  130  *
  131  * le_mrc_GetLteBandCapabilities() let you get the LTE band capabilities by retrieving a bit mask
  132  * built with @c le_mrc_LteBandBitMask_t
  133  *
  134  * le_mrc_GetTdScdmaBandCapabilities() let you get the TD-SCDMA band capabilities by retrieving
  135  * a bit mask built with @c le_mrc_TdScdmaBandBitMask_t
  136  *
  137  * A sample code can be seen in the following page:
  138  * - @subpage c_mrcBandCapabilities
  139  *
  140  * @section le_mrc_rat Radio Access Technology (RAT)
  141  * le_mrc_GetRadioAccessTechInUse() API retrieves the current active Radio Access Technology.
  142  *
  143  * The application can register a handler function to retrieve the Radio Access Technology each time
  144  * the RAT changes.
  145  *
  146  * le_mrc_AddRatChangeHandler() API installs a RAT change handler.
  147  *
  148  * le_mrc_RemoveRatChangeHandler() API uninstalls the handler function.
  149  *
  150  * le_mrc_SetRatPreferences(), le_mrc_GetRatPreferences() let you set/get the Radio Access
  151  * Technology preferences by using a bit mask built with @c le_mrc_RatBitMask_t.
  152  *
  153  * The Radio Access Technology preferences can be:
  154  * - CDMA (CDMA2000-1X + CDMA2000-HRPD)
  155  * - GSM
  156  * - UMTS (UMTS)
  157  * - TDSCDMA (TD-SCDMA)
  158  * - LTE
  159  *
  160  * @note LE_MRC_BITMASK_RAT_ALL value can be used to select the RAT in automatic mode.
  161  *
  162  * A sample code can be seen in the following page:
  163  * - @subpage c_mrcRAT
  164  *
  165  * @section le_mrc_registration Network Registration
  166  * le_mrc_GetNetRegState() API retrieves the radio module network registration status.
  167  *
  168  * The application can register a handler function to retrieve the registration status each time the
  169  * registration state changes.
  170  *
  171  * le_mrc_AddNetRegStateEventHandler() API installs a registration state handler.
  172  *
  173  * le_mrc_RemoveNetRegStateEventHandler() API uninstalls the handler function.
  174  * @note If only one handler is registered, the le_mrc_RemoveNetRegStateHandler() API
  175  *       resets the registration mode to its original value before any handler functions were added.
  176  *
  177  * le_mrc_SetManualRegisterMode() API registers on a cellular network.
  178  *
  179  * Call le_mrc_SetManualRegisterModeAsync() function to set the manual registration mode
  180  *  asynchronously. The function is not blocking. The response will be returned with the
  181  *  @c le_mrc_ManualSelectionHandlerFunc_t handler function.
  182  *
  183  * When the network registration fails, the platform specific network registration error code can
  184  * be known by using le_mrc_GetPlatformSpecificRegistrationErrorCode() API.
  185  * Please refer to @ref platformConstraintsSpecificErrorCodes for platform specific
  186  * registration error code description.
  187  *
  188  * A sample code can be seen in the following page:
  189  * - @subpage c_mrcNetworkRegistration
  190  *
  191  * @section le_mrc_service Packet services state
  192  *
  193  * le_mrc_GetPacketSwitchedState() API retrieves the current Packet Switched state
  194  * @ref le_mrc_NetRegState_t.
  195  *
  196  * The Packet Switched services state can be:
  197  * - NONE
  198  * - HOME
  199  * - ROAMING
  200  *
  201  * The application can register a handler function to retrieve the Packet
  202  * Switched state each time the service state changes.
  203  *
  204  * le_mrc_AddPacketSwitchedChangeHandler() API installs a Packet Switched state handler.
  205  *
  206  * le_mrc_RemovePacketSwitchedChangeHandler() API uninstalls the handler function.
  207  *
  208  * A sample code can be seen in the following page:
  209  * - @subpage c_mrcGetService
  210  *
  211  * @section le_mrc_signal Signal Quality
  212  *
  213  * le_mrc_GetSignalQual() retrieves the received signal strength details.
  214  *
  215  * You must call le_mrc_MeasureSignalMetrics() to measure the signal metrics of the serving cell
  216  * (aka the 'serving' cell). It returns a reference of le_mrc_MetricsRef_t type.
  217  *
  218  * When the signal metrics are no longer needed, you must call le_mrc_DeleteSignalMetrics() to free
  219  * all allocated ressources associated with the Metrics object.
  220  *
  221  * le_mrc_GetRatOfSignalMetrics() returns the Radio Access Technology of the signal measures.
  222  *
  223  * le_mrc_GetGsmSignalMetrics() the signal strength in dBm and the bit error rate measured on GSM
  224  * network.
  225  *
  226  * le_mrc_GetUmtsSignalMetrics() returns the signal metrics measured on UMTS or TD-SCDMA networks.
  227  *
  228  * le_mrc_GetLteSignalMetrics() returns the signal metrics measured on LTE network.
  229  *
  230  * le_mrc_GetCdmaSignalMetrics() returns the signal metrics measured on CDMA network.
  231  *
  232  * The application can register a handler function to get notifications when the signal strength
  233  * changes of a certain threshold value.
  234  *
  235  * le_mrc_AddSignalStrengthChangeHandler() API installs a signal strength change handler.
  236  * The RAT, the lower-range and the upper-range thresholds must be passed as input parameters. These
  237  * parameters are updated each time the function is called, the previous thresholds are replaced by
  238  * the new ones if the function is called with the same RAT. The event is notified when we cross the
  239  * range limits in both direction.
  240  *
  241  * @warning The threshold values must be in the allowed platform range and the RAT must be valid,
  242  *          else, it's a fatal error, le_mrc_AddSignalStrengthChangeHandler API won't return.
  243  *
  244  * le_mrc_RemoveSignalStrengthChangeHandler() API uninstalls the handler function.
  245  *
  246  * le_mrc_SetSignalStrengthIndThresholds() API changes or sets new thresholds.
  247  *
  248  * le_mrc_SetSignalStrengthIndDelta() API sets a signal strength indication delta value for a
  249  * specific RAT. The event is notified when the delta range is crossed in both direction.
  250  *
  251  * A sample code can be seen in the following page:
  252  * - @subpage c_mrcQuality
  253  *
  254  * @section le_mrc_location Serving cell's location information
  255  *
  256  * le_mrc_GetServingCellId() retrieves the the serving Cell Identifier.
  257  *
  258  * le_mrc_GetServingCellLocAreaCode() retrieves the Location Area Code of the serving cell.
  259  *
  260  * le_mrc_GetServingCellLteTracAreaCode() retrieves the the Tracking Area Code of the serving cell
  261  * (LTE only).
  262  *
  263  * A sample code can be seen in the following page:
  264  * - @subpage c_mrcLocationinformation
  265  *
  266  * @section le_mrc_network_information Current Network Information
  267  * le_mrc_GetCurrentNetworkName() retrieves the Current Network Name.
  268  * le_mrc_GetCurrentNetworkMccMnc() retrieves the Current Network PLMN information.
  269  *
  270  * A sample code can be seen in the following page:
  271  * - @subpage c_mrcGetCurrentNetwork
  272  *
  273  * @section le_mrc_networkScan Network Scan
  274  *
  275  * Call le_mrc_PerformCellularNetworkScan() to fill a list of all network in sight.
  276  * You can go through all Scan Information by calling le_mrc_GetFirstCellularNetworkScan() and
  277  * le_mrc_GetNextCellularNetworkScan().
  278  *
  279  * Call le_mrc_PerformCellularNetworkScanAsync() to start a network scan asynchronously. The
  280  * function is not blocking. The scan list reference will be returned with the handler function
  281  * response (@c le_mrc_CellularNetworkScanHandlerFunc_t).
  282  *
  283  * For each Scan Information, you can call:
  284  *
  285  *  - le_mrc_GetCellularNetworkMccMnc() to have the operator code.
  286  *  - le_mrc_GetCellularNetworkName() to get the operator name.
  287  *  - le_mrc_GetCellularNetworkRat() to get the radio access technology.
  288  *  - le_mrc_IsCellularNetworkInUse() to check if this is currently in use by the network.
  289  *  - le_mrc_IsCellularNetworkAvailable() to check if this is available.
  290  *  - le_mrc_IsCellularNetworkHome() to check if this is in home status.
  291  *  - le_mrc_IsCellularNetworkForbidden() to check if this is forbidden by the network.
  292  *
  293  * le_mrc_DeleteCellularNetworkScan() should be called when you do not need the list anymore.
  294  *
  295  * A sample code can be seen in the following page:
  296  * - @subpage c_mrcNetworkScan
  297  *
  298  * @section le_mrc_ngbr Neighboring Cells Information
  299  *
  300  * @warning The following functions do not apply to CDMA network.
  301  *
  302  * You must call le_mrc_GetNeighborCellsInfo() to retrieve the neighboring cells
  303  * information. It returns a reference of le_mrc_NeighborCellsRef_t type.
  304  *
  305  * When the neighboring cells information is no longer needed, you must call
  306  * le_mrc_DeleteNeighborCellsInfo() to free all allocated resources associated with the
  307  * object.
  308  *
  309  * Then, you can use the following function to get the information:
  310  * - le_mrc_GetFirstNeighborCellInfo() and le_mrc_GetFirstNeighborCellInfo() allow to go among
  311  *   the single cell information retrieved with le_mrc_GetNeighborCellsInfo(). These two functions
  312  *   return a reference of le_mrc_CellInfoRef_t type.
  313  * - le_mrc_GetNeighborCellId() gets the identifier of the cell specified with the
  314  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT).
  315  * - le_mrc_GetNeighborCellLocAreaCode() gets the location area code of the cell specified with the
  316  *   le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT16_MAX value is
  317  *   returned if the value is not available.
  318  * - le_mrc_GetNeighborCellRxLevel() gets the signal strength (in dBm) of the cell specified with
  319  *   the le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT).
  320  * - le_mrc_GetNeighborCellRat() gets the Radio Access Technology of the cell specified with
  321  *   the le_mrc_CellInfoRef_t parameter.
  322  * - le_mrc_GetNeighborCellUmtsEcIo() gets the Ec/Io (the received energy per chip divided by the
  323  *   power density in the band measured in dBm on the primary CPICH channel of serving cell) of the
  324  *   cell specified with the le_mrc_CellInfoRef_t parameter.
  325  * - le_mrc_GetNeighborCellLteIntraFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  326  *   specified with the le_mrc_CellInfoRef_t parameter.
  327  * - le_mrc_GetNeighborCellLteInterFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
  328  *   specified with the le_mrc_CellInfoRef_t parameter.
  329  *
  330  * A sample code can be seen in the following page:
  331  * - @subpage c_mrcNeighborCells
  332  *
  333  * <HR>
  334  *
  335  * Copyright (C) Sierra Wireless Inc.
  336  */
  337 /**
  338  * @page c_mrcRadioPower Sample code for Radio Power Management
  339  *
  340  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Radio Power
  341  */
  342 /**
  343  * @page c_mrcRadioConfigurationPreferences Sample code for Radio Configuration Preferences
  344  *
  345  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Preferences
  346  *
  347  */
  348 /**
  349  * @page c_mrcRAT Sample code for Radio Access Technology
  350  *
  351  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT in Use
  352  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT Preferences
  353  *
  354  */
  355 /**
  356  * @page c_mrcNetworkRegistration Sample code for Network Registration
  357  *
  358  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Register
  359  *
  360  */
  361 /**
  362  * @page c_mrcQuality Sample code for Signal Quality
  363  *
  364  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Signal Quality
  365  *
  366  */
  367 /**
  368  * @page c_mrcLocationinformation Sample code for Location information
  369  *
  370  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Loc information
  371  *
  372  */
  373 /**
  374  * @page c_mrcBandCapabilities Sample code for Band Capabilities
  375  *
  376  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Capabilities
  377  *
  378  */
  379 /**
  380  * @page c_mrcGetCurrentNetwork Sample code for Get Current Network Information
  381  *
  382  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Get Network
  383  *
  384  */
  385 /**
  386  * @page c_mrcNetworkScan Sample code for Network Scan
  387  *
  388  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Network Scan
  389  *
  390  */
  391 /**
  392  * @page c_mrcNeighborCells Sample code for Neighboring Cells Information
  393  *
  394  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Neighbor Cells
  395  *
  396  */
  397 /**
  398  * @page c_mrcGetService Sample code for Get the Current Packet Switched state
  399  *
  400  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Service State
  401  *
  402  */
  403 /**
  404  * @file le_mrc_interface.h
  405  *
  406  * Legato @ref c_mrc include file.
  407  *
  408  * Copyright (C) Sierra Wireless Inc.
  409  */
  410 
  411 #ifndef LE_MRC_INTERFACE_H_INCLUDE_GUARD
  412 #define LE_MRC_INTERFACE_H_INCLUDE_GUARD
  413 
  414 
  415 #include "legato.h"
  416 
  417 
  418 //--------------------------------------------------------------------------------------------------
  419 /**
  420  * Type for handler called when a server disconnects.
  421  */
  422 //--------------------------------------------------------------------------------------------------
  423 typedef void (*le_mrc_DisconnectHandler_t)(void *);
  424 
  425 //--------------------------------------------------------------------------------------------------
  426 /**
  427  *
  428  * Connect the current client thread to the service providing this API. Block until the service is
  429  * available.
  430  *
  431  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  432  * called before any other functions in this API.  Normally, ConnectService is automatically called
  433  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  434  *
  435  * This function is created automatically.
  436  */
  437 //--------------------------------------------------------------------------------------------------
  438 void le_mrc_ConnectService
  439 (
  440     void
  441 );
  442 
  443 //--------------------------------------------------------------------------------------------------
  444 /**
  445  *
  446  * Try to connect the current client thread to the service providing this API. Return with an error
  447  * if the service is not available.
  448  *
  449  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  450  * called before any other functions in this API.  Normally, ConnectService is automatically called
  451  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  452  *
  453  * This function is created automatically.
  454  *
  455  * @return
  456  *  - LE_OK if the client connected successfully to the service.
  457  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  458  *    bound.
  459  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  460  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  461  */
  462 //--------------------------------------------------------------------------------------------------
  463 le_result_t le_mrc_TryConnectService
  464 (
  465     void
  466 );
  467 
  468 //--------------------------------------------------------------------------------------------------
  469 /**
  470  * Set handler called when server disconnection is detected.
  471  *
  472  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  473  * to continue without exiting, it should call longjmp() from inside the handler.
  474  */
  475 //--------------------------------------------------------------------------------------------------
  476 void le_mrc_SetServerDisconnectHandler
  477 (
  478     le_mrc_DisconnectHandler_t disconnectHandler,
  479     void *contextPtr
  480 );
  481 
  482 //--------------------------------------------------------------------------------------------------
  483 /**
  484  *
  485  * Disconnect the current client thread from the service providing this API.
  486  *
  487  * Normally, this function doesn't need to be called. After this function is called, there's no
  488  * longer a connection to the service, and the functions in this API can't be used. For details, see
  489  * @ref apiFilesC_client.
  490  *
  491  * This function is created automatically.
  492  */
  493 //--------------------------------------------------------------------------------------------------
  494 void le_mrc_DisconnectService
  495 (
  496     void
  497 );
  498 
  499 
  500 //--------------------------------------------------------------------------------------------------
  501 /**
  502  * Mobile Country Code length
  503  */
  504 //--------------------------------------------------------------------------------------------------
  505 #define LE_MRC_MCC_LEN 3
  506 
  507 //--------------------------------------------------------------------------------------------------
  508 /**
  509  * Mobile Country Code length
  510  * One extra byte is added for the null character.
  511  */
  512 //--------------------------------------------------------------------------------------------------
  513 #define LE_MRC_MCC_BYTES 4
  514 
  515 //--------------------------------------------------------------------------------------------------
  516 /**
  517  * Mobile Network Code length
  518  */
  519 //--------------------------------------------------------------------------------------------------
  520 #define LE_MRC_MNC_LEN 3
  521 
  522 //--------------------------------------------------------------------------------------------------
  523 /**
  524  * Mobile Network Code length
  525  * One extra byte is added for the null character.
  526  */
  527 //--------------------------------------------------------------------------------------------------
  528 #define LE_MRC_MNC_BYTES 4
  529 
  530 //--------------------------------------------------------------------------------------------------
  531 /**
  532  * Cellular Network length.
  533  *
  534  */
  535 //--------------------------------------------------------------------------------------------------
  536 #define LE_MRC_NETWORK_NAME_MAX_LEN 100
  537 
  538 //--------------------------------------------------------------------------------------------------
  539 /**
  540  * 2G/3G Band Bit Mask (64 bits)
  541  */
  542 //--------------------------------------------------------------------------------------------------
  543 typedef enum
  544 {
  545     LE_MRC_BITMASK_BAND_CLASS_0_A_SYSTEM = 0x1,
  546     LE_MRC_BITMASK_BAND_CLASS_0_B_SYSTEM = 0x2,
  547     LE_MRC_BITMASK_BAND_CLASS_1_ALL_BLOCKS = 0x4,
  548     LE_MRC_BITMASK_BAND_CLASS_2_PLACEHOLDER = 0x8,
  549     LE_MRC_BITMASK_BAND_CLASS_3_A_SYSTEM = 0x10,
  550     LE_MRC_BITMASK_BAND_CLASS_4_ALL_BLOCKS = 0x20,
  551     LE_MRC_BITMASK_BAND_CLASS_5_ALL_BLOCKS = 0x40,
  552     LE_MRC_BITMASK_BAND_CLASS_6 = 0x80,
  553     LE_MRC_BITMASK_BAND_CLASS_7 = 0x100,
  554     LE_MRC_BITMASK_BAND_CLASS_8 = 0x200,
  555     LE_MRC_BITMASK_BAND_CLASS_9 = 0x400,
  556     LE_MRC_BITMASK_BAND_CLASS_10 = 0x800,
  557     LE_MRC_BITMASK_BAND_CLASS_11 = 0x1000,
  558     LE_MRC_BITMASK_BAND_CLASS_12 = 0x2000,
  559     LE_MRC_BITMASK_BAND_CLASS_14 = 0x4000,
  560     LE_MRC_BITMASK_BAND_CLASS_15 = 0x8000,
  561     LE_MRC_BITMASK_BAND_CLASS_16 = 0x10000,
  562     LE_MRC_BITMASK_BAND_CLASS_17 = 0x20000,
  563     LE_MRC_BITMASK_BAND_CLASS_18 = 0x40000,
  564     LE_MRC_BITMASK_BAND_CLASS_19 = 0x80000,
  565     LE_MRC_BITMASK_BAND_GSM_DCS_1800 = 0x100000,
  566     LE_MRC_BITMASK_BAND_EGSM_900 = 0x200000,
  567     LE_MRC_BITMASK_BAND_PRI_GSM_900 = 0x400000,
  568     LE_MRC_BITMASK_BAND_GSM_450 = 0x800000,
  569     LE_MRC_BITMASK_BAND_GSM_480 = 0x1000000,
  570     LE_MRC_BITMASK_BAND_GSM_750 = 0x2000000,
  571     LE_MRC_BITMASK_BAND_GSM_850 = 0x4000000,
  572     LE_MRC_BITMASK_BAND_GSMR_900 = 0x8000000,
  573     LE_MRC_BITMASK_BAND_GSM_PCS_1900 = 0x10000000,
  574     LE_MRC_BITMASK_BAND_WCDMA_EU_J_CH_IMT_2100 = 0x20000000,
  575     LE_MRC_BITMASK_BAND_WCDMA_US_PCS_1900 = 0x40000000,
  576     LE_MRC_BITMASK_BAND_WCDMA_EU_CH_DCS_1800 = 0x80000000,
  577     LE_MRC_BITMASK_BAND_WCDMA_US_1700 = 0x100000000,
  578     LE_MRC_BITMASK_BAND_WCDMA_US_850 = 0x200000000,
  579     LE_MRC_BITMASK_BAND_WCDMA_J_800 = 0x400000000,
  580     LE_MRC_BITMASK_BAND_WCDMA_EU_2600 = 0x800000000,
  581     LE_MRC_BITMASK_BAND_WCDMA_EU_J_900 = 0x1000000000,
  582     LE_MRC_BITMASK_BAND_WCDMA_J_1700 = 0x2000000000
  583 }
  584 le_mrc_BandBitMask_t;
  585 
  586 
  587 //--------------------------------------------------------------------------------------------------
  588 /**
  589  * LTE Band Bit Mask (32bits)
  590  *
  591  */
  592 //--------------------------------------------------------------------------------------------------
  593 typedef enum
  594 {
  595     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_1 = 0x1,
  596     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_2 = 0x2,
  597     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_3 = 0x4,
  598     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_4 = 0x8,
  599     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_5 = 0x10,
  600     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_6 = 0x20,
  601     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_7 = 0x40,
  602     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_8 = 0x80,
  603     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_9 = 0x100,
  604     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_10 = 0x200,
  605     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_11 = 0x400,
  606     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_12 = 0x800,
  607     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_13 = 0x1000,
  608     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_14 = 0x2000,
  609     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_17 = 0x4000,
  610     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_18 = 0x8000,
  611     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_19 = 0x10000,
  612     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_20 = 0x20000,
  613     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_21 = 0x40000,
  614     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_24 = 0x80000,
  615     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_25 = 0x100000,
  616     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_33 = 0x200000,
  617     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_34 = 0x400000,
  618     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_35 = 0x800000,
  619     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_36 = 0x1000000,
  620     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_37 = 0x2000000,
  621     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_38 = 0x4000000,
  622     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_39 = 0x8000000,
  623     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_40 = 0x10000000,
  624     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_41 = 0x20000000,
  625     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_42 = 0x40000000,
  626     LE_MRC_BITMASK_LTE_BAND_E_UTRA_OP_BAND_43 = 0x80000000
  627 }
  628 le_mrc_LteBandBitMask_t;
  629 
  630 
  631 //--------------------------------------------------------------------------------------------------
  632 /**
  633  * TDSCDMA Band Bit Mask
  634  *
  635  */
  636 //--------------------------------------------------------------------------------------------------
  637 typedef enum
  638 {
  639     LE_MRC_BITMASK_TDSCDMA_BAND_A = 0x1,
  640     LE_MRC_BITMASK_TDSCDMA_BAND_B = 0x2,
  641     LE_MRC_BITMASK_TDSCDMA_BAND_C = 0x4,
  642     LE_MRC_BITMASK_TDSCDMA_BAND_D = 0x8,
  643     LE_MRC_BITMASK_TDSCDMA_BAND_E = 0x10,
  644     LE_MRC_BITMASK_TDSCDMA_BAND_F = 0x20
  645 }
  646 le_mrc_TdScdmaBandBitMask_t;
  647 
  648 
  649 //--------------------------------------------------------------------------------------------------
  650 /**
  651  * Reference type for referring to MRC Scan Information objects.
  652  */
  653 //--------------------------------------------------------------------------------------------------
  654 typedef struct le_mrc_ScanInformation* le_mrc_ScanInformationRef_t;
  655 
  656 
  657 //--------------------------------------------------------------------------------------------------
  658 /**
  659  * Reference type for Scan Information Listing.
  660  */
  661 //--------------------------------------------------------------------------------------------------
  662 typedef struct le_mrc_ScanInformationList* le_mrc_ScanInformationListRef_t;
  663 
  664 
  665 //--------------------------------------------------------------------------------------------------
  666 /**
  667  * Reference type for referring to the Preferred Operator objects.
  668  */
  669 //--------------------------------------------------------------------------------------------------
  670 typedef struct le_mrc_PreferredOperator* le_mrc_PreferredOperatorRef_t;
  671 
  672 
  673 //--------------------------------------------------------------------------------------------------
  674 /**
  675  * Reference type for Preferred Operator Listing.
  676  */
  677 //--------------------------------------------------------------------------------------------------
  678 typedef struct le_mrc_PreferredOperatorList* le_mrc_PreferredOperatorListRef_t;
  679 
  680 
  681 //--------------------------------------------------------------------------------------------------
  682 /**
  683  *  Reference type for one Cell Information.
  684  */
  685 //--------------------------------------------------------------------------------------------------
  686 typedef struct le_mrc_CellInfo* le_mrc_CellInfoRef_t;
  687 
  688 
  689 //--------------------------------------------------------------------------------------------------
  690 /**
  691  *  Reference type for all Neighboring Cells Information.
  692  */
  693 //--------------------------------------------------------------------------------------------------
  694 typedef struct le_mrc_NeighborCells* le_mrc_NeighborCellsRef_t;
  695 
  696 
  697 //--------------------------------------------------------------------------------------------------
  698 /**
  699  *  Reference type for the signal metrics.
  700  */
  701 //--------------------------------------------------------------------------------------------------
  702 typedef struct le_mrc_Metrics* le_mrc_MetricsRef_t;
  703 
  704 
  705 //--------------------------------------------------------------------------------------------------
  706 /**
  707  * Network Registration states.
  708  */
  709 //--------------------------------------------------------------------------------------------------
  710 typedef enum
  711 {
  712     LE_MRC_REG_NONE = 0,
  713         ///< Not registered and not currently searching for new operator.
  714     LE_MRC_REG_HOME = 1,
  715         ///< Registered, home network.
  716     LE_MRC_REG_SEARCHING = 2,
  717         ///< Not registered but currently searching for a new operator.
  718     LE_MRC_REG_DENIED = 3,
  719         ///< Registration was denied, usually because of invalid access credentials.
  720     LE_MRC_REG_ROAMING = 4,
  721         ///< Registered to a roaming network.
  722     LE_MRC_REG_UNKNOWN = 5
  723         ///< Unknown state.
  724 }
  725 le_mrc_NetRegState_t;
  726 
  727 
  728 //--------------------------------------------------------------------------------------------------
  729 /**
  730  * Radio Access Technology enum
  731  */
  732 //--------------------------------------------------------------------------------------------------
  733 typedef enum
  734 {
  735     LE_MRC_RAT_UNKNOWN = 0,
  736         ///< Unknown
  737     LE_MRC_RAT_GSM = 1,
  738         ///< GSM network
  739     LE_MRC_RAT_UMTS = 2,
  740         ///< UMTS networks
  741     LE_MRC_RAT_TDSCDMA = 3,
  742         ///< TD-SCDMA networks
  743     LE_MRC_RAT_LTE = 4,
  744         ///< LTE network
  745     LE_MRC_RAT_CDMA = 5
  746         ///< CDMA network
  747 }
  748 le_mrc_Rat_t;
  749 
  750 
  751 //--------------------------------------------------------------------------------------------------
  752 /**
  753  * Radio Bitmask Access Technology Bit Mask
  754  */
  755 //--------------------------------------------------------------------------------------------------
  756 typedef enum
  757 {
  758     LE_MRC_BITMASK_RAT_GSM = 0x1,        ///< GSM RAT Bit Mask
  759     LE_MRC_BITMASK_RAT_UMTS = 0x2,        ///< UMTS RAT Bit Mask
  760     LE_MRC_BITMASK_RAT_TDSCDMA = 0x4,        ///< TD-SCDMA RAT Bit Mask
  761     LE_MRC_BITMASK_RAT_LTE = 0x8,        ///< LTE RAT Bit Mask
  762     LE_MRC_BITMASK_RAT_CDMA = 0x10,        ///< CDMA RAT Bit Mask
  763     LE_MRC_BITMASK_RAT_ALL = 0x20,        ///< To Set all RAT preference Bit Mask
  764     LE_MRC_BITMASK_RAT_MAX = 0x40
  765 }
  766 le_mrc_RatBitMask_t;
  767 
  768 
  769 //--------------------------------------------------------------------------------------------------
  770 /**
  771  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegStateEvent'
  772  */
  773 //--------------------------------------------------------------------------------------------------
  774 typedef struct le_mrc_NetRegStateEventHandler* le_mrc_NetRegStateEventHandlerRef_t;
  775 
  776 
  777 //--------------------------------------------------------------------------------------------------
  778 /**
  779  * Reference type used by Add/Remove functions for EVENT 'le_mrc_RatChange'
  780  */
  781 //--------------------------------------------------------------------------------------------------
  782 typedef struct le_mrc_RatChangeHandler* le_mrc_RatChangeHandlerRef_t;
  783 
  784 
  785 //--------------------------------------------------------------------------------------------------
  786 /**
  787  * Reference type used by Add/Remove functions for EVENT 'le_mrc_PacketSwitchedChange'
  788  */
  789 //--------------------------------------------------------------------------------------------------
  790 typedef struct le_mrc_PacketSwitchedChangeHandler* le_mrc_PacketSwitchedChangeHandlerRef_t;
  791 
  792 
  793 //--------------------------------------------------------------------------------------------------
  794 /**
  795  * Reference type used by Add/Remove functions for EVENT 'le_mrc_SignalStrengthChange'
  796  */
  797 //--------------------------------------------------------------------------------------------------
  798 typedef struct le_mrc_SignalStrengthChangeHandler* le_mrc_SignalStrengthChangeHandlerRef_t;
  799 
  800 
  801 //--------------------------------------------------------------------------------------------------
  802 /**
  803  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetworkReject'
  804  */
  805 //--------------------------------------------------------------------------------------------------
  806 typedef struct le_mrc_NetworkRejectHandler* le_mrc_NetworkRejectHandlerRef_t;
  807 
  808 
  809 //--------------------------------------------------------------------------------------------------
  810 /**
  811  * Handler for Network registration state changes.
  812  *
  813  */
  814 //--------------------------------------------------------------------------------------------------
  815 typedef void (*le_mrc_NetRegStateHandlerFunc_t)
  816 (
  817     le_mrc_NetRegState_t state,
  818         ///< Parameter ready to receive the Network Registration state.
  819     void* contextPtr
  820         ///<
  821 );
  822 
  823 //--------------------------------------------------------------------------------------------------
  824 /**
  825  * Handler for Radio Access Technology changes.
  826  *
  827  */
  828 //--------------------------------------------------------------------------------------------------
  829 typedef void (*le_mrc_RatChangeHandlerFunc_t)
  830 (
  831     le_mrc_Rat_t rat,
  832         ///< Parameter ready to receive the Radio Access Technology.
  833     void* contextPtr
  834         ///<
  835 );
  836 
  837 //--------------------------------------------------------------------------------------------------
  838 /**
  839  * Handler for Packet Switched service state changes.
  840  *
  841  */
  842 //--------------------------------------------------------------------------------------------------
  843 typedef void (*le_mrc_PacketSwitchedChangeHandlerFunc_t)
  844 (
  845     le_mrc_NetRegState_t state,
  846         ///< Parameter ready to receive the Packet Switched service state.
  847     void* contextPtr
  848         ///<
  849 );
  850 
  851 //--------------------------------------------------------------------------------------------------
  852 /**
  853  * Handler for Signal Strength value changes.
  854  *
  855  */
  856 //--------------------------------------------------------------------------------------------------
  857 typedef void (*le_mrc_SignalStrengthChangeHandlerFunc_t)
  858 (
  859     int32_t ss,
  860         ///< Signal strength in dBm
  861     void* contextPtr
  862         ///<
  863 );
  864 
  865 //--------------------------------------------------------------------------------------------------
  866 /**
  867  * Handler for cellular asynchronous network scan Sending result.
  868  *  Returns the reference to the List object. Null pointer if the scan failed.
  869  *
  870  */
  871 //--------------------------------------------------------------------------------------------------
  872 typedef void (*le_mrc_CellularNetworkScanHandlerFunc_t)
  873 (
  874     le_mrc_ScanInformationListRef_t listRef,
  875         ///< Reference to the List object. Null pointer if the
  876         ///< scan failed.
  877     void* contextPtr
  878         ///<
  879 );
  880 
  881 //--------------------------------------------------------------------------------------------------
  882 /**
  883  * Handler for asynchronous manual selection response
  884  *
  885  */
  886 //--------------------------------------------------------------------------------------------------
  887 typedef void (*le_mrc_ManualSelectionHandlerFunc_t)
  888 (
  889     le_result_t result,
  890         ///< Manual selection response
  891     void* contextPtr
  892         ///<
  893 );
  894 
  895 //--------------------------------------------------------------------------------------------------
  896 /**
  897  * Handler to report network reject indication.
  898  *
  899  */
  900 //--------------------------------------------------------------------------------------------------
  901 typedef void (*le_mrc_NetworkRejectHandlerFunc_t)
  902 (
  903     const char* LE_NONNULL mcc,
  904         ///< Mobile Country Code
  905     const char* LE_NONNULL mnc,
  906         ///< Mobile Network Code
  907     le_mrc_Rat_t rat,
  908         ///< Radio Access Technology.
  909     void* contextPtr
  910         ///<
  911 );
  912 
  913 //--------------------------------------------------------------------------------------------------
  914 /**
  915  * Add handler function for EVENT 'le_mrc_NetRegStateEvent'
  916  *
  917  * This event provides information on network registration state changes.
  918  *
  919  * @note <b>multi-app safe</b>
  920  */
  921 //--------------------------------------------------------------------------------------------------
  922 le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler
  923 (
  924     le_mrc_NetRegStateHandlerFunc_t handlerPtr,
  925         ///< [IN]
  926     void* contextPtr
  927         ///< [IN]
  928 );
  929 
  930 //--------------------------------------------------------------------------------------------------
  931 /**
  932  * Remove handler function for EVENT 'le_mrc_NetRegStateEvent'
  933  */
  934 //--------------------------------------------------------------------------------------------------
  935 void le_mrc_RemoveNetRegStateEventHandler
  936 (
  937     le_mrc_NetRegStateEventHandlerRef_t handlerRef
  938         ///< [IN]
  939 );
  940 
  941 //--------------------------------------------------------------------------------------------------
  942 /**
  943  * Add handler function for EVENT 'le_mrc_RatChange'
  944  *
  945  * This event provides information on Radio Access Technology changes.
  946  *
  947  * @note <b>multi-app safe</b>
  948  */
  949 //--------------------------------------------------------------------------------------------------
  950 le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler
  951 (
  952     le_mrc_RatChangeHandlerFunc_t handlerPtr,
  953         ///< [IN]
  954     void* contextPtr
  955         ///< [IN]
  956 );
  957 
  958 //--------------------------------------------------------------------------------------------------
  959 /**
  960  * Remove handler function for EVENT 'le_mrc_RatChange'
  961  */
  962 //--------------------------------------------------------------------------------------------------
  963 void le_mrc_RemoveRatChangeHandler
  964 (
  965     le_mrc_RatChangeHandlerRef_t handlerRef
  966         ///< [IN]
  967 );
  968 
  969 //--------------------------------------------------------------------------------------------------
  970 /**
  971  * Add handler function for EVENT 'le_mrc_PacketSwitchedChange'
  972  *
  973  * This event provides information on Packet Switched service changes.
  974  *
  975  * @note <b>multi-app safe</b>
  976  */
  977 //--------------------------------------------------------------------------------------------------
  978 le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler
  979 (
  980     le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr,
  981         ///< [IN]
  982     void* contextPtr
  983         ///< [IN]
  984 );
  985 
  986 //--------------------------------------------------------------------------------------------------
  987 /**
  988  * Remove handler function for EVENT 'le_mrc_PacketSwitchedChange'
  989  */
  990 //--------------------------------------------------------------------------------------------------
  991 void le_mrc_RemovePacketSwitchedChangeHandler
  992 (
  993     le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef
  994         ///< [IN]
  995 );
  996 
  997 //--------------------------------------------------------------------------------------------------
  998 /**
  999  * Add handler function for EVENT 'le_mrc_SignalStrengthChange'
 1000  *
 1001  * This event provides information on Signal Strength value changes.
 1002  *
 1003  * @note <b>NOT multi-app safe</b>
 1004  */
 1005 //--------------------------------------------------------------------------------------------------
 1006 le_mrc_SignalStrengthChangeHandlerRef_t le_mrc_AddSignalStrengthChangeHandler
 1007 (
 1008     le_mrc_Rat_t rat,
 1009         ///< [IN] Radio Access Technology
 1010     int32_t lowerRangeThreshold,
 1011         ///< [IN] Lower-range Signal strength threshold in dBm
 1012     int32_t upperRangeThreshold,
 1013         ///< [IN] Upper-range Signal strength threshold in dBm
 1014     le_mrc_SignalStrengthChangeHandlerFunc_t handlerPtr,
 1015         ///< [IN]
 1016     void* contextPtr
 1017         ///< [IN]
 1018 );
 1019 
 1020 //--------------------------------------------------------------------------------------------------
 1021 /**
 1022  * Remove handler function for EVENT 'le_mrc_SignalStrengthChange'
 1023  */
 1024 //--------------------------------------------------------------------------------------------------
 1025 void le_mrc_RemoveSignalStrengthChangeHandler
 1026 (
 1027     le_mrc_SignalStrengthChangeHandlerRef_t handlerRef
 1028         ///< [IN]
 1029 );
 1030 
 1031 //--------------------------------------------------------------------------------------------------
 1032 /**
 1033  * This function sets signal strength indication thresholds for a specific RAT.
 1034  *
 1035  * @return
 1036  *  - LE_OK             Function succeeded.
 1037  *  - LE_BAD_PARAMETER  Bad parameters
 1038  *  - LE_FAULT          Function failed.
 1039  *
 1040  * @note <b>NOT multi-app safe</b>
 1041  */
 1042 //--------------------------------------------------------------------------------------------------
 1043 le_result_t le_mrc_SetSignalStrengthIndThresholds
 1044 (
 1045     le_mrc_Rat_t rat,
 1046         ///< [IN] Radio Access Technology
 1047     int32_t lowerRangeThreshold,
 1048         ///< [IN] Lower-range Signal strength threshold in dBm
 1049     int32_t upperRangeThreshold
 1050         ///< [IN] Upper-range Signal strength threshold in dBm
 1051 );
 1052 
 1053 //--------------------------------------------------------------------------------------------------
 1054 /**
 1055  * This function sets a signal strength indication delta for a specific RAT.
 1056  *
 1057  * @return
 1058  *  - LE_OK             Function succeeded.
 1059  *  - LE_BAD_PARAMETER  Bad parameters.
 1060  *  - LE_FAULT          Function failed.
 1061  *
 1062  * @note The signal delta is set in units of 0.1 dBm. For example, to set a delta of 10.6 dBm, the
 1063  *       delta value must be set to 106.
 1064  *
 1065  * @warning The signal delta resolution is platform dependent. Please refer to
 1066  *          @ref platformConstraintsModemRadiocontrol section for full details.
 1067  */
 1068 //--------------------------------------------------------------------------------------------------
 1069 le_result_t le_mrc_SetSignalStrengthIndDelta
 1070 (
 1071     le_mrc_Rat_t rat,
 1072         ///< [IN] Radio Access Technology
 1073     uint16_t delta
 1074         ///< [IN] Signal delta in units of 0.1 dBm
 1075 );
 1076 
 1077 //--------------------------------------------------------------------------------------------------
 1078 /**
 1079  * Enable the automatic Selection Register mode.
 1080  *
 1081  * @return
 1082  *  - LE_FAULT  Function failed.
 1083  *  - LE_OK     Function succeeded.
 1084  *
 1085  * @note <b>NOT multi-app safe</b>
 1086  */
 1087 //--------------------------------------------------------------------------------------------------
 1088 le_result_t le_mrc_SetAutomaticRegisterMode
 1089 (
 1090     void
 1091 );
 1092 
 1093 //--------------------------------------------------------------------------------------------------
 1094 /**
 1095  * Set the manual Selection Register mode with the MCC/MNC parameters.
 1096  *
 1097  * @return
 1098  *  - LE_FAULT  Function failed.
 1099  *  - LE_OK     Function succeeded.
 1100  *
 1101  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1102  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1103  *       won't return.
 1104  *
 1105  * @note <b>NOT multi-app safe</b>
 1106  */
 1107 //--------------------------------------------------------------------------------------------------
 1108 le_result_t le_mrc_SetManualRegisterMode
 1109 (
 1110     const char* LE_NONNULL mcc,
 1111         ///< [IN] Mobile Country Code
 1112     const char* LE_NONNULL mnc
 1113         ///< [IN] Mobile Network Code
 1114 );
 1115 
 1116 //--------------------------------------------------------------------------------------------------
 1117 /**
 1118  * Set the manual selection register mode asynchronously. This function is not blocking,
 1119  *  the response will be returned with a handler function.
 1120  *
 1121  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1122  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1123  *       won't return.
 1124  *
 1125  *@note <b>NOT multi-app safe</b>
 1126  *
 1127  */
 1128 //--------------------------------------------------------------------------------------------------
 1129 void le_mrc_SetManualRegisterModeAsync
 1130 (
 1131     const char* LE_NONNULL mcc,
 1132         ///< [IN] Mobile Country Code
 1133     const char* LE_NONNULL mnc,
 1134         ///< [IN] Mobile Network Code
 1135     le_mrc_ManualSelectionHandlerFunc_t handlerPtr,
 1136         ///< [IN] handler for sending result
 1137     void* contextPtr
 1138         ///< [IN]
 1139 );
 1140 
 1141 //--------------------------------------------------------------------------------------------------
 1142 /**
 1143  * Get the selected Selection Register mode.
 1144  *
 1145  * @return
 1146  *  - LE_FAULT  Function failed.
 1147  *  - LE_OK     Function succeeded.
 1148  *
 1149  * @note <b>multi-app safe</b>
 1150  */
 1151 //--------------------------------------------------------------------------------------------------
 1152 le_result_t le_mrc_GetRegisterMode
 1153 (
 1154     bool* isManualPtrPtr,
 1155         ///< [OUT] true if the scan mode is manual, false if the scan mode is automatic.
 1156     char* mccPtr,
 1157         ///< [OUT] Mobile Country Code
 1158     size_t mccPtrSize,
 1159         ///< [IN]
 1160     char* mncPtr,
 1161         ///< [OUT] Mobile Network Code
 1162     size_t mncPtrSize
 1163         ///< [IN]
 1164 );
 1165 
 1166 //--------------------------------------------------------------------------------------------------
 1167 /**
 1168  * Get the Packet Switched state.
 1169  *
 1170  * @return
 1171  *  - LE_FAULT  Function failed.
 1172  *  - LE_OK     Function succeeded.
 1173  *
 1174  * @note <b>multi-app safe</b>
 1175  */
 1176 //--------------------------------------------------------------------------------------------------
 1177 le_result_t le_mrc_GetPacketSwitchedState
 1178 (
 1179     le_mrc_NetRegState_t* statePtr
 1180         ///< [OUT] The current Packet switched state.
 1181 );
 1182 
 1183 //--------------------------------------------------------------------------------------------------
 1184 /**
 1185  * Get the platform specific network registration error code.
 1186  *
 1187  * Refer to @ref platformConstraintsSpecificErrorCodes for platform specific
 1188  * registration error code description.
 1189  *
 1190  * @return the platform specific registration error code
 1191  *
 1192  */
 1193 //--------------------------------------------------------------------------------------------------
 1194 int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode
 1195 (
 1196     void
 1197 );
 1198 
 1199 //--------------------------------------------------------------------------------------------------
 1200 /**
 1201  * Set the Radio Access Technology preferences by using a bit mask.
 1202  *
 1203  * @return
 1204  *  - LE_FAULT           Function failed.
 1205  *  - LE_OK              Function succeeded.
 1206  *  - LE_UNSUPPORTED     Not supported by platform.
 1207  *
 1208  * @note <b>NOT multi-app safe</b>
 1209  */
 1210 //--------------------------------------------------------------------------------------------------
 1211 le_result_t le_mrc_SetRatPreferences
 1212 (
 1213     le_mrc_RatBitMask_t ratMask
 1214         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1215 );
 1216 
 1217 //--------------------------------------------------------------------------------------------------
 1218 /**
 1219  * Get the Radio Access Technology preferences
 1220  *
 1221  * @return
 1222  * - LE_FAULT  Function failed.
 1223  * - LE_OK     Function succeeded.
 1224  *
 1225  * @note <b>multi-app safe</b>
 1226  */
 1227 //--------------------------------------------------------------------------------------------------
 1228 le_result_t le_mrc_GetRatPreferences
 1229 (
 1230     le_mrc_RatBitMask_t* ratMaskPtrPtr
 1231         ///< [OUT] Bit mask for the Radio Access Technology preferences.
 1232 );
 1233 
 1234 //--------------------------------------------------------------------------------------------------
 1235 /**
 1236  * Set the 2G/3G Band preferences by using a bit mask.
 1237  *
 1238  * @return
 1239  *  - LE_FAULT  Function failed.
 1240  *  - LE_OK     Function succeeded.
 1241  *
 1242  * @note <b>NOT multi-app safe</b>
 1243  */
 1244 //--------------------------------------------------------------------------------------------------
 1245 le_result_t le_mrc_SetBandPreferences
 1246 (
 1247     le_mrc_BandBitMask_t bandMask
 1248         ///< [IN] Bit mask for 2G/3G Band preferences.
 1249 );
 1250 
 1251 //--------------------------------------------------------------------------------------------------
 1252 /**
 1253  * Get the Bit mask for 2G/3G Band preferences.
 1254  *
 1255  * @return
 1256  *  - LE_FAULT  Function failed.
 1257  *  - LE_OK     Function succeeded.
 1258  *
 1259  * @note <b>multi-app safe</b>
 1260  */
 1261 //--------------------------------------------------------------------------------------------------
 1262 le_result_t le_mrc_GetBandPreferences
 1263 (
 1264     le_mrc_BandBitMask_t* bandMaskPtrPtr
 1265         ///< [OUT] Bit mask for 2G/3G Band preferences.
 1266 );
 1267 
 1268 //--------------------------------------------------------------------------------------------------
 1269 /**
 1270  * Set the LTE Band preferences by using a bit mask.
 1271  *
 1272  * @return
 1273  *  - LE_FAULT  Function failed.
 1274  *  - LE_OK     Function succeeded.
 1275  *
 1276  * @note <b>NOT multi-app safe</b>
 1277  */
 1278 //--------------------------------------------------------------------------------------------------
 1279 le_result_t le_mrc_SetLteBandPreferences
 1280 (
 1281     le_mrc_LteBandBitMask_t bandMask
 1282         ///< [IN] Bit mask for LTE Band preferences.
 1283 );
 1284 
 1285 //--------------------------------------------------------------------------------------------------
 1286 /**
 1287  * Get the Bit mask for LTE Band preferences.
 1288  *
 1289  * @return
 1290  *  - LE_FAULT  Function failed.
 1291  *  - LE_OK     Function succeeded.
 1292  *
 1293  * @note <b>multi-app safe</b>
 1294  */
 1295 //--------------------------------------------------------------------------------------------------
 1296 le_result_t le_mrc_GetLteBandPreferences
 1297 (
 1298     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 1299         ///< [OUT] Bit mask for LTE Band preferences.
 1300 );
 1301 
 1302 //--------------------------------------------------------------------------------------------------
 1303 /**
 1304  * Set the TD-SCDMA Band preferences by using a bit mask.
 1305  *
 1306  * @return
 1307  *  - LE_FAULT  Function failed.
 1308  *  - LE_OK     Function succeeded.
 1309  *
 1310  * @note <b>NOT multi-app safe</b>
 1311  */
 1312 //--------------------------------------------------------------------------------------------------
 1313 le_result_t le_mrc_SetTdScdmaBandPreferences
 1314 (
 1315     le_mrc_TdScdmaBandBitMask_t bandMask
 1316         ///< [IN] Bit mask for TD-SCDMA Band preferences.
 1317 );
 1318 
 1319 //--------------------------------------------------------------------------------------------------
 1320 /**
 1321  * Get the Bit mask for TD-SCDMA Band preferences.
 1322  *
 1323  * @return
 1324  *  - LE_FAULT  Function failed.
 1325  *  - LE_OK     Function succeeded.
 1326  *
 1327  * @note <b>multi-app safe</b>
 1328  */
 1329 //--------------------------------------------------------------------------------------------------
 1330 le_result_t le_mrc_GetTdScdmaBandPreferences
 1331 (
 1332     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 1333         ///< [OUT] Bit mask for TD-SCDMA Band preferences.
 1334 );
 1335 
 1336 //--------------------------------------------------------------------------------------------------
 1337 /**
 1338  * Add a preferred operator by specifying the MCC/MNC and the Radio Access Technology.
 1339  *
 1340  * @return
 1341  *  - LE_UNSUPPORTED   List of User Preferred operators not available.
 1342  *  - LE_FAULT         Function failed.
 1343  *  - LE_BAD_PARAMETER RAT mask is invalid.
 1344  *  - LE_OK            Function succeeded.
 1345  *
 1346  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1347  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1348  *       won't return.
 1349  *
 1350  * @note <b>NOT multi-app safe</b>
 1351  */
 1352 //--------------------------------------------------------------------------------------------------
 1353 le_result_t le_mrc_AddPreferredOperator
 1354 (
 1355     const char* LE_NONNULL mcc,
 1356         ///< [IN] Mobile Country Code
 1357     const char* LE_NONNULL mnc,
 1358         ///< [IN] Mobile Network Code
 1359     le_mrc_RatBitMask_t ratMask
 1360         ///< [IN] Bit mask for the Radio Access Technology preferences.
 1361 );
 1362 
 1363 //--------------------------------------------------------------------------------------------------
 1364 /**
 1365  * Remove a preferred operator by specifying the MCC/MNC.
 1366  *
 1367  * @return
 1368  *  - LE_UNSUPPORTED    List of User Preferred operators not available.
 1369  *  - LE_NOT_FOUND      Operator not found in the User Preferred operators list.
 1370  *  - LE_FAULT          Function failed.
 1371  *  - LE_OK             Function succeeded.
 1372  *
 1373  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
 1374  *       short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
 1375  *       won't return.
 1376  *
 1377  * @note <b>NOT multi-app safe</b>
 1378  */
 1379 //--------------------------------------------------------------------------------------------------
 1380 le_result_t le_mrc_RemovePreferredOperator
 1381 (
 1382     const char* LE_NONNULL mcc,
 1383         ///< [IN] Mobile Country Code
 1384     const char* LE_NONNULL mnc
 1385         ///< [IN] Mobile Network Code
 1386 );
 1387 
 1388 //--------------------------------------------------------------------------------------------------
 1389 /**
 1390  * This function must be called to retrieve a list of the preferred operators.
 1391  *
 1392  * @return
 1393  * - Reference to the List object.
 1394  * - Null pointer if there is no preferences list.
 1395  *
 1396  * @note <b>multi-app safe</b>
 1397  */
 1398 //--------------------------------------------------------------------------------------------------
 1399 le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList
 1400 (
 1401     void
 1402 );
 1403 
 1404 //--------------------------------------------------------------------------------------------------
 1405 /**
 1406  * This function must be called to get the first Operator object reference in the list of the
 1407  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1408  *
 1409  * @return
 1410  *  - NULL                          No operator information found.
 1411  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1412  *
 1413  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1414  *       function won't return.
 1415  *
 1416  * @note <b>multi-app safe</b>
 1417  */
 1418 //--------------------------------------------------------------------------------------------------
 1419 le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator
 1420 (
 1421     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1422         ///< [IN] The list of the preferred operators.
 1423 );
 1424 
 1425 //--------------------------------------------------------------------------------------------------
 1426 /**
 1427  * This function must be called to get the next Operator object reference in the list of the
 1428  * preferred operators retrieved with le_mrc_GetPreferredOperators().
 1429  *
 1430  * @return
 1431  *  - NULL                          No operator information found.
 1432  *  - le_mrc_PreferredOperatorRef   The Operator object reference.
 1433  *
 1434  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
 1435  *       function won't return.
 1436  *
 1437  * @note <b>multi-app safe</b>
 1438  */
 1439 //--------------------------------------------------------------------------------------------------
 1440 le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator
 1441 (
 1442     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1443         ///< [IN] The list of the preferred operators.
 1444 );
 1445 
 1446 //--------------------------------------------------------------------------------------------------
 1447 /**
 1448  * This function must be called to delete the list of the preferred operators retrieved with
 1449  * le_mrc_GetPreferredOperators().
 1450  *
 1451  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1452  *       reference for validity.
 1453  *
 1454  * @note <b>multi-app safe</b>
 1455  */
 1456 //--------------------------------------------------------------------------------------------------
 1457 void le_mrc_DeletePreferredOperatorsList
 1458 (
 1459     le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
 1460         ///< [IN] The list of the preferred operators.
 1461 );
 1462 
 1463 //--------------------------------------------------------------------------------------------------
 1464 /**
 1465  * This function must be called to get the Operator information details.
 1466  *
 1467  * @return
 1468  *      - LE_OK on success
 1469  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 1470  *      - LE_FAULT for all other errors
 1471  *
 1472  * @note <b>multi-app safe</b>
 1473  */
 1474 //--------------------------------------------------------------------------------------------------
 1475 le_result_t le_mrc_GetPreferredOperatorDetails
 1476 (
 1477     le_mrc_PreferredOperatorRef_t preferredOperatorRef,
 1478         ///< [IN] Operator object reference.
 1479     char* mccPtr,
 1480         ///< [OUT] Mobile Country Code.
 1481     size_t mccPtrSize,
 1482         ///< [IN]
 1483     char* mncPtr,
 1484         ///< [OUT] Mobile Network Code.
 1485     size_t mncPtrSize,
 1486         ///< [IN]
 1487     le_mrc_RatBitMask_t* ratMaskPtr
 1488         ///< [OUT] Bit mask for the RAT preferences.
 1489 );
 1490 
 1491 //--------------------------------------------------------------------------------------------------
 1492 /**
 1493  * Get the network registration state.
 1494  *
 1495  * @return LE_FAULT         The function failed to get the Network registration state.
 1496  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1497  * @return LE_OK            The function succeeded.
 1498  *
 1499  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1500  *       function won't return.
 1501  *
 1502  * @note <b>multi-app safe</b>
 1503  */
 1504 //--------------------------------------------------------------------------------------------------
 1505 le_result_t le_mrc_GetNetRegState
 1506 (
 1507     le_mrc_NetRegState_t* statePtr
 1508         ///< [OUT] Network Registration state.
 1509 );
 1510 
 1511 //--------------------------------------------------------------------------------------------------
 1512 /**
 1513  * Get the signal quality.
 1514  *
 1515  * @return LE_FAULT         The function failed to get the Signal Quality information.
 1516  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1517  * @return LE_OK            The function succeeded.
 1518  *
 1519  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1520  *       function won't return.
 1521  *
 1522  * @note <b>multi-app safe</b>
 1523  */
 1524 //--------------------------------------------------------------------------------------------------
 1525 le_result_t le_mrc_GetSignalQual
 1526 (
 1527     uint32_t* qualityPtr
 1528         ///< [OUT] [OUT] Received signal strength quality (0 = no signal strength,
 1529         ///<        5 = very good signal strength).
 1530 );
 1531 
 1532 //--------------------------------------------------------------------------------------------------
 1533 /**
 1534  * Set the power of the Radio Module.
 1535  *
 1536  * @return LE_BAD_PARAMETER Bad power mode specified.
 1537  * @return LE_FAULT         Function failed.
 1538  * @return LE_OK            Function succeed.
 1539  *
 1540  * @note <b>NOT multi-app safe</b>
 1541  */
 1542 //--------------------------------------------------------------------------------------------------
 1543 le_result_t le_mrc_SetRadioPower
 1544 (
 1545     le_onoff_t power
 1546         ///< [IN] The power state.
 1547 );
 1548 
 1549 //--------------------------------------------------------------------------------------------------
 1550 /**
 1551  * Must be called to get the Radio Module power state.
 1552  *
 1553  * @return LE_FAULT         The function failed to get the Radio Module power state.
 1554  * @return LE_BAD_PARAMETER if powerPtr is NULL.
 1555  * @return LE_OK            The function succeed.
 1556  *
 1557  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1558  *       function won't return.
 1559  *
 1560  * @note <b>multi-app safe</b>
 1561  */
 1562 //--------------------------------------------------------------------------------------------------
 1563 le_result_t le_mrc_GetRadioPower
 1564 (
 1565     le_onoff_t* powerPtr
 1566         ///< [OUT] Power state.
 1567 );
 1568 
 1569 //--------------------------------------------------------------------------------------------------
 1570 /**
 1571  * This function must be called to perform a cellular network scan.
 1572  *
 1573  * @return Reference to the List object. Null pointer if the scan failed.
 1574  *
 1575  * @note <b>multi-app safe</b>
 1576  */
 1577 //--------------------------------------------------------------------------------------------------
 1578 le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan
 1579 (
 1580     le_mrc_RatBitMask_t ratMask
 1581         ///< [IN] Radio Access Technology mask
 1582 );
 1583 
 1584 //--------------------------------------------------------------------------------------------------
 1585 /**
 1586  * This function must be called to perform a cellular network scan asynchronously. This function
 1587  * is not blocking, the response will be returned with a handler function.
 1588  *
 1589  *@note <b>multi-app safe</b>
 1590  *
 1591  */
 1592 //--------------------------------------------------------------------------------------------------
 1593 void le_mrc_PerformCellularNetworkScanAsync
 1594 (
 1595     le_mrc_RatBitMask_t ratMask,
 1596         ///< [IN] Radio Access Technology mask
 1597     le_mrc_CellularNetworkScanHandlerFunc_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 delete the list of the Scan Information retrieved with
 1646  * le_mrc_PerformCellularNetworkScan().
 1647  *
 1648  * @note
 1649  *      On failure, the process exits, so you don't have to worry about checking the returned
 1650  *      reference for validity.
 1651  *
 1652  * @note <b>multi-app safe</b>
 1653  */
 1654 //--------------------------------------------------------------------------------------------------
 1655 void le_mrc_DeleteCellularNetworkScan
 1656 (
 1657     le_mrc_ScanInformationListRef_t scanInformationListRef
 1658         ///< [IN] The list of scan information.
 1659 );
 1660 
 1661 //--------------------------------------------------------------------------------------------------
 1662 /**
 1663  * This function must be called to get the Cellular Network Code [mcc:mnc]
 1664  *
 1665  * @return
 1666  *      - LE_OK on success
 1667  *      - LE_OVERFLOW if the MCC or MNC would not fit in buffer
 1668  *      - LE_FAULT for all other errors
 1669  *
 1670  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1671  *       reference for validity.
 1672  *
 1673  * @note <b>multi-app safe</b>
 1674  */
 1675 //--------------------------------------------------------------------------------------------------
 1676 le_result_t le_mrc_GetCellularNetworkMccMnc
 1677 (
 1678     le_mrc_ScanInformationRef_t scanInformationRef,
 1679         ///< [IN] Scan information reference
 1680     char* mccPtr,
 1681         ///< [OUT] Mobile Country Code
 1682     size_t mccPtrSize,
 1683         ///< [IN]
 1684     char* mncPtr,
 1685         ///< [OUT] Mobile Network Code
 1686     size_t mncPtrSize
 1687         ///< [IN]
 1688 );
 1689 
 1690 //--------------------------------------------------------------------------------------------------
 1691 /**
 1692  * This function must be called to get the Cellular Network Name.
 1693  *
 1694  * @return
 1695  *      - LE_OK on success
 1696  *      - LE_OVERFLOW if the operator name would not fit in buffer
 1697  *      - LE_FAULT for all other errors
 1698  *
 1699  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1700  *       reference for validity.
 1701  *
 1702  * @note <b>multi-app safe</b>
 1703  */
 1704 //--------------------------------------------------------------------------------------------------
 1705 le_result_t le_mrc_GetCellularNetworkName
 1706 (
 1707     le_mrc_ScanInformationRef_t scanInformationRef,
 1708         ///< [IN] Scan information reference
 1709     char* namePtr,
 1710         ///< [OUT] Name of operator
 1711     size_t namePtrSize
 1712         ///< [IN]
 1713 );
 1714 
 1715 //--------------------------------------------------------------------------------------------------
 1716 /**
 1717  * This function must be called to get the radio access technology of a scanInformationRef.
 1718  *
 1719  * @return the radio access technology
 1720  *
 1721  * @note On failure, the process exits.
 1722  *
 1723  * @note <b>multi-app safe</b>
 1724  */
 1725 //--------------------------------------------------------------------------------------------------
 1726 le_mrc_Rat_t le_mrc_GetCellularNetworkRat
 1727 (
 1728     le_mrc_ScanInformationRef_t scanInformationRef
 1729         ///< [IN] Scan information reference
 1730 );
 1731 
 1732 //--------------------------------------------------------------------------------------------------
 1733 /**
 1734  * This function must be called to check if a cellular network is currently in use.
 1735  *
 1736  * @return true     The network is in use
 1737  * @return false    The network isn't in use
 1738  *
 1739  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1740  *       reference for validity.
 1741  *
 1742  * @note <b>multi-app safe</b>
 1743  */
 1744 //--------------------------------------------------------------------------------------------------
 1745 bool le_mrc_IsCellularNetworkInUse
 1746 (
 1747     le_mrc_ScanInformationRef_t scanInformationRef
 1748         ///< [IN] Scan information reference
 1749 );
 1750 
 1751 //--------------------------------------------------------------------------------------------------
 1752 /**
 1753  * This function must be called to check if a cellular network is available.
 1754  *
 1755  * @return true     The network is available
 1756  * @return false    The network isn't available
 1757  *
 1758  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1759  *       reference for validity.
 1760  *
 1761  * @note <b>multi-app safe</b>
 1762  */
 1763 //--------------------------------------------------------------------------------------------------
 1764 bool le_mrc_IsCellularNetworkAvailable
 1765 (
 1766     le_mrc_ScanInformationRef_t scanInformationRef
 1767         ///< [IN] Scan information reference
 1768 );
 1769 
 1770 //--------------------------------------------------------------------------------------------------
 1771 /**
 1772  * This function must be called to check if a cellular network is currently in home mode.
 1773  *
 1774  * @return true     The network is home
 1775  * @return false    The network is roaming
 1776  *
 1777  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1778  *       reference for validity.
 1779  *
 1780  * @note <b>multi-app safe</b>
 1781  */
 1782 //--------------------------------------------------------------------------------------------------
 1783 bool le_mrc_IsCellularNetworkHome
 1784 (
 1785     le_mrc_ScanInformationRef_t scanInformationRef
 1786         ///< [IN] Scan information reference
 1787 );
 1788 
 1789 //--------------------------------------------------------------------------------------------------
 1790 /**
 1791  * This function must be called to check if a cellular network is forbidden by the operator.
 1792  *
 1793  * @return true     The network is forbidden
 1794  * @return false    The network is allowed
 1795  *
 1796  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1797  *       reference for validity.
 1798  *
 1799  * @note <b>multi-app safe</b>
 1800  */
 1801 //--------------------------------------------------------------------------------------------------
 1802 bool le_mrc_IsCellularNetworkForbidden
 1803 (
 1804     le_mrc_ScanInformationRef_t scanInformationRef
 1805         ///< [IN] Scan information reference
 1806 );
 1807 
 1808 //--------------------------------------------------------------------------------------------------
 1809 /**
 1810  * This function must be called to get the current network name information.
 1811  *
 1812  * @return
 1813  *      - LE_OK             on success
 1814  *      - LE_BAD_PARAMETER  if nameStr is NULL
 1815  *      - LE_OVERFLOW       if the Home Network Name can't fit in nameStr
 1816  *      - LE_FAULT          on any other failure
 1817  *
 1818  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1819  *       function won't return.
 1820  *
 1821  * @note <b>multi-app safe</b>
 1822  */
 1823 //--------------------------------------------------------------------------------------------------
 1824 le_result_t le_mrc_GetCurrentNetworkName
 1825 (
 1826     char* nameStr,
 1827         ///< [OUT] the home network Name
 1828     size_t nameStrSize
 1829         ///< [IN]
 1830 );
 1831 
 1832 //--------------------------------------------------------------------------------------------------
 1833 /**
 1834  * This function must be called to get the current network PLMN information.
 1835  *
 1836  * @return
 1837  *      - LE_OK       on success
 1838  *      - LE_FAULT    on any other failure
 1839  *
 1840  * @note <b>multi-app safe</b>
 1841  */
 1842 //--------------------------------------------------------------------------------------------------
 1843 le_result_t le_mrc_GetCurrentNetworkMccMnc
 1844 (
 1845     char* mccStr,
 1846         ///< [OUT] the mobile country code
 1847     size_t mccStrSize,
 1848         ///< [IN]
 1849     char* mncStr,
 1850         ///< [OUT] the mobile network code
 1851     size_t mncStrSize
 1852         ///< [IN]
 1853 );
 1854 
 1855 //--------------------------------------------------------------------------------------------------
 1856 /**
 1857  * This function must be called to get the current Radio Access Technology in use.
 1858  *
 1859  * @return LE_FAULT         Function failed to get the Radio Access Technology.
 1860  * @return LE_BAD_PARAMETER A bad parameter was passed.
 1861  * @return LE_OK            Function succeeded.
 1862  *
 1863  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1864  *       function won't return.
 1865  *
 1866  * @note <b>multi-app safe</b>
 1867  */
 1868 //--------------------------------------------------------------------------------------------------
 1869 le_result_t le_mrc_GetRadioAccessTechInUse
 1870 (
 1871     le_mrc_Rat_t* ratPtr
 1872         ///< [OUT] The Radio Access Technology.
 1873 );
 1874 
 1875 //--------------------------------------------------------------------------------------------------
 1876 /**
 1877  * This function must be called to retrieve the Neighboring Cells information. It creates and
 1878  * returns a reference to the Neighboring Cells information.
 1879  *
 1880  * @return A reference to the Neighboring Cells information.
 1881  * @return NULL if no Cells Information are available.
 1882  *
 1883  * @note <b>multi-app safe</b>
 1884  */
 1885 //--------------------------------------------------------------------------------------------------
 1886 le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo
 1887 (
 1888     void
 1889 );
 1890 
 1891 //--------------------------------------------------------------------------------------------------
 1892 /**
 1893  * This function must be called to delete the Neighboring Cells information.
 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 void le_mrc_DeleteNeighborCellsInfo
 1902 (
 1903     le_mrc_NeighborCellsRef_t ngbrCellsRef
 1904         ///< [IN] Neighboring Cells reference.
 1905 );
 1906 
 1907 //--------------------------------------------------------------------------------------------------
 1908 /**
 1909  * This function must be called to get the first Cell Information reference in the list of
 1910  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 1911  *
 1912  * @return NULL                   No Cell information object found.
 1913  * @return le_mrc_CellInfoRef_t   The Cell information object reference.
 1914  *
 1915  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1916  *       function won't return.
 1917  *
 1918  * @note <b>multi-app safe</b>
 1919  */
 1920 //--------------------------------------------------------------------------------------------------
 1921 le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo
 1922 (
 1923     le_mrc_NeighborCellsRef_t ngbrCellsRef
 1924         ///< [IN] Neighboring Cells reference.
 1925 );
 1926 
 1927 //--------------------------------------------------------------------------------------------------
 1928 /**
 1929  * This function must be called to get the next Cell Information reference in the list of
 1930  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
 1931  *
 1932  * @return NULL                   No Cell information object found.
 1933  * @return le_mrc_CellInfoRef_t   Cell information object reference.
 1934  *
 1935  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1936  *       function won't return.
 1937  *
 1938  * @note <b>multi-app safe</b>
 1939  */
 1940 //--------------------------------------------------------------------------------------------------
 1941 le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo
 1942 (
 1943     le_mrc_NeighborCellsRef_t ngbrCellsRef
 1944         ///< [IN] Neighboring Cells reference.
 1945 );
 1946 
 1947 //--------------------------------------------------------------------------------------------------
 1948 /**
 1949  * This function must be called to get the Cell Identifier.
 1950  *
 1951  * @return The Cell Identifier.
 1952  *
 1953  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1954  *       function won't return.
 1955  *
 1956  * @note <b>multi-app safe</b>
 1957  */
 1958 //--------------------------------------------------------------------------------------------------
 1959 uint32_t le_mrc_GetNeighborCellId
 1960 (
 1961     le_mrc_CellInfoRef_t ngbrCellInfoRef
 1962         ///< [IN] Cell information reference.
 1963 );
 1964 
 1965 //--------------------------------------------------------------------------------------------------
 1966 /**
 1967  * This function must be called to get the Location Area Code of a cell.
 1968  *
 1969  * @return The Location Area Code of a cell. UINT16_MAX value is returned if the value is not
 1970  * available.
 1971  *
 1972  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1973  *       function won't return.
 1974  *
 1975  * @note <b>multi-app safe</b>
 1976  */
 1977 //--------------------------------------------------------------------------------------------------
 1978 uint32_t le_mrc_GetNeighborCellLocAreaCode
 1979 (
 1980     le_mrc_CellInfoRef_t ngbrCellInfoRef
 1981         ///< [IN] Cell information reference.
 1982 );
 1983 
 1984 //--------------------------------------------------------------------------------------------------
 1985 /**
 1986  * This function must be called to get the signal strength of a cell.
 1987  *
 1988  * @return The signal strength of a cell in dBm.
 1989  *
 1990  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 1991  *       function won't return.
 1992  *
 1993  * @note <b>multi-app safe</b>
 1994  */
 1995 //--------------------------------------------------------------------------------------------------
 1996 int32_t le_mrc_GetNeighborCellRxLevel
 1997 (
 1998     le_mrc_CellInfoRef_t ngbrCellInfoRef
 1999         ///< [IN] Cell information reference.
 2000 );
 2001 
 2002 //--------------------------------------------------------------------------------------------------
 2003 /**
 2004  * This function must be called to get the Radio Access Technology of a cell.
 2005  *
 2006  * @return The Radio Access Technology of a cell.
 2007  *
 2008  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2009  *       function won't return.
 2010  *
 2011  * @note <b>multi-app safe</b>
 2012  */
 2013 //--------------------------------------------------------------------------------------------------
 2014 le_mrc_Rat_t le_mrc_GetNeighborCellRat
 2015 (
 2016     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2017         ///< [IN] Cell information reference.
 2018 );
 2019 
 2020 //--------------------------------------------------------------------------------------------------
 2021 /**
 2022  * This function must be called to get the Ec/Io; the received energy per chip divided by the power
 2023  * density in the band measured in dBm on the primary CPICH channel of serving cell (negative value)
 2024  *
 2025  * @return
 2026  *  - The Ec/Io of a cell given in dB with 1 decimal place. (only applicable for UMTS network).
 2027  *  - INT32_MAX when the value isn't available.
 2028  *
 2029  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2030  *       function won't return.
 2031  *
 2032  * @note <b>multi-app safe</b>
 2033  */
 2034 //--------------------------------------------------------------------------------------------------
 2035 int32_t le_mrc_GetNeighborCellUmtsEcIo
 2036 (
 2037     le_mrc_CellInfoRef_t ngbrCellInfoRef
 2038         ///< [IN] Cell information reference.
 2039 );
 2040 
 2041 //--------------------------------------------------------------------------------------------------
 2042 /**
 2043  * This function must be called to get the RSRP and RSRQ of the Intrafrequency of a LTE cell.
 2044  *
 2045  * @return
 2046  *      - LE_OK on success
 2047  *      - LE_FAULT on failure
 2048  *
 2049  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2050  *       function won't return.
 2051  *
 2052  * @note <b>multi-app safe</b>
 2053  */
 2054 //--------------------------------------------------------------------------------------------------
 2055 le_result_t le_mrc_GetNeighborCellLteIntraFreq
 2056 (
 2057     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2058         ///< [IN] Cell information reference.
 2059     int32_t* rsrqPtr,
 2060         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2061         ///< place
 2062     int32_t* rsrpPtr
 2063         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2064         ///< place
 2065 );
 2066 
 2067 //--------------------------------------------------------------------------------------------------
 2068 /**
 2069  * This function must be called to get the RSRP and RSRQ of the Interfrequency of a LTE cell.
 2070  *
 2071  * @return
 2072  *      - LE_OK on success
 2073  *      - LE_FAULT on failure
 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_result_t le_mrc_GetNeighborCellLteInterFreq
 2082 (
 2083     le_mrc_CellInfoRef_t ngbrCellInfoRef,
 2084         ///< [IN] Cell information reference.
 2085     int32_t* rsrqPtr,
 2086         ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
 2087         ///< place
 2088     int32_t* rsrpPtr
 2089         ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
 2090         ///< place
 2091 );
 2092 
 2093 //--------------------------------------------------------------------------------------------------
 2094 /**
 2095  * This function must be called to measure the signal metrics. It creates and returns a reference
 2096  * to the signal metrics.
 2097  *
 2098  * @return A reference to the signal metrics.
 2099  * @return NULL if no signal metrics are available.
 2100  *
 2101  * @note <b>multi-app safe</b>
 2102  */
 2103 //--------------------------------------------------------------------------------------------------
 2104 le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics
 2105 (
 2106     void
 2107 );
 2108 
 2109 //--------------------------------------------------------------------------------------------------
 2110 /**
 2111  * This function must be called to delete the the signal metrics.
 2112  *
 2113  * @note On failure, the process exits, so you don't have to worry about checking the returned
 2114  *       reference for validity.
 2115  *
 2116  * @note <b>multi-app safe</b>
 2117  */
 2118 //--------------------------------------------------------------------------------------------------
 2119 void le_mrc_DeleteSignalMetrics
 2120 (
 2121     le_mrc_MetricsRef_t MetricsRef
 2122         ///< [IN] Signal metrics reference.
 2123 );
 2124 
 2125 //--------------------------------------------------------------------------------------------------
 2126 /**
 2127  * This function returns the Radio Access Technology of the signal metrics.
 2128  *
 2129  * @return The Radio Access Technology of the signal measure.
 2130  *
 2131  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2132  *       function won't return.
 2133  *
 2134  * @note <b>multi-app safe</b>
 2135  */
 2136 //--------------------------------------------------------------------------------------------------
 2137 le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics
 2138 (
 2139     le_mrc_MetricsRef_t MetricsRef
 2140         ///< [IN] Signal metrics reference.
 2141 );
 2142 
 2143 //--------------------------------------------------------------------------------------------------
 2144 /**
 2145  * This function returns the signal strength in dBm and the bit error rate measured on GSM network.
 2146  *
 2147  * @return
 2148  *      - LE_OK on success
 2149  *      - LE_FAULT on failure
 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 le_result_t le_mrc_GetGsmSignalMetrics
 2158 (
 2159     le_mrc_MetricsRef_t MetricsRef,
 2160         ///< [IN] Signal metrics reference.
 2161     int32_t* rssiPtr,
 2162         ///< [OUT] Signal strength in dBm
 2163     uint32_t* berPtr
 2164         ///< [OUT] Bit error rate.
 2165 );
 2166 
 2167 //--------------------------------------------------------------------------------------------------
 2168 /**
 2169  * This function returns the signal metrics measured on UMTS or TD-SCDMA networks.
 2170  *
 2171  * @return
 2172  *      - LE_OK on success
 2173  *      - LE_FAULT on failure
 2174  *
 2175  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2176  *       function won't return.
 2177  *
 2178  * @note <b>multi-app safe</b>
 2179  */
 2180 //--------------------------------------------------------------------------------------------------
 2181 le_result_t le_mrc_GetUmtsSignalMetrics
 2182 (
 2183     le_mrc_MetricsRef_t MetricsRef,
 2184         ///< [IN] Signal metrics reference.
 2185     int32_t* ssPtr,
 2186         ///< [OUT] Signal strength in dBm
 2187     uint32_t* blerPtr,
 2188         ///< [OUT] Block error rate
 2189     int32_t* ecioPtr,
 2190         ///< [OUT] Ec/Io value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2191         ///< value)
 2192     int32_t* rscpPtr,
 2193         ///< [OUT] Measured RSCP in dBm (negative value, value INT32_MAX means
 2194         ///< that RSCP is not available)
 2195     int32_t* sinrPtr
 2196         ///< [OUT] Measured SINR in dB (only applicable for TD-SCDMA network, value
 2197         ///< INT32_MAX means that the SINR is not available)
 2198 );
 2199 
 2200 //--------------------------------------------------------------------------------------------------
 2201 /**
 2202  * This function returns the signal metrics measured on LTE network.
 2203  *
 2204  * @return
 2205  *      - LE_OK on success
 2206  *      - LE_FAULT on failure
 2207  *      - sinrPtr and ioPtr return INT32_MAX when the value isn't available.
 2208  *
 2209  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2210  *       function won't return.
 2211  *
 2212  * @note <b>multi-app safe</b>
 2213  */
 2214 //--------------------------------------------------------------------------------------------------
 2215 le_result_t le_mrc_GetLteSignalMetrics
 2216 (
 2217     le_mrc_MetricsRef_t MetricsRef,
 2218         ///< [IN] Signal metrics reference.
 2219     int32_t* ssPtr,
 2220         ///< [OUT] Signal strength in dBm
 2221     uint32_t* blerPtr,
 2222         ///< [OUT] Block error rate
 2223     int32_t* rsrqPtr,
 2224         ///< [OUT] RSRQ value in dB as measured by L1 with 1 decimal place
 2225     int32_t* rsrpPtr,
 2226         ///< [OUT] Current RSRP in dBm as measured by L1 with 1 decimal place
 2227     int32_t* snrPtr
 2228         ///< [OUT] SNR level in dB with 1 decimal place (15 = 1.5 dB)
 2229 );
 2230 
 2231 //--------------------------------------------------------------------------------------------------
 2232 /**
 2233  * This function returns the signal metrics measured on CDMA network.
 2234  *
 2235  * @return
 2236  *      - LE_OK on success
 2237  *      - LE_FAULT on failure
 2238  *      - rscpPtr and sinrPtr return INT32_MAX when the value isn't available.
 2239  *
 2240  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
 2241  *       function won't return.
 2242  *
 2243  * @note <b>multi-app safe</b>
 2244  */
 2245 //--------------------------------------------------------------------------------------------------
 2246 le_result_t le_mrc_GetCdmaSignalMetrics
 2247 (
 2248     le_mrc_MetricsRef_t MetricsRef,
 2249         ///< [IN] Signal metrics reference.
 2250     int32_t* ssPtr,
 2251         ///< [OUT] Signal strength in dBm
 2252     uint32_t* erPtr,
 2253         ///< [OUT] Frame/Packet error rate
 2254     int32_t* ecioPtr,
 2255         ///< [OUT] ECIO value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
 2256         ///< value)
 2257     int32_t* sinrPtr,
 2258         ///< [OUT] SINR level in dB with 1 decimal place, (only applicable for
 2259         ///< 1xEV-DO, value INT32_MAX means that the value is not available)
 2260     int32_t* ioPtr
 2261         ///< [OUT] Received IO in dBm (only applicable for 1xEV-DO, value INT32_MAX
 2262         ///< means that the value is not available)
 2263 );
 2264 
 2265 //--------------------------------------------------------------------------------------------------
 2266 /**
 2267  * This function must be called to get the serving Cell Identifier.
 2268  *
 2269  * @return The Cell Identifier. UINT32_MAX value is returned if the value is not available.
 2270  *
 2271  * @note When the module is in UMTS network, the API returns the serving UTRAN Cell Identity (UC-Id)
 2272  * which is used to identify the cell uniquely.
 2273  * It is composed of the Controlling Radio Network Controller Identifier (CRNC-Id, 12 bits) and the
 2274  * Cell Identifier (C-Id, 16 bits). (3GPP 25.401, section 6.1.5)
 2275  * The Cell Identifier is coded in the lower 2 bytes of the 4 bytes UC-Id and the CRNC-Id is coded
 2276  * in the upper 2 bytes.
 2277  * Example: the API returns 7807609 -> 0x772279 (CRNC-Id = 0x77 , cell ID = 0x2279)
 2278  *
 2279  * @note <b>multi-app safe</b>
 2280  */
 2281 //--------------------------------------------------------------------------------------------------
 2282 uint32_t le_mrc_GetServingCellId
 2283 (
 2284     void
 2285 );
 2286 
 2287 //--------------------------------------------------------------------------------------------------
 2288 /**
 2289  * This function must be called to get the Location Area Code of the serving cell.
 2290  *
 2291  * @return The Location Area Code. UINT32_MAX value is returned if the value is not available.
 2292  *
 2293  * @note <b>multi-app safe</b>
 2294  */
 2295 //--------------------------------------------------------------------------------------------------
 2296 uint32_t le_mrc_GetServingCellLocAreaCode
 2297 (
 2298     void
 2299 );
 2300 
 2301 //--------------------------------------------------------------------------------------------------
 2302 /**
 2303  * This function must be called to get the Tracking Area Code of the serving cell (LTE only).
 2304  *
 2305  * @return The Tracking Area Code. UINT16_MAX value is returned if the value is not available.
 2306  *
 2307  * @note <b>multi-app safe</b>
 2308  */
 2309 //--------------------------------------------------------------------------------------------------
 2310 uint16_t le_mrc_GetServingCellLteTracAreaCode
 2311 (
 2312     void
 2313 );
 2314 
 2315 //--------------------------------------------------------------------------------------------------
 2316 /**
 2317  * Get the Bit mask for 2G/3G Band capabilities.
 2318  *
 2319  * @return
 2320  *  - LE_OK              on success
 2321  *  - LE_FAULT           on failure
 2322  *  - LE_UNSUPPORTED     The platform does not support this operation.
 2323  *
 2324  * @note <b>multi-app safe</b>
 2325  */
 2326 //--------------------------------------------------------------------------------------------------
 2327 le_result_t le_mrc_GetBandCapabilities
 2328 (
 2329     le_mrc_BandBitMask_t* bandMaskPtrPtr
 2330         ///< [OUT] Bit mask for 2G/3G Band capabilities.
 2331 );
 2332 
 2333 //--------------------------------------------------------------------------------------------------
 2334 /**
 2335  * Get the Bit mask for LTE Band capabilities.
 2336  *
 2337  * @return
 2338  *  - LE_OK              on success
 2339  *  - LE_FAULT           on failure
 2340  *  - LE_UNSUPPORTED     The platform does not support this operation.
 2341  *
 2342  * @note <b>multi-app safe</b>
 2343  */
 2344 //--------------------------------------------------------------------------------------------------
 2345 le_result_t le_mrc_GetLteBandCapabilities
 2346 (
 2347     le_mrc_LteBandBitMask_t* bandMaskPtrPtr
 2348         ///< [OUT] Bit mask for LTE Band capabilities.
 2349 );
 2350 
 2351 //--------------------------------------------------------------------------------------------------
 2352 /**
 2353  * Get the Bit mask for TD-SCDMA Band capabilities.
 2354  *
 2355  * @return
 2356  *  - LE_OK              on success
 2357  *  - LE_FAULT           on failure
 2358  *  - LE_UNSUPPORTED     The platform does not support this operation.
 2359  *
 2360  * @note <b>multi-app safe</b>
 2361  */
 2362 //--------------------------------------------------------------------------------------------------
 2363 le_result_t le_mrc_GetTdScdmaBandCapabilities
 2364 (
 2365     le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
 2366         ///< [OUT] Bit mask for TD-SCDMA Band capabilities.
 2367 );
 2368 
 2369 //--------------------------------------------------------------------------------------------------
 2370 /**
 2371  * Add handler function for EVENT 'le_mrc_NetworkReject'
 2372  *
 2373  * Event to report network reject indication.
 2374  *
 2375  */
 2376 //--------------------------------------------------------------------------------------------------
 2377 le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler
 2378 (
 2379     le_mrc_NetworkRejectHandlerFunc_t handlerPtr,
 2380         ///< [IN]
 2381     void* contextPtr
 2382         ///< [IN]
 2383 );
 2384 
 2385 //--------------------------------------------------------------------------------------------------
 2386 /**
 2387  * Remove handler function for EVENT 'le_mrc_NetworkReject'
 2388  */
 2389 //--------------------------------------------------------------------------------------------------
 2390 void le_mrc_RemoveNetworkRejectHandler
 2391 (
 2392     le_mrc_NetworkRejectHandlerRef_t handlerRef
 2393         ///< [IN]
 2394 );
 2395 
 2396 #endif // LE_MRC_INTERFACE_H_INCLUDE_GUARD
le_mrc_GetLteBandCapabilities
le_result_t le_mrc_GetLteBandCapabilities(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
le_mrc_GetNeighborCellId
uint32_t le_mrc_GetNeighborCellId(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_GetPreferredOperatorDetails
le_result_t le_mrc_GetPreferredOperatorDetails(le_mrc_PreferredOperatorRef_t preferredOperatorRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize, le_mrc_RatBitMask_t *ratMaskPtr)
LE_MRC_RAT_TDSCDMA
TD-SCDMA networks. 
Definition: le_mrc_interface.h:741
LE_MRC_BITMASK_RAT_LTE
LTE RAT Bit Mask. 
Definition: le_mrc_interface.h:761
le_mrc_GetGsmSignalMetrics
le_result_t le_mrc_GetGsmSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *rssiPtr, uint32_t *berPtr)
LE_MRC_BITMASK_RAT_CDMA
CDMA RAT Bit Mask. 
Definition: le_mrc_interface.h:762
le_mrc_GetSignalQual
le_result_t le_mrc_GetSignalQual(uint32_t *qualityPtr)
le_mrc_GetServingCellLteTracAreaCode
uint16_t le_mrc_GetServingCellLteTracAreaCode(void)
le_mrc_DeleteNeighborCellsInfo
void le_mrc_DeleteNeighborCellsInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_GetNextNeighborCellInfo
le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_RemovePacketSwitchedChangeHandler
void le_mrc_RemovePacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef)
le_mrc_GetNetRegState
le_result_t le_mrc_GetNetRegState(le_mrc_NetRegState_t *statePtr)
le_mrc_AddRatChangeHandler
le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler(le_mrc_RatChangeHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_SetAutomaticRegisterMode
le_result_t le_mrc_SetAutomaticRegisterMode(void)
le_mrc_PreferredOperatorListRef_t
struct le_mrc_PreferredOperatorList * le_mrc_PreferredOperatorListRef_t
Definition: le_mrc_interface.h:678
le_mrc_SetSignalStrengthIndThresholds
le_result_t le_mrc_SetSignalStrengthIndThresholds(le_mrc_Rat_t rat, int32_t lowerRangeThreshold, int32_t upperRangeThreshold)
le_mrc_PreferredOperatorRef_t
struct le_mrc_PreferredOperator * le_mrc_PreferredOperatorRef_t
Definition: le_mrc_interface.h:670
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:423
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_GetCurrentNetworkMccMnc
le_result_t le_mrc_GetCurrentNetworkMccMnc(char *mccStr, size_t mccStrSize, char *mncStr, size_t mncStrSize)
le_mrc_NeighborCellsRef_t
struct le_mrc_NeighborCells * le_mrc_NeighborCellsRef_t
Definition: le_mrc_interface.h:694
le_mrc_SetTdScdmaBandPreferences
le_result_t le_mrc_SetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t bandMask)
le_mrc_MetricsRef_t
struct le_mrc_Metrics * le_mrc_MetricsRef_t
Definition: le_mrc_interface.h:702
le_mrc_GetPacketSwitchedState
le_result_t le_mrc_GetPacketSwitchedState(le_mrc_NetRegState_t *statePtr)
LE_MRC_RAT_UMTS
UMTS networks. 
Definition: le_mrc_interface.h:739
LE_MRC_BITMASK_RAT_TDSCDMA
TD-SCDMA RAT Bit Mask. 
Definition: le_mrc_interface.h:760
le_mrc_GetRatOfSignalMetrics
le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_mrc_NetRegStateEventHandlerRef_t
struct le_mrc_NetRegStateEventHandler * le_mrc_NetRegStateEventHandlerRef_t
Definition: le_mrc_interface.h:774
le_mrc_GetTdScdmaBandPreferences
le_result_t le_mrc_GetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
le_mrc_DeleteSignalMetrics
void le_mrc_DeleteSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_mrc_RatChangeHandlerRef_t
struct le_mrc_RatChangeHandler * le_mrc_RatChangeHandlerRef_t
Definition: le_mrc_interface.h:782
le_mrc_GetFirstNeighborCellInfo
le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
LE_MRC_REG_ROAMING
Registered to a roaming network. 
Definition: le_mrc_interface.h:720
le_mrc_ManualSelectionHandlerFunc_t
void(* le_mrc_ManualSelectionHandlerFunc_t)(le_result_t result, void *contextPtr)
Definition: le_mrc_interface.h:888
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_ScanInformationListRef_t
struct le_mrc_ScanInformationList * le_mrc_ScanInformationListRef_t
Definition: le_mrc_interface.h:662
le_mrc_TryConnectService
le_result_t le_mrc_TryConnectService(void)
le_mrc_SetSignalStrengthIndDelta
le_result_t le_mrc_SetSignalStrengthIndDelta(le_mrc_Rat_t rat, uint16_t delta)
le_mrc_PacketSwitchedChangeHandlerFunc_t
void(* le_mrc_PacketSwitchedChangeHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:844
LE_MRC_RAT_LTE
LTE network. 
Definition: le_mrc_interface.h:743
le_mrc_RatChangeHandlerFunc_t
void(* le_mrc_RatChangeHandlerFunc_t)(le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_interface.h:830
le_mrc_GetRatPreferences
le_result_t le_mrc_GetRatPreferences(le_mrc_RatBitMask_t *ratMaskPtrPtr)
le_mrc_CellInfoRef_t
struct le_mrc_CellInfo * le_mrc_CellInfoRef_t
Definition: le_mrc_interface.h:686
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_SignalStrengthChangeHandlerRef_t
struct le_mrc_SignalStrengthChangeHandler * le_mrc_SignalStrengthChangeHandlerRef_t
Definition: le_mrc_interface.h:798
le_mrc_GetNeighborCellsInfo
le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo(void)
le_mrc_GetCellularNetworkRat
le_mrc_Rat_t le_mrc_GetCellularNetworkRat(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_RemoveRatChangeHandler
void le_mrc_RemoveRatChangeHandler(le_mrc_RatChangeHandlerRef_t handlerRef)
le_mrc_NetworkRejectHandlerRef_t
struct le_mrc_NetworkRejectHandler * le_mrc_NetworkRejectHandlerRef_t
Definition: le_mrc_interface.h:806
LE_MRC_REG_HOME
Registered, home network. 
Definition: le_mrc_interface.h:714
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_PerformCellularNetworkScanAsync
void le_mrc_PerformCellularNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_GetLteSignalMetrics
le_result_t le_mrc_GetLteSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *blerPtr, int32_t *rsrqPtr, int32_t *rsrpPtr, int32_t *snrPtr)
LE_MRC_RAT_GSM
GSM network. 
Definition: le_mrc_interface.h:737
le_mrc_NetRegStateHandlerFunc_t
void(* le_mrc_NetRegStateHandlerFunc_t)(le_mrc_NetRegState_t state, void *contextPtr)
Definition: le_mrc_interface.h:816
le_mrc_RemoveNetworkRejectHandler
void le_mrc_RemoveNetworkRejectHandler(le_mrc_NetworkRejectHandlerRef_t handlerRef)
LE_MRC_BITMASK_RAT_ALL
To Set all RAT preference Bit Mask. 
Definition: le_mrc_interface.h:763
le_mrc_RatBitMask_t
le_mrc_RatBitMask_t
Definition: le_mrc_interface.h:756
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_RAT_CDMA
CDMA network. 
Definition: le_mrc_interface.h:745
le_mrc_SetManualRegisterModeAsync
void le_mrc_SetManualRegisterModeAsync(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_ManualSelectionHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_Rat_t
le_mrc_Rat_t
Definition: le_mrc_interface.h:733
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_RAT_UNKNOWN
Unknown. 
Definition: le_mrc_interface.h:735
le_mrc_SetLteBandPreferences
le_result_t le_mrc_SetLteBandPreferences(le_mrc_LteBandBitMask_t bandMask)
le_mrc_IsCellularNetworkForbidden
bool le_mrc_IsCellularNetworkForbidden(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_ScanInformationRef_t
struct le_mrc_ScanInformation * le_mrc_ScanInformationRef_t
Definition: le_mrc_interface.h:654
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_SetServerDisconnectHandler
void le_mrc_SetServerDisconnectHandler(le_mrc_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_mrc_GetCurrentNetworkName
le_result_t le_mrc_GetCurrentNetworkName(char *nameStr, size_t nameStrSize)
le_mrc_GetRadioAccessTechInUse
le_result_t le_mrc_GetRadioAccessTechInUse(le_mrc_Rat_t *ratPtr)
le_mrc_GetPreferredOperatorsList
le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList(void)
le_mrc_GetLteBandPreferences
le_result_t le_mrc_GetLteBandPreferences(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
le_mrc_AddPreferredOperator
le_result_t le_mrc_AddPreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_RatBitMask_t ratMask)
le_mrc_GetBandCapabilities
le_result_t le_mrc_GetBandCapabilities(le_mrc_BandBitMask_t *bandMaskPtrPtr)
le_mrc_IsCellularNetworkHome
bool le_mrc_IsCellularNetworkHome(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_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)
legato.h
le_mrc_NetworkRejectHandlerFunc_t
void(* le_mrc_NetworkRejectHandlerFunc_t)(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_Rat_t rat, void *contextPtr)
Definition: le_mrc_interface.h:902
LE_MRC_REG_SEARCHING
Not registered but currently searching for a new operator. 
Definition: le_mrc_interface.h:716
le_mrc_BandBitMask_t
le_mrc_BandBitMask_t
Definition: le_mrc_interface.h:543
le_mrc_GetUmtsSignalMetrics
le_result_t le_mrc_GetUmtsSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *blerPtr, int32_t *ecioPtr, int32_t *rscpPtr, int32_t *sinrPtr)
le_mrc_SignalStrengthChangeHandlerFunc_t
void(* le_mrc_SignalStrengthChangeHandlerFunc_t)(int32_t ss, void *contextPtr)
Definition: le_mrc_interface.h:858
le_mrc_DisconnectService
void le_mrc_DisconnectService(void)
le_mrc_IsCellularNetworkInUse
bool le_mrc_IsCellularNetworkInUse(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_CellularNetworkScanHandlerFunc_t
void(* le_mrc_CellularNetworkScanHandlerFunc_t)(le_mrc_ScanInformationListRef_t listRef, void *contextPtr)
Definition: le_mrc_interface.h:873
le_mrc_NetRegState_t
le_mrc_NetRegState_t
Definition: le_mrc_interface.h:710
le_mrc_GetNeighborCellLocAreaCode
uint32_t le_mrc_GetNeighborCellLocAreaCode(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_MeasureSignalMetrics
le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics(void)
le_mrc_LteBandBitMask_t
le_mrc_LteBandBitMask_t
Definition: le_mrc_interface.h:593
LE_MRC_REG_UNKNOWN
Unknown state. 
Definition: le_mrc_interface.h:722
le_mrc_IsCellularNetworkAvailable
bool le_mrc_IsCellularNetworkAvailable(le_mrc_ScanInformationRef_t scanInformationRef)
LE_MRC_REG_DENIED
Registration was denied, usually because of invalid access credentials. 
Definition: le_mrc_interface.h:718
LE_MRC_BITMASK_RAT_UMTS
UMTS RAT Bit Mask. 
Definition: le_mrc_interface.h:759
le_mrc_TdScdmaBandBitMask_t
le_mrc_TdScdmaBandBitMask_t
Definition: le_mrc_interface.h:637
LE_MRC_REG_NONE
Not registered and not currently searching for new operator. 
Definition: le_mrc_interface.h:712
LE_MRC_BITMASK_RAT_GSM
GSM RAT Bit Mask. 
Definition: le_mrc_interface.h:758
le_mrc_AddNetworkRejectHandler
le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler(le_mrc_NetworkRejectHandlerFunc_t handlerPtr, void *contextPtr)
le_mrc_GetBandPreferences
le_result_t le_mrc_GetBandPreferences(le_mrc_BandBitMask_t *bandMaskPtrPtr)
le_mrc_PacketSwitchedChangeHandlerRef_t
struct le_mrc_PacketSwitchedChangeHandler * le_mrc_PacketSwitchedChangeHandlerRef_t
Definition: le_mrc_interface.h:790
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:70