le_mrc_interface.h

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