le_mrc_interface.h

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