le_mrc_interface.h

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