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