le_mrc_interface.h

Go to the documentation of this file.
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_AddNetRegRejectHandler Report Network Registration Reject Indication
120  *
121  * The application can register a handler function to report network reject with reject cause,
122  * reject service domain, MNC/MCC code and the Radio Access Technology using
123  * le_mrc_AddNetRegRejectHandler() API (le_mrc_AddNetworkRejectHandler() will be deprecated).
124  *
125  * le_mrc_RemoveNetRegRejectHandler() API uninstalls the handler function.
126  *
127  * @deprecated le_mrc_NetworkRejectHandler() will be removed in near future.
128  * It will be replaced by le_mrc_AddNetRegRejectHandler().
129  *
130  * le_mrc_NetworkRejectHandler Report Network Reject Indication
131  *
132  * The application can register a handler function to report network reject with MNC/MCC code and
133  * the Radio Access Technology using le_mrc_AddNetworkRejectHandler() API.
134  *
135  * le_mrc_RemoveNetworkRejectHandler() API uninstalls the handler function.
136  *
137  * @section le_mrc_capabilities Radio Capabilities
138  *
139  * le_mrc_GetBandCapabilities() let you get the 2G/3G band capabilities by retrieving a bit mask
140  * built with @c le_mrc_BandBitMask_t
141  *
142  * le_mrc_GetLteBandCapabilities() let you get the LTE band capabilities by retrieving a bit mask
143  * built with @c le_mrc_LteBandBitMask_t
144  *
145  * le_mrc_GetTdScdmaBandCapabilities() let you get the TD-SCDMA band capabilities by retrieving
146  * a bit mask built with @c le_mrc_TdScdmaBandBitMask_t
147  *
148  * A sample code can be seen in the following page:
149  * - @subpage c_mrcBandCapabilities
150  *
151  * @section le_mrc_rat Radio Access Technology (RAT)
152  * le_mrc_GetRadioAccessTechInUse() API retrieves the current active Radio Access Technology (RAT).
153  * @note The API returns the RAT only if the device is registered on the network.
154  *
155  * The application can register a handler function to retrieve the Radio Access Technology each time
156  * the RAT changes.
157  *
158  * le_mrc_AddRatChangeHandler() API installs a RAT change handler.
159  *
160  * le_mrc_RemoveRatChangeHandler() API uninstalls the handler function.
161  *
162  * le_mrc_SetRatPreferences(), le_mrc_GetRatPreferences() let you set/get the Radio Access
163  * Technology preferences by using a bit mask built with @c le_mrc_RatBitMask_t.
164  *
165  * The Radio Access Technology preferences can be:
166  * - CDMA (CDMA2000-1X + CDMA2000-HRPD)
167  * - GSM
168  * - UMTS (UMTS)
169  * - TDSCDMA (TD-SCDMA)
170  * - LTE
171  *
172  * @note LE_MRC_BITMASK_RAT_ALL value can be used to select the RAT in automatic mode.
173  *
174  * A sample code can be seen in the following page:
175  * - @subpage c_mrcRAT
176  *
177  * @section le_mrc_registration Network Registration
178  * le_mrc_GetNetRegState() API retrieves the radio module network registration status.
179  *
180  * The application can register a handler function to retrieve the registration status each time the
181  * registration state changes.
182  *
183  * le_mrc_AddNetRegStateEventHandler() API installs a registration state handler.
184  *
185  * le_mrc_RemoveNetRegStateEventHandler() API uninstalls the handler function.
186  * @note If only one handler is registered, the le_mrc_RemoveNetRegStateHandler() API
187  * resets the registration mode to its original value before any handler functions were added.
188  *
189  * le_mrc_SetManualRegisterMode() API registers on a cellular network.
190  *
191  * Call le_mrc_SetManualRegisterModeAsync() function to set the manual registration mode
192  * asynchronously. The function is not blocking. The response will be returned with the
193  * @c le_mrc_ManualSelectionHandlerFunc_t handler function.
194  *
195  * When the network registration fails, the platform specific network registration error code can
196  * be known by using le_mrc_GetPlatformSpecificRegistrationErrorCode() API.
197  * Please refer to @ref platformConstraintsSpecificErrorCodes for platform specific
198  * registration error code description.
199  *
200  * A sample code can be seen in the following page:
201  * - @subpage c_mrcNetworkRegistration
202  *
203  * @section le_mrc_service Packet services state
204  *
205  * le_mrc_GetPacketSwitchedState() API retrieves the current Packet Switched state
206  * @ref le_mrc_NetRegState_t.
207  *
208  * The Packet Switched services state can be:
209  * - NONE
210  * - HOME
211  * - ROAMING
212  *
213  * The application can register a handler function to retrieve the Packet
214  * Switched state each time the service state changes.
215  *
216  * le_mrc_AddPacketSwitchedChangeHandler() API installs a Packet Switched state handler.
217  *
218  * le_mrc_RemovePacketSwitchedChangeHandler() API uninstalls the handler function.
219  *
220  * A sample code can be seen in the following page:
221  * - @subpage c_mrcGetService
222  *
223  * @section le_mrc_signal Signal Quality
224  *
225  * le_mrc_GetSignalQual() retrieves the received signal strength details.
226  *
227  * You must call le_mrc_MeasureSignalMetrics() to measure the signal metrics of the serving cell
228  * (aka the 'serving' cell). It returns a reference of le_mrc_MetricsRef_t type.
229  *
230  * When the signal metrics are no longer needed, you must call le_mrc_DeleteSignalMetrics() to free
231  * all allocated ressources associated with the Metrics object.
232  *
233  * le_mrc_GetRatOfSignalMetrics() returns the Radio Access Technology of the signal measures.
234  *
235  * le_mrc_GetGsmSignalMetrics() the signal strength in dBm and the bit error rate measured on GSM
236  * network.
237  *
238  * le_mrc_GetUmtsSignalMetrics() returns the signal metrics measured on UMTS or TD-SCDMA networks.
239  *
240  * le_mrc_GetLteSignalMetrics() returns the signal metrics measured on LTE network.
241  *
242  * le_mrc_GetCdmaSignalMetrics() returns the signal metrics measured on CDMA network.
243  *
244  * The application can register a handler function to get notifications when the signal strength
245  * changes of a certain threshold value.
246  *
247  * le_mrc_AddSignalStrengthChangeHandler() API installs a signal strength change handler.
248  * The RAT, the lower-range and the upper-range thresholds must be passed as input parameters. These
249  * parameters are updated each time the function is called, the previous thresholds are replaced by
250  * the new ones if the function is called with the same RAT. The event is notified when we cross the
251  * range limits in both direction.
252  *
253  * @warning A fatal error will be thrown if the RAT is not valid and the
254  * le_mrc_AddSignalStrengthChangeHandler function won't return.
255  *
256  * le_mrc_RemoveSignalStrengthChangeHandler() API uninstalls the handler function.
257  *
258  * le_mrc_SetSignalStrengthIndThresholds() API changes or sets new thresholds.
259  *
260  * le_mrc_SetSignalStrengthIndDelta() API sets a signal strength indication delta value for a
261  * specific RAT. The event is notified when the delta range is crossed in both direction.
262  *
263  * A sample code can be seen in the following page:
264  * - @subpage c_mrcQuality
265  *
266  * @section le_mrc_location Serving cell's location information
267  *
268  * le_mrc_GetServingCellId() retrieves the the serving Cell Identifier.
269  *
270  * le_mrc_GetServingCellLocAreaCode() retrieves the Location Area Code of the serving cell.
271  *
272  * le_mrc_GetServingCellLteTracAreaCode() retrieves the the Tracking Area Code of the serving cell
273  * (LTE only).
274  *
275  * A sample code can be seen in the following page:
276  * - @subpage c_mrcLocationinformation
277  *
278  * @section le_mrc_network_information Current Network Information
279  * le_mrc_GetCurrentNetworkName() retrieves the Current Network Name.
280  * le_mrc_GetCurrentNetworkMccMnc() retrieves the Current Network PLMN information.
281  *
282  * A sample code can be seen in the following page:
283  * - @subpage c_mrcGetCurrentNetwork
284  *
285  * @section le_mrc_networkScan Network Scan
286  *
287  * Call le_mrc_PerformCellularNetworkScan() to fill a list of all network in sight.
288  * You can go through all Scan Information by calling le_mrc_GetFirstCellularNetworkScan() and
289  * le_mrc_GetNextCellularNetworkScan().
290  *
291  * Call le_mrc_PerformCellularNetworkScanAsync() to start a network scan asynchronously. The
292  * function is not blocking. The scan list reference will be returned with the handler function
293  * response (@c le_mrc_CellularNetworkScanHandlerFunc_t).
294  *
295  * For each Scan Information, you can call:
296  *
297  * - le_mrc_GetCellularNetworkMccMnc() to have the operator code.
298  * - le_mrc_GetCellularNetworkName() to get the operator name.
299  * - le_mrc_GetCellularNetworkRat() to get the radio access technology.
300  * - le_mrc_IsCellularNetworkInUse() to check if this is currently in use by the network.
301  * - le_mrc_IsCellularNetworkAvailable() to check if this is available.
302  * - le_mrc_IsCellularNetworkHome() to check if this is in home status.
303  * - le_mrc_IsCellularNetworkForbidden() to check if this is forbidden by the network.
304  *
305  * le_mrc_DeleteCellularNetworkScan() should be called when you do not need the list anymore.
306  *
307  * A sample code can be seen in the following page:
308  * - @subpage c_mrcNetworkScan
309  *
310  * @section le_mrc_PcinetworkScan PCI Network Scan
311  *
312  * Call le_mrc_PerformPciNetworkScan() to fill a list of all neighboring cells.
313  * The Pci scan is used to get the according MCC/MNC for each neightboring cells ID. Not that a cell
314  * may contain more than one MCC/MNC when sevral plmn sharing the same cell.
315  *
316  * You can go through all Scan Information by calling le_mrc_GetFirstPciScanInfo() and
317  * le_mrc_GetNextPciScanInfo(). Note that each cell info contains a list of mcc/mnc, you can go
318  * through all mcc/mnc Information for each cell by calling le_mrc_GetFirstPlmnInfo()
319  * and le_mrc_GetNextPlmnInfo(), this two APIs return a reference to PlmnInformation, then use
320  * le_mrc_GetPciScanMccMnc() by giving this reference as parameter to get the Mcc/Mnc of the Plmn.
321  *
322  * Call le_mrc_PerformPciNetworkScanAsync()to start a pci scan asynchronously. The
323  * function is not blocking. The scan list reference will be returned with the handler function
324  * response (@c le_mrc_PciNetworkScanHandlerFunc_t).
325  *
326  *
327  * For Pci Network Scan Information, you can call:
328  *
329  * - le_mrc_GetPciScanCellId() to get the physical id of each cell.
330  * - le_mrc_GetPciScanGlobalCellId() to get the global id of each cell.
331  * - le_mrc_GetPciScanMccMnc() to get the Mcc/Mnc of each plmn on each cell.
332  * - le_mrc_DeletePciNetworkScan() should be called when you do not need the list anymore.
333  *
334  * A sample code can be seen in the following page:
335  * - @subpage c_mrcPciScan
336  *
337  * @section le_mrc_ngbr Neighboring Cells Information
338  *
339  * @warning The following functions do not apply to CDMA network.
340  *
341  * You must call le_mrc_GetNeighborCellsInfo() to retrieve the neighboring cells
342  * information. It returns a reference of le_mrc_NeighborCellsRef_t type.
343  *
344  * When the neighboring cells information is no longer needed, you must call
345  * le_mrc_DeleteNeighborCellsInfo() to free all allocated resources associated with the
346  * object.
347  *
348  * Then, you can use the following function to get the information:
349  * - le_mrc_GetFirstNeighborCellInfo() and le_mrc_GetFirstNeighborCellInfo() allow to go among
350  * the single cell information retrieved with le_mrc_GetNeighborCellsInfo(). These two functions
351  * return a reference of le_mrc_CellInfoRef_t type.
352  * - le_mrc_GetNeighborCellId() gets the identifier of the cell specified with the
353  * le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT32_MAX value is
354  * returned if the value is not available.
355  * - le_mrc_GetNeighborCellLocAreaCode() gets the location area code of the cell specified with the
356  * le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT). UINT16_MAX value is
357  * returned if the value is not available.
358  * - le_mrc_GetNeighborCellRxLevel() gets the signal strength (in dBm) of the cell specified with
359  * the le_mrc_CellInfoRef_t parameter (can be called for any kind of RAT).
360  * - le_mrc_GetNeighborCellRat() gets the Radio Access Technology of the cell specified with
361  * the le_mrc_CellInfoRef_t parameter.
362  * - le_mrc_GetNeighborCellUmtsEcIo() gets the Ec/Io (the received energy per chip divided by the
363  * power density in the band measured in dBm on the primary CPICH channel of serving cell) of the
364  * cell specified with the le_mrc_CellInfoRef_t parameter.
365  * - le_mrc_GetNeighborCellLteIntraFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
366  * specified with the le_mrc_CellInfoRef_t parameter.
367  * - le_mrc_GetNeighborCellLteInterFreq() gets the RSRP and RSRQ of the Interfrequency of the cell
368  * specified with the le_mrc_CellInfoRef_t parameter.
369  *
370  * A sample code can be seen in the following page:
371  * - @subpage c_mrcNeighborCells
372  *
373  * @section le_mrc_jamming Jamming detection
374  *
375  * The jamming detection algorithm is based on power measurements and cell synchronization actions
376  * performed during a GSM network scan procedure.
377  * During this procedure some intermediate results are reported, that allows user to take some
378  * preventive actions if necessary.
379  * This result is reported as a jammed state probability. See @ref le_mrc_JammingStatus_t
380  * enumeration for probability description.
381  * Each time the jamming status changes during the scan procedure, it is reported to the user.
382  * See @ref le_mrc_JammingReport_t enumeration for details.
383  *
384  * The jamming status is reported:
385  * - In an unsolicited way, each time the protocol stack initiates a scan for PLMN selection or
386  * reselection.
387  * - On user demand, when a user PLMN scan is performed.
388  *
389  * Call le_mrc_StartJammingDetection() to launch jamming monitoring.
390  * By registering a handler by calling le_mrc_AddJammingDetectionEventHandler(), the notification
391  * on jamming detection can be sent to the registered application.
392  *
393  * For each jamming detection monitoring, the following APIs can be called:
394  * - le_mrc_StartJammingDetection() to start the jamming monitoring.
395  * - le_mrc_StopJammingDetection() to stop the jamming monitoring.
396  * - le_mrc_AddJammingDetectionEventHandler() to register an event handler.
397  * - le_mrc_RemoveJammingDetectionEventHandler() to remove an event handler.
398  *
399  * @section le_mrc_sar SAR backoff
400  * SAR (Specific Absorption Rate) is a measure of RF energy absorption by the human body.
401  * Users can dynamically select a pre-configured SAR backoff state so they can adjust the SAR
402  * depending on their needs. To manage SAR backoff, these API should be used:
403  * - le_mrc_SetSarBackoffState() to set a new SAR backoff state.
404  * - le_mrc_GetSarBackoffState() to get the current SAR backoff state.
405  * This feature may be unsupported by some targets. Also, the number of supported states may vary
406  * depending on the target. Please refer to @ref platformConstraintsMdc for further details.
407  *
408  * <HR>
409  *
410  * Copyright (C) Sierra Wireless Inc.
411  */
412 /**
413  * @page c_mrcRadioPower Sample code for Radio Power Management
414  *
415  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Radio Power
416  */
417 /**
418  * @page c_mrcRadioConfigurationPreferences Sample code for Radio Configuration Preferences
419  *
420  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Preferences
421  *
422  */
423 /**
424  * @page c_mrcRAT Sample code for Radio Access Technology
425  *
426  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT in Use
427  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" RAT Preferences
428  *
429  */
430 /**
431  * @page c_mrcNetworkRegistration Sample code for Network Registration
432  *
433  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Register
434  *
435  */
436 /**
437  * @page c_mrcQuality Sample code for Signal Quality
438  *
439  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Signal Quality
440  *
441  */
442 /**
443  * @page c_mrcLocationinformation Sample code for Location information
444  *
445  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Loc information
446  *
447  */
448 /**
449  * @page c_mrcBandCapabilities Sample code for Band Capabilities
450  *
451  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Band Capabilities
452  *
453  */
454 /**
455  * @page c_mrcGetCurrentNetwork Sample code for Get Current Network Information
456  *
457  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Get Network
458  *
459  */
460 /**
461  * @page c_mrcNetworkScan Sample code for Network Scan
462  *
463  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Network Scan
464  *
465  */
466 /**
467  * @page c_mrcPciScan Sample code for LTE PCI Scan
468  *
469  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" PCI Scan
470  *
471  */
472 /**
473  * @page c_mrcNeighborCells Sample code for Neighboring Cells Information
474  *
475  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Neighbor Cells
476  *
477  */
478 /**
479  * @page c_mrcGetService Sample code for Get the Current Packet Switched state
480  *
481  * @snippet "apps/test/modemServices/mrc/mrcIntegrationTest/mrcTest/le_mrcTest.c" Service State
482  *
483  */
484 /**
485  * @file le_mrc_interface.h
486  *
487  * Legato @ref c_mrc include file.
488  *
489  * Copyright (C) Sierra Wireless Inc.
490  */
491 
492 #ifndef LE_MRC_INTERFACE_H_INCLUDE_GUARD
493 #define LE_MRC_INTERFACE_H_INCLUDE_GUARD
494 
495 
496 #include "legato.h"
497 
498 // Internal includes for this interface
499 #include "le_mrc_common.h"
500 //--------------------------------------------------------------------------------------------------
501 /**
502  * Type for handler called when a server disconnects.
503  */
504 //--------------------------------------------------------------------------------------------------
505 typedef void (*le_mrc_DisconnectHandler_t)(void *);
506 
507 //--------------------------------------------------------------------------------------------------
508 /**
509  *
510  * Connect the current client thread to the service providing this API. Block until the service is
511  * available.
512  *
513  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
514  * called before any other functions in this API. Normally, ConnectService is automatically called
515  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
516  *
517  * This function is created automatically.
518  */
519 //--------------------------------------------------------------------------------------------------
521 (
522  void
523 );
524 
525 //--------------------------------------------------------------------------------------------------
526 /**
527  *
528  * Try to connect the current client thread to the service providing this API. Return with an error
529  * if the service is not available.
530  *
531  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
532  * called before any other functions in this API. Normally, ConnectService is automatically called
533  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
534  *
535  * This function is created automatically.
536  *
537  * @return
538  * - LE_OK if the client connected successfully to the service.
539  * - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
540  * bound.
541  * - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
542  * - LE_COMM_ERROR if the Service Directory cannot be reached.
543  */
544 //--------------------------------------------------------------------------------------------------
546 (
547  void
548 );
549 
550 //--------------------------------------------------------------------------------------------------
551 /**
552  * Set handler called when server disconnection is detected.
553  *
554  * When a server connection is lost, call this handler then exit with LE_FATAL. If a program wants
555  * to continue without exiting, it should call longjmp() from inside the handler.
556  */
557 //--------------------------------------------------------------------------------------------------
559 (
560  le_mrc_DisconnectHandler_t disconnectHandler,
561  void *contextPtr
562 );
563 
564 //--------------------------------------------------------------------------------------------------
565 /**
566  *
567  * Disconnect the current client thread from the service providing this API.
568  *
569  * Normally, this function doesn't need to be called. After this function is called, there's no
570  * longer a connection to the service, and the functions in this API can't be used. For details, see
571  * @ref apiFilesC_client.
572  *
573  * This function is created automatically.
574  */
575 //--------------------------------------------------------------------------------------------------
577 (
578  void
579 );
580 
581 
582 //--------------------------------------------------------------------------------------------------
583 /**
584  * 2G/3G Band Bit Mask (64 bits)
585  */
586 //--------------------------------------------------------------------------------------------------
587 
588 
589 //--------------------------------------------------------------------------------------------------
590 /**
591  * LTE Band Bit Mask (64 bits)
592  *
593  */
594 //--------------------------------------------------------------------------------------------------
595 
596 
597 //--------------------------------------------------------------------------------------------------
598 /**
599  * TDSCDMA Band Bit Mask
600  *
601  */
602 //--------------------------------------------------------------------------------------------------
603 
604 
605 //--------------------------------------------------------------------------------------------------
606 /**
607  * Reference type for referring to MRC Scan Information objects.
608  */
609 //--------------------------------------------------------------------------------------------------
610 
611 
612 //--------------------------------------------------------------------------------------------------
613 /**
614  * Reference type for Scan Information Listing.
615  */
616 //--------------------------------------------------------------------------------------------------
617 
618 
619 //--------------------------------------------------------------------------------------------------
620 /**
621  * Reference type for PCI Scan Information Listing.
622  */
623 //--------------------------------------------------------------------------------------------------
624 
625 
626 //--------------------------------------------------------------------------------------------------
627 /**
628  * Reference type for PCI Scan Information .
629  */
630 //--------------------------------------------------------------------------------------------------
631 
632 
633 //--------------------------------------------------------------------------------------------------
634 /**
635  * Reference type for PLMN Information .
636  */
637 //--------------------------------------------------------------------------------------------------
638 
639 
640 //--------------------------------------------------------------------------------------------------
641 /**
642  * Reference type for referring to the Preferred Operator objects.
643  */
644 //--------------------------------------------------------------------------------------------------
645 
646 
647 //--------------------------------------------------------------------------------------------------
648 /**
649  * Reference type for Preferred Operator Listing.
650  */
651 //--------------------------------------------------------------------------------------------------
652 
653 
654 //--------------------------------------------------------------------------------------------------
655 /**
656  * Reference type for one Cell Information.
657  */
658 //--------------------------------------------------------------------------------------------------
659 
660 
661 //--------------------------------------------------------------------------------------------------
662 /**
663  * Reference type for all Neighboring Cells Information.
664  */
665 //--------------------------------------------------------------------------------------------------
666 
667 
668 //--------------------------------------------------------------------------------------------------
669 /**
670  * Reference type for the signal metrics.
671  */
672 //--------------------------------------------------------------------------------------------------
673 
674 
675 //--------------------------------------------------------------------------------------------------
676 /**
677  * Network Registration states.
678  */
679 //--------------------------------------------------------------------------------------------------
680 
681 
682 //--------------------------------------------------------------------------------------------------
683 /**
684  * Radio Access Technology enum
685  */
686 //--------------------------------------------------------------------------------------------------
687 
688 
689 //--------------------------------------------------------------------------------------------------
690 /**
691  * Jamming detection report type enum
692  *
693  * @note If the reported status is the final status (end of the procedure), this shall be indicated
694  * within the status report.
695  * @note Other reports, called intermediate reports, gives only intermediate results issuing from
696  * the algorithm
697  */
698 //--------------------------------------------------------------------------------------------------
699 
700 
701 //--------------------------------------------------------------------------------------------------
702 /**
703  * Jamming detection status type enum
704  *
705  * @note The final status can be only NULL or JAMMED.
706  */
707 //--------------------------------------------------------------------------------------------------
708 
709 
710 //--------------------------------------------------------------------------------------------------
711 /**
712  * Radio Bitmask Access Technology Bit Mask
713  */
714 //--------------------------------------------------------------------------------------------------
715 
716 
717 //--------------------------------------------------------------------------------------------------
718 /**
719  * Network Registration reject cause type enum.
720  */
721 //--------------------------------------------------------------------------------------------------
722 
723 
724 //--------------------------------------------------------------------------------------------------
725 /**
726  * Network Registration service domain type enum.
727  */
728 //--------------------------------------------------------------------------------------------------
729 
730 
731 //--------------------------------------------------------------------------------------------------
732 /**
733  * Network registration reject indication structure.
734  */
735 //--------------------------------------------------------------------------------------------------
736 
737 
738 //--------------------------------------------------------------------------------------------------
739 /**
740  * Handler for Network registration state changes.
741  */
742 //--------------------------------------------------------------------------------------------------
743 
744 
745 //--------------------------------------------------------------------------------------------------
746 /**
747  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegStateEvent'
748  */
749 //--------------------------------------------------------------------------------------------------
750 
751 
752 //--------------------------------------------------------------------------------------------------
753 /**
754  * Handler for Radio Access Technology changes.
755  *
756  */
757 //--------------------------------------------------------------------------------------------------
758 
759 
760 //--------------------------------------------------------------------------------------------------
761 /**
762  * Reference type used by Add/Remove functions for EVENT 'le_mrc_RatChange'
763  */
764 //--------------------------------------------------------------------------------------------------
765 
766 
767 //--------------------------------------------------------------------------------------------------
768 /**
769  * Handler for Packet Switched service state changes.
770  *
771  */
772 //--------------------------------------------------------------------------------------------------
773 
774 
775 //--------------------------------------------------------------------------------------------------
776 /**
777  * Reference type used by Add/Remove functions for EVENT 'le_mrc_PacketSwitchedChange'
778  */
779 //--------------------------------------------------------------------------------------------------
780 
781 
782 //--------------------------------------------------------------------------------------------------
783 /**
784  * Handler for Signal Strength value changes.
785  *
786  */
787 //--------------------------------------------------------------------------------------------------
788 
789 
790 //--------------------------------------------------------------------------------------------------
791 /**
792  * Reference type used by Add/Remove functions for EVENT 'le_mrc_SignalStrengthChange'
793  */
794 //--------------------------------------------------------------------------------------------------
795 
796 
797 //--------------------------------------------------------------------------------------------------
798 /**
799  * Handler for cellular asynchronous network scan Sending result.
800  * Returns the reference to the List object. Null pointer if the scan failed.
801  *
802  */
803 //--------------------------------------------------------------------------------------------------
804 
805 
806 //--------------------------------------------------------------------------------------------------
807 /**
808  * Handler for PCI asynchronous network scan Sending result.
809  * Returns the reference to the List object. Null pointer if the scan failed.
810  *
811  */
812 //--------------------------------------------------------------------------------------------------
813 
814 
815 //--------------------------------------------------------------------------------------------------
816 /**
817  * Handler for asynchronous manual selection response
818  *
819  */
820 //--------------------------------------------------------------------------------------------------
821 
822 
823 //--------------------------------------------------------------------------------------------------
824 /**
825  * Handler to report network reject indication.
826  *
827  * @deprecated le_mrc_NetworkRejectHandler() will be removed in near future.
828  * It will be replaced by le_mrc_AddNetRegRejectHandler().
829  *
830  */
831 //--------------------------------------------------------------------------------------------------
832 
833 
834 //--------------------------------------------------------------------------------------------------
835 /**
836  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetworkReject'
837  */
838 //--------------------------------------------------------------------------------------------------
839 
840 
841 //--------------------------------------------------------------------------------------------------
842 /**
843  * Handler to report network registration reject indication.
844  * NetworkRejectHandler is deprecated.
845  */
846 //--------------------------------------------------------------------------------------------------
847 
848 
849 //--------------------------------------------------------------------------------------------------
850 /**
851  * Reference type used by Add/Remove functions for EVENT 'le_mrc_NetRegReject'
852  */
853 //--------------------------------------------------------------------------------------------------
854 
855 
856 //--------------------------------------------------------------------------------------------------
857 /**
858  * Handler for jamming detection event.
859  */
860 //--------------------------------------------------------------------------------------------------
861 
862 
863 //--------------------------------------------------------------------------------------------------
864 /**
865  * Reference type used by Add/Remove functions for EVENT 'le_mrc_JammingDetectionEvent'
866  */
867 //--------------------------------------------------------------------------------------------------
868 
869 
870 //--------------------------------------------------------------------------------------------------
871 /**
872  * Add handler function for EVENT 'le_mrc_NetRegStateEvent'
873  *
874  * This event provides information on network registration state changes.
875  *
876  * @note <b>multi-app safe</b>
877  */
878 //--------------------------------------------------------------------------------------------------
879 le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler
880 (
881  le_mrc_NetRegStateHandlerFunc_t handlerPtr,
882  ///< [IN]
883  void* contextPtr
884  ///< [IN]
885 );
886 
887 //--------------------------------------------------------------------------------------------------
888 /**
889  * Remove handler function for EVENT 'le_mrc_NetRegStateEvent'
890  */
891 //--------------------------------------------------------------------------------------------------
893 (
894  le_mrc_NetRegStateEventHandlerRef_t handlerRef
895  ///< [IN]
896 );
897 
898 //--------------------------------------------------------------------------------------------------
899 /**
900  * Add handler function for EVENT 'le_mrc_RatChange'
901  *
902  * This event provides information on Radio Access Technology changes.
903  *
904  * @note <b>multi-app safe</b>
905  */
906 //--------------------------------------------------------------------------------------------------
907 le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler
908 (
909  le_mrc_RatChangeHandlerFunc_t handlerPtr,
910  ///< [IN]
911  void* contextPtr
912  ///< [IN]
913 );
914 
915 //--------------------------------------------------------------------------------------------------
916 /**
917  * Remove handler function for EVENT 'le_mrc_RatChange'
918  */
919 //--------------------------------------------------------------------------------------------------
921 (
922  le_mrc_RatChangeHandlerRef_t handlerRef
923  ///< [IN]
924 );
925 
926 //--------------------------------------------------------------------------------------------------
927 /**
928  * Add handler function for EVENT 'le_mrc_PacketSwitchedChange'
929  *
930  * This event provides information on Packet Switched service changes.
931  *
932  * @note <b>multi-app safe</b>
933  */
934 //--------------------------------------------------------------------------------------------------
935 le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler
936 (
937  le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr,
938  ///< [IN]
939  void* contextPtr
940  ///< [IN]
941 );
942 
943 //--------------------------------------------------------------------------------------------------
944 /**
945  * Remove handler function for EVENT 'le_mrc_PacketSwitchedChange'
946  */
947 //--------------------------------------------------------------------------------------------------
949 (
950  le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef
951  ///< [IN]
952 );
953 
954 //--------------------------------------------------------------------------------------------------
955 /**
956  * Add handler function for EVENT 'le_mrc_SignalStrengthChange'
957  *
958  * This event provides information on Signal Strength value changes.
959  *
960  * @note <b>NOT multi-app safe</b>
961  */
962 //--------------------------------------------------------------------------------------------------
963 le_mrc_SignalStrengthChangeHandlerRef_t le_mrc_AddSignalStrengthChangeHandler
964 (
965  le_mrc_Rat_t rat,
966  ///< [IN] Radio Access Technology
967  int32_t lowerRangeThreshold,
968  ///< [IN] Lower-range Signal strength threshold in dBm
969  int32_t upperRangeThreshold,
970  ///< [IN] Upper-range Signal strength threshold in dBm
971  le_mrc_SignalStrengthChangeHandlerFunc_t handlerPtr,
972  ///< [IN]
973  void* contextPtr
974  ///< [IN]
975 );
976 
977 //--------------------------------------------------------------------------------------------------
978 /**
979  * Remove handler function for EVENT 'le_mrc_SignalStrengthChange'
980  */
981 //--------------------------------------------------------------------------------------------------
983 (
984  le_mrc_SignalStrengthChangeHandlerRef_t handlerRef
985  ///< [IN]
986 );
987 
988 //--------------------------------------------------------------------------------------------------
989 /**
990  * This function sets signal strength indication thresholds for a specific RAT.
991  *
992  * @return
993  * - LE_OK Function succeeded.
994  * - LE_BAD_PARAMETER Bad parameters
995  * - LE_FAULT Function failed.
996  *
997  * @note <b>NOT multi-app safe</b>
998  */
999 //--------------------------------------------------------------------------------------------------
1001 (
1002  le_mrc_Rat_t rat,
1003  ///< [IN] Radio Access Technology
1004  int32_t lowerRangeThreshold,
1005  ///< [IN] Lower-range Signal strength threshold in dBm
1006  int32_t upperRangeThreshold
1007  ///< [IN] Upper-range Signal strength threshold in dBm
1008 );
1009 
1010 //--------------------------------------------------------------------------------------------------
1011 /**
1012  * This function sets a signal strength indication delta for a specific RAT.
1013  *
1014  * @return
1015  * - LE_OK Function succeeded.
1016  * - LE_BAD_PARAMETER Bad parameters.
1017  * - LE_FAULT Function failed.
1018  *
1019  * @note The signal delta is set in units of 0.1 dBm. For example, to set a delta of 10.6 dBm, the
1020  * delta value must be set to 106.
1021  *
1022  * @warning The signal delta resolution is platform dependent. Please refer to
1023  * @ref platformConstraintsMdc section for full details.
1024  */
1025 //--------------------------------------------------------------------------------------------------
1027 (
1028  le_mrc_Rat_t rat,
1029  ///< [IN] Radio Access Technology
1030  uint16_t delta
1031  ///< [IN] Signal delta in units of 0.1 dBm
1032 );
1033 
1034 //--------------------------------------------------------------------------------------------------
1035 /**
1036  * Enable the automatic Selection Register mode.
1037  *
1038  * @return
1039  * - LE_FAULT Function failed.
1040  * - LE_OK Function succeeded.
1041  *
1042  * @note <b>NOT multi-app safe</b>
1043  */
1044 //--------------------------------------------------------------------------------------------------
1046 (
1047  void
1048 );
1049 
1050 //--------------------------------------------------------------------------------------------------
1051 /**
1052  * Set the manual Selection Register mode with the MCC/MNC parameters.
1053  *
1054  * @return
1055  * - LE_FAULT Function failed.
1056  * - LE_OK Function succeeded.
1057  *
1058  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1059  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1060  * won't return.
1061  *
1062  * @note <b>NOT multi-app safe</b>
1063  */
1064 //--------------------------------------------------------------------------------------------------
1066 (
1067  const char* LE_NONNULL mcc,
1068  ///< [IN] Mobile Country Code
1069  const char* LE_NONNULL mnc
1070  ///< [IN] Mobile Network Code
1071 );
1072 
1073 //--------------------------------------------------------------------------------------------------
1074 /**
1075  * Set the manual selection register mode asynchronously. This function is not blocking,
1076  * the response will be returned with a handler function.
1077  *
1078  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1079  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1080  * won't return.
1081  *
1082  *@note <b>NOT multi-app safe</b>
1083  *
1084  */
1085 //--------------------------------------------------------------------------------------------------
1087 (
1088  const char* LE_NONNULL mcc,
1089  ///< [IN] Mobile Country Code
1090  const char* LE_NONNULL mnc,
1091  ///< [IN] Mobile Network Code
1092  le_mrc_ManualSelectionHandlerFunc_t handlerPtr,
1093  ///< [IN] handler for sending result
1094  void* contextPtr
1095  ///< [IN]
1096 );
1097 
1098 //--------------------------------------------------------------------------------------------------
1099 /**
1100  * Get the selected Selection Register mode.
1101  *
1102  * @return
1103  * - LE_FAULT Function failed.
1104  * - LE_OK Function succeeded.
1105  *
1106  * @note <b>multi-app safe</b>
1107  */
1108 //--------------------------------------------------------------------------------------------------
1110 (
1111  bool* isManualPtrPtr,
1112  ///< [OUT] true if the scan mode is manual, false if the scan mode is automatic.
1113  char* mccPtr,
1114  ///< [OUT] Mobile Country Code
1115  size_t mccPtrSize,
1116  ///< [IN]
1117  char* mncPtr,
1118  ///< [OUT] Mobile Network Code
1119  size_t mncPtrSize
1120  ///< [IN]
1121 );
1122 
1123 //--------------------------------------------------------------------------------------------------
1124 /**
1125  * Get the Packet Switched state.
1126  *
1127  * @return
1128  * - LE_FAULT Function failed.
1129  * - LE_OK Function succeeded.
1130  *
1131  * @note <b>multi-app safe</b>
1132  */
1133 //--------------------------------------------------------------------------------------------------
1135 (
1136  le_mrc_NetRegState_t* statePtr
1137  ///< [OUT] The current Packet switched state.
1138 );
1139 
1140 //--------------------------------------------------------------------------------------------------
1141 /**
1142  * Get the platform specific network registration error code.
1143  *
1144  * Refer to @ref platformConstraintsSpecificErrorCodes for platform specific
1145  * registration error code description.
1146  *
1147  * @return the platform specific registration error code
1148  *
1149  */
1150 //--------------------------------------------------------------------------------------------------
1152 (
1153  void
1154 );
1155 
1156 //--------------------------------------------------------------------------------------------------
1157 /**
1158  * Set the Radio Access Technology preferences by using a bit mask.
1159  *
1160  * @return
1161  * - LE_FAULT Function failed.
1162  * - LE_OK Function succeeded.
1163  * - LE_UNSUPPORTED Not supported by platform.
1164  *
1165  * @note <b>NOT multi-app safe</b>
1166  */
1167 //--------------------------------------------------------------------------------------------------
1169 (
1170  le_mrc_RatBitMask_t ratMask
1171  ///< [IN] Bit mask for the Radio Access Technology preferences.
1172 );
1173 
1174 //--------------------------------------------------------------------------------------------------
1175 /**
1176  * Get the Radio Access Technology preferences
1177  *
1178  * @return
1179  * - LE_FAULT Function failed.
1180  * - LE_OK Function succeeded.
1181  *
1182  * @note <b>multi-app safe</b>
1183  */
1184 //--------------------------------------------------------------------------------------------------
1186 (
1187  le_mrc_RatBitMask_t* ratMaskPtrPtr
1188  ///< [OUT] Bit mask for the Radio Access Technology preferences.
1189 );
1190 
1191 //--------------------------------------------------------------------------------------------------
1192 /**
1193  * Set the 2G/3G Band preferences by using a bit mask.
1194  *
1195  * @return
1196  * - LE_FAULT Function failed.
1197  * - LE_OK Function succeeded.
1198  *
1199  * @note <b>NOT multi-app safe</b>
1200  */
1201 //--------------------------------------------------------------------------------------------------
1203 (
1204  le_mrc_BandBitMask_t bandMask
1205  ///< [IN] Bit mask for 2G/3G Band preferences.
1206 );
1207 
1208 //--------------------------------------------------------------------------------------------------
1209 /**
1210  * Get the Bit mask for 2G/3G Band preferences.
1211  *
1212  * @return
1213  * - LE_FAULT Function failed.
1214  * - LE_OK Function succeeded.
1215  *
1216  * @note <b>multi-app safe</b>
1217  */
1218 //--------------------------------------------------------------------------------------------------
1220 (
1221  le_mrc_BandBitMask_t* bandMaskPtrPtr
1222  ///< [OUT] Bit mask for 2G/3G Band preferences.
1223 );
1224 
1225 //--------------------------------------------------------------------------------------------------
1226 /**
1227  * Set the LTE Band preferences by using a bit mask.
1228  *
1229  * @return
1230  * - LE_FAULT Function failed.
1231  * - LE_OK Function succeeded.
1232  * - LE_UNSUPPORTED The platform doesn't support setting LTE Band preferences.
1233  *
1234  * @note <b>NOT multi-app safe</b>
1235  */
1236 //--------------------------------------------------------------------------------------------------
1238 (
1239  le_mrc_LteBandBitMask_t bandMask
1240  ///< [IN] Bit mask for LTE Band preferences.
1241 );
1242 
1243 //--------------------------------------------------------------------------------------------------
1244 /**
1245  * Get the Bit mask for LTE Band preferences.
1246  *
1247  * @return
1248  * - LE_FAULT Function failed.
1249  * - LE_OK Function succeeded.
1250  *
1251  * @note <b>multi-app safe</b>
1252  */
1253 //--------------------------------------------------------------------------------------------------
1255 (
1256  le_mrc_LteBandBitMask_t* bandMaskPtrPtr
1257  ///< [OUT] Bit mask for LTE Band preferences.
1258 );
1259 
1260 //--------------------------------------------------------------------------------------------------
1261 /**
1262  * Set the TD-SCDMA Band preferences by using a bit mask.
1263  *
1264  * @return
1265  * - LE_OK Function succeeded.
1266  * - LE_FAULT Function failed.
1267  * - LE_UNSUPPORTED The platform doesn't support setting TD-SCDMA Band preferences.
1268  *
1269  * @note <b>NOT multi-app safe</b>
1270  */
1271 //--------------------------------------------------------------------------------------------------
1273 (
1274  le_mrc_TdScdmaBandBitMask_t bandMask
1275  ///< [IN] Bit mask for TD-SCDMA Band preferences.
1276 );
1277 
1278 //--------------------------------------------------------------------------------------------------
1279 /**
1280  * Get the Bit mask for TD-SCDMA Band preferences.
1281  *
1282  * @return
1283  * - LE_OK Function succeeded.
1284  * - LE_FAULT Function failed.
1285  * - LE_UNSUPPORTED The platform doesn't support getting TD-SCDMA Band preferences.
1286  *
1287  * @note <b>multi-app safe</b>
1288  */
1289 //--------------------------------------------------------------------------------------------------
1291 (
1292  le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
1293  ///< [OUT] Bit mask for TD-SCDMA Band preferences.
1294 );
1295 
1296 //--------------------------------------------------------------------------------------------------
1297 /**
1298  * Add a preferred operator by specifying the MCC/MNC and the Radio Access Technology.
1299  *
1300  * @return
1301  * - LE_UNSUPPORTED List of User Preferred operators not available.
1302  * - LE_FAULT Function failed.
1303  * - LE_BAD_PARAMETER RAT mask is invalid.
1304  * - LE_OK Function succeeded.
1305  *
1306  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1307  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1308  * won't return.
1309  *
1310  * @note <b>NOT multi-app safe</b>
1311  */
1312 //--------------------------------------------------------------------------------------------------
1314 (
1315  const char* LE_NONNULL mcc,
1316  ///< [IN] Mobile Country Code
1317  const char* LE_NONNULL mnc,
1318  ///< [IN] Mobile Network Code
1319  le_mrc_RatBitMask_t ratMask
1320  ///< [IN] Bit mask for the Radio Access Technology preferences.
1321 );
1322 
1323 //--------------------------------------------------------------------------------------------------
1324 /**
1325  * Remove a preferred operator by specifying the MCC/MNC.
1326  *
1327  * @return
1328  * - LE_UNSUPPORTED List of User Preferred operators not available.
1329  * - LE_NOT_FOUND Operator not found in the User Preferred operators list.
1330  * - LE_FAULT Function failed.
1331  * - LE_OK Function succeeded.
1332  *
1333  * @note If strings are not set, too long (bigger than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN digits), or too
1334  * short (less than LE_MRC_MCC_LEN/LE_MRC_MNC_LEN-1 digits) it's a fatal error, the function
1335  * won't return.
1336  *
1337  * @note <b>NOT multi-app safe</b>
1338  */
1339 //--------------------------------------------------------------------------------------------------
1341 (
1342  const char* LE_NONNULL mcc,
1343  ///< [IN] Mobile Country Code
1344  const char* LE_NONNULL mnc
1345  ///< [IN] Mobile Network Code
1346 );
1347 
1348 //--------------------------------------------------------------------------------------------------
1349 /**
1350  * This function must be called to retrieve a list of the preferred operators.
1351  *
1352  * @return
1353  * - Reference to the List object.
1354  * - Null pointer if there is no preferences list.
1355  *
1356  * @note <b>multi-app safe</b>
1357  */
1358 //--------------------------------------------------------------------------------------------------
1359 le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList
1360 (
1361  void
1362 );
1363 
1364 //--------------------------------------------------------------------------------------------------
1365 /**
1366  * This function must be called to get the first Operator object reference in the list of the
1367  * preferred operators retrieved with le_mrc_GetPreferredOperators().
1368  *
1369  * @return
1370  * - NULL No operator information found.
1371  * - le_mrc_PreferredOperatorRef The Operator object reference.
1372  *
1373  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
1374  * function won't return.
1375  *
1376  * @note <b>multi-app safe</b>
1377  */
1378 //--------------------------------------------------------------------------------------------------
1379 le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator
1380 (
1381  le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
1382  ///< [IN] The list of the preferred operators.
1383 );
1384 
1385 //--------------------------------------------------------------------------------------------------
1386 /**
1387  * This function must be called to get the next Operator object reference in the list of the
1388  * preferred operators retrieved with le_mrc_GetPreferredOperators().
1389  *
1390  * @return
1391  * - NULL No operator information found.
1392  * - le_mrc_PreferredOperatorRef The Operator object reference.
1393  *
1394  * @note If the caller is passing a bad reference into this function, it's a fatal error, the
1395  * function won't return.
1396  *
1397  * @note <b>multi-app safe</b>
1398  */
1399 //--------------------------------------------------------------------------------------------------
1400 le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator
1401 (
1402  le_mrc_PreferredOperatorListRef_t preferredOperatorListRef
1403  ///< [IN] The list of the preferred operators.
1404 );
1405 
1406 //--------------------------------------------------------------------------------------------------
1407 /**
1408  * This function must be called to delete the list of the preferred operators retrieved with
1409  * le_mrc_GetPreferredOperators().
1410  *
1411  * @note On failure, the process exits, so you don't have to worry about checking the returned
1412  * reference for validity.
1413  *
1414  * @note <b>multi-app safe</b>
1415  */
1416 //--------------------------------------------------------------------------------------------------
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 Operator information details.
1426  *
1427  * @return
1428  * - LE_OK on success
1429  * - LE_OVERFLOW if the MCC or MNC would not fit in buffer
1430  * - LE_FAULT for all other errors
1431  *
1432  * @note <b>multi-app safe</b>
1433  */
1434 //--------------------------------------------------------------------------------------------------
1436 (
1437  le_mrc_PreferredOperatorRef_t preferredOperatorRef,
1438  ///< [IN] Operator object reference.
1439  char* mccPtr,
1440  ///< [OUT] Mobile Country Code.
1441  size_t mccPtrSize,
1442  ///< [IN]
1443  char* mncPtr,
1444  ///< [OUT] Mobile Network Code.
1445  size_t mncPtrSize,
1446  ///< [IN]
1447  le_mrc_RatBitMask_t* ratMaskPtr
1448  ///< [OUT] Bit mask for the RAT preferences.
1449 );
1450 
1451 //--------------------------------------------------------------------------------------------------
1452 /**
1453  * Get the network registration state.
1454  *
1455  * @return LE_FAULT The function failed to get the Network registration state.
1456  * @return LE_BAD_PARAMETER A bad parameter was passed.
1457  * @return LE_OK The function succeeded.
1458  *
1459  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1460  * function won't return.
1461  *
1462  * @note <b>multi-app safe</b>
1463  */
1464 //--------------------------------------------------------------------------------------------------
1466 (
1467  le_mrc_NetRegState_t* statePtr
1468  ///< [OUT] Network Registration state.
1469 );
1470 
1471 //--------------------------------------------------------------------------------------------------
1472 /**
1473  * Get the signal quality.
1474  *
1475  * @return LE_FAULT The function failed to get the Signal Quality information.
1476  * @return LE_BAD_PARAMETER A bad parameter was passed.
1477  * @return LE_OK The function succeeded.
1478  *
1479  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1480  * function won't return.
1481  *
1482  * @note <b>multi-app safe</b>
1483  */
1484 //--------------------------------------------------------------------------------------------------
1486 (
1487  uint32_t* qualityPtr
1488  ///< [OUT] [OUT] Received signal strength quality (0 = no signal strength,
1489  ///< 5 = very good signal strength).
1490 );
1491 
1492 //--------------------------------------------------------------------------------------------------
1493 /**
1494  * Set the power of the Radio Module.
1495  *
1496  * @return LE_BAD_PARAMETER Bad power mode specified.
1497  * @return LE_FAULT Function failed.
1498  * @return LE_OK Function succeed.
1499  *
1500  * @note <b>NOT multi-app safe</b>
1501  */
1502 //--------------------------------------------------------------------------------------------------
1504 (
1505  le_onoff_t power
1506  ///< [IN] The power state.
1507 );
1508 
1509 //--------------------------------------------------------------------------------------------------
1510 /**
1511  * Must be called to get the Radio Module power state.
1512  *
1513  * @return LE_FAULT The function failed to get the Radio Module power state.
1514  * @return LE_BAD_PARAMETER if powerPtr is NULL.
1515  * @return LE_OK The function succeed.
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 //--------------------------------------------------------------------------------------------------
1524 (
1525  le_onoff_t* powerPtr
1526  ///< [OUT] Power state.
1527 );
1528 
1529 //--------------------------------------------------------------------------------------------------
1530 /**
1531  * This function must be called to perform a cellular network scan.
1532  *
1533  * @return Reference to the List object. Null pointer if the scan failed.
1534  *
1535  * @note <b>multi-app safe</b>
1536  */
1537 //--------------------------------------------------------------------------------------------------
1538 le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan
1539 (
1540  le_mrc_RatBitMask_t ratMask
1541  ///< [IN] Radio Access Technology mask
1542 );
1543 
1544 //--------------------------------------------------------------------------------------------------
1545 /**
1546  * This function must be called to perform a PCI network scan.
1547  *
1548  * @return Reference to the List object. Null pointer if the scan failed.
1549  *
1550  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
1551  * details.
1552  *
1553  * @note <b>multi-app safe</b>
1554  */
1555 //--------------------------------------------------------------------------------------------------
1556 le_mrc_PciScanInformationListRef_t le_mrc_PerformPciNetworkScan
1557 (
1558  le_mrc_RatBitMask_t ratMask
1559  ///< [IN] Radio Access Technology mask
1560 );
1561 
1562 //--------------------------------------------------------------------------------------------------
1563 /**
1564  * This function must be called to perform a cellular network scan asynchronously. This function
1565  * is not blocking, the response will be returned with a handler function.
1566  *
1567  *@note <b>multi-app safe</b>
1568  *
1569  */
1570 //--------------------------------------------------------------------------------------------------
1572 (
1573  le_mrc_RatBitMask_t ratMask,
1574  ///< [IN] Radio Access Technology mask
1575  le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr,
1576  ///< [IN] handler for sending result.
1577  void* contextPtr
1578  ///< [IN]
1579 );
1580 
1581 //--------------------------------------------------------------------------------------------------
1582 /**
1583  * This function must be called to perform a PCI network scan asynchronously. This function
1584  * is not blocking, the response will be returned with a handler function.
1585  *
1586  * @warning PCI scan is platform dependent. Please refer to @ref platformConstraintsMdc for further
1587  * details.
1588  *
1589  *@note <b>multi-app safe</b>
1590  *
1591  */
1592 //--------------------------------------------------------------------------------------------------
1594 (
1595  le_mrc_RatBitMask_t ratMask,
1596  ///< [IN] Radio Access Technology mask
1597  le_mrc_PciNetworkScanHandlerFunc_t handlerPtr,
1598  ///< [IN] handler for sending result.
1599  void* contextPtr
1600  ///< [IN]
1601 );
1602 
1603 //--------------------------------------------------------------------------------------------------
1604 /**
1605  * This function must be called to get the first Scan Information object reference in the list of
1606  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
1607  *
1608  * @return NULL No scan information found.
1609  * @return le_mrc_ScanInformationRef_t The Scan Information object reference.
1610  *
1611  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1612  * function won't return.
1613  *
1614  * @note <b>multi-app safe</b>
1615  */
1616 //--------------------------------------------------------------------------------------------------
1617 le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan
1618 (
1619  le_mrc_ScanInformationListRef_t scanInformationListRef
1620  ///< [IN] The list of scan information.
1621 );
1622 
1623 //--------------------------------------------------------------------------------------------------
1624 /**
1625  * This function must be called to get the next Scan Information object reference in the list of
1626  * scan Information retrieved with le_mrc_PerformCellularNetworkScan().
1627  *
1628  * @return NULL No scan information found.
1629  * @return le_mrc_ScanInformationRef_t The Scan Information object reference.
1630  *
1631  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1632  * function won't return.
1633  *
1634  * @note <b>multi-app safe</b>
1635  */
1636 //--------------------------------------------------------------------------------------------------
1637 le_mrc_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan
1638 (
1639  le_mrc_ScanInformationListRef_t scanInformationListRef
1640  ///< [IN] The list of scan information.
1641 );
1642 
1643 //--------------------------------------------------------------------------------------------------
1644 /**
1645  * This function must be called to get the first Pci Scan Information object reference in the list of
1646  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
1647  *
1648  * @return NULL No scan information found.
1649  * @return The Scan Information object reference.
1650  *
1651  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1652  * function won't return.
1653  *
1654  * @note <b>multi-app safe</b>
1655  */
1656 //--------------------------------------------------------------------------------------------------
1657 le_mrc_PciScanInformationRef_t le_mrc_GetFirstPciScanInfo
1658 (
1659  le_mrc_PciScanInformationListRef_t scanInformationListRef
1660  ///< [IN] The list of scan information.
1661 );
1662 
1663 //--------------------------------------------------------------------------------------------------
1664 /**
1665  * This function must be called to get the next Scan Information object reference in the list of
1666  * scan Information retrieved with le_mrc_PerformPciNetworkScan().
1667  *
1668  * @return NULL No scan information found.
1669  * @return The Scan Information object reference.
1670  *
1671  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1672  * function won't return.
1673  *
1674  * @note <b>multi-app safe</b>
1675  */
1676 //--------------------------------------------------------------------------------------------------
1677 le_mrc_PciScanInformationRef_t le_mrc_GetNextPciScanInfo
1678 (
1679  le_mrc_PciScanInformationListRef_t scanInformationListRef
1680  ///< [IN] The list of scan information.
1681 );
1682 
1683 //--------------------------------------------------------------------------------------------------
1684 /**
1685  * This function must be called to get the first Plmn Information object reference in the list of
1686  * Plmn on each cell.
1687  *
1688  * @return NULL No scan information found.
1689  * @return le_mrc_PlmnInformationRef_t The Plmn Information object reference.
1690  *
1691  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1692  * function won't return.
1693  *
1694  */
1695 //--------------------------------------------------------------------------------------------------
1696 le_mrc_PlmnInformationRef_t le_mrc_GetFirstPlmnInfo
1697 (
1698  le_mrc_PciScanInformationRef_t pciScanInformationRef
1699  ///< [IN] [IN] The reference to the cell information.
1700 );
1701 
1702 //--------------------------------------------------------------------------------------------------
1703 /**
1704  * This function must be called to get the next Plmn Information object reference in the list of
1705  * Plmn on each cell.
1706  *
1707  * @return NULL No scan information found.
1708  * @return le_mrc_PlmnInformationRef_t The Plmn Information object reference.
1709  *
1710  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1711  * function won't return.
1712  *
1713  */
1714 //--------------------------------------------------------------------------------------------------
1715 le_mrc_PlmnInformationRef_t le_mrc_GetNextPlmnInfo
1716 (
1717  le_mrc_PciScanInformationRef_t plmnRef
1718  ///< [IN] [IN] The reference to the cell information.
1719 );
1720 
1721 //--------------------------------------------------------------------------------------------------
1722 /**
1723  * This function must be called to get the physical cell id referenced by PciScanInformation which
1724  * is returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
1725  *
1726  * @return The Physical Cell Identifier.
1727  *
1728  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1729  * function won't return.
1730  */
1731 //--------------------------------------------------------------------------------------------------
1732 uint16_t le_mrc_GetPciScanCellId
1733 (
1734  le_mrc_PciScanInformationRef_t pciScanInformationRef
1735  ///< [IN] [IN] The reference to the cell information.
1736 );
1737 
1738 //--------------------------------------------------------------------------------------------------
1739 /**
1740  * This function must be called to get the global cell id referenced by PciScanInformation which is
1741  * returned by le_mrc_GetFirstPciScanInfo() and le_mrc_GetNextPciScanInfo().
1742  *
1743  * @return The Global Cell Identifier.
1744  *
1745  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1746  * function won't return.
1747  */
1748 //--------------------------------------------------------------------------------------------------
1750 (
1751  le_mrc_PciScanInformationRef_t pciScanInformationRef
1752  ///< [IN] [IN] The reference to the cell information.
1753 );
1754 
1755 //--------------------------------------------------------------------------------------------------
1756 /**
1757  * This function must be called to get the Mcc/Mnc of each PLMN referenced in the list of
1758  * Plmn Information retrieved with le_mrc_GetFirstPlmnInfo() and le_mrc_GetNextPlmnInfo().
1759  *
1760  * @return
1761  * - LE_OK on success
1762  * - LE_OVERFLOW if the MCC or MNC would not fit in buffer
1763  * - LE_FAULT for all other errors
1764  *
1765  *
1766  */
1767 //--------------------------------------------------------------------------------------------------
1769 (
1770  le_mrc_PlmnInformationRef_t plmnRef,
1771  ///< [IN] [IN] The reference to the cell information.
1772  char* mccPtr,
1773  ///< [OUT] Mobile Country Code
1774  size_t mccPtrSize,
1775  ///< [IN]
1776  char* mncPtr,
1777  ///< [OUT] Mobile Network Code
1778  size_t mncPtrSize
1779  ///< [IN]
1780 );
1781 
1782 //--------------------------------------------------------------------------------------------------
1783 /**
1784  * This function must be called to delete the list of the Scan Information retrieved with
1785  * le_mrc_PerformCellularNetworkScan().
1786  *
1787  * @note
1788  * On failure, the process exits, so you don't have to worry about checking the returned
1789  * reference for validity.
1790  *
1791  * @note <b>multi-app safe</b>
1792  */
1793 //--------------------------------------------------------------------------------------------------
1795 (
1796  le_mrc_ScanInformationListRef_t scanInformationListRef
1797  ///< [IN] The list of scan information.
1798 );
1799 
1800 //--------------------------------------------------------------------------------------------------
1801 /**
1802  * This function must be called to delete the list of the Pci Scan Information retrieved with
1803  * le_mrc_PerformPciNetworkScan().
1804  *
1805  * @note
1806  * On failure, the process exits, so you don't have to worry about checking the returned
1807  * reference for validity.
1808  *
1809  */
1810 //--------------------------------------------------------------------------------------------------
1812 (
1813  le_mrc_PciScanInformationListRef_t scanInformationListRef
1814  ///< [IN] The list of scan information.
1815 );
1816 
1817 //--------------------------------------------------------------------------------------------------
1818 /**
1819  * This function must be called to get the Cellular Network Code [mcc:mnc]
1820  *
1821  * @return
1822  * - LE_OK on success
1823  * - LE_OVERFLOW if the MCC or MNC would not fit in buffer
1824  * - LE_FAULT for all other errors
1825  *
1826  * @note On failure, the process exits, so you don't have to worry about checking the returned
1827  * reference for validity.
1828  *
1829  * @note <b>multi-app safe</b>
1830  */
1831 //--------------------------------------------------------------------------------------------------
1833 (
1834  le_mrc_ScanInformationRef_t scanInformationRef,
1835  ///< [IN] Scan information reference
1836  char* mccPtr,
1837  ///< [OUT] Mobile Country Code
1838  size_t mccPtrSize,
1839  ///< [IN]
1840  char* mncPtr,
1841  ///< [OUT] Mobile Network Code
1842  size_t mncPtrSize
1843  ///< [IN]
1844 );
1845 
1846 //--------------------------------------------------------------------------------------------------
1847 /**
1848  * This function must be called to get the Cellular Network Name.
1849  *
1850  * @return
1851  * - LE_OK on success
1852  * - LE_OVERFLOW if the operator name would not fit in buffer
1853  * - LE_FAULT for all other errors
1854  *
1855  * @note On failure, the process exits, so you don't have to worry about checking the returned
1856  * reference for validity.
1857  *
1858  * @note <b>multi-app safe</b>
1859  */
1860 //--------------------------------------------------------------------------------------------------
1862 (
1863  le_mrc_ScanInformationRef_t scanInformationRef,
1864  ///< [IN] Scan information reference
1865  char* namePtr,
1866  ///< [OUT] Name of operator
1867  size_t namePtrSize
1868  ///< [IN]
1869 );
1870 
1871 //--------------------------------------------------------------------------------------------------
1872 /**
1873  * This function must be called to get the radio access technology of a scanInformationRef.
1874  *
1875  * @return the radio access technology
1876  *
1877  * @note On failure, the process exits.
1878  *
1879  * @note <b>multi-app safe</b>
1880  */
1881 //--------------------------------------------------------------------------------------------------
1882 le_mrc_Rat_t le_mrc_GetCellularNetworkRat
1883 (
1884  le_mrc_ScanInformationRef_t scanInformationRef
1885  ///< [IN] Scan information reference
1886 );
1887 
1888 //--------------------------------------------------------------------------------------------------
1889 /**
1890  * This function must be called to check if a cellular network is currently in use.
1891  *
1892  * @return true The network is in use
1893  * @return false The network isn't in use
1894  *
1895  * @note On failure, the process exits, so you don't have to worry about checking the returned
1896  * reference for validity.
1897  *
1898  * @note <b>multi-app safe</b>
1899  */
1900 //--------------------------------------------------------------------------------------------------
1902 (
1903  le_mrc_ScanInformationRef_t scanInformationRef
1904  ///< [IN] Scan information reference
1905 );
1906 
1907 //--------------------------------------------------------------------------------------------------
1908 /**
1909  * This function must be called to check if a cellular network is available.
1910  *
1911  * @return true The network is available
1912  * @return false The network isn't available
1913  *
1914  * @note On failure, the process exits, so you don't have to worry about checking the returned
1915  * reference for validity.
1916  *
1917  * @note <b>multi-app safe</b>
1918  */
1919 //--------------------------------------------------------------------------------------------------
1921 (
1922  le_mrc_ScanInformationRef_t scanInformationRef
1923  ///< [IN] Scan information reference
1924 );
1925 
1926 //--------------------------------------------------------------------------------------------------
1927 /**
1928  * This function must be called to check if a cellular network is currently in home mode.
1929  *
1930  * @return true The network is home
1931  * @return false The network is roaming
1932  *
1933  * @note On failure, the process exits, so you don't have to worry about checking the returned
1934  * reference for validity.
1935  *
1936  * @note <b>multi-app safe</b>
1937  */
1938 //--------------------------------------------------------------------------------------------------
1940 (
1941  le_mrc_ScanInformationRef_t scanInformationRef
1942  ///< [IN] Scan information reference
1943 );
1944 
1945 //--------------------------------------------------------------------------------------------------
1946 /**
1947  * This function must be called to check if a cellular network is forbidden by the operator.
1948  *
1949  * @return true The network is forbidden
1950  * @return false The network is allowed
1951  *
1952  * @note On failure, the process exits, so you don't have to worry about checking the returned
1953  * reference for validity.
1954  *
1955  * @note <b>multi-app safe</b>
1956  */
1957 //--------------------------------------------------------------------------------------------------
1959 (
1960  le_mrc_ScanInformationRef_t scanInformationRef
1961  ///< [IN] Scan information reference
1962 );
1963 
1964 //--------------------------------------------------------------------------------------------------
1965 /**
1966  * This function must be called to get the current network name information.
1967  *
1968  * @return
1969  * - LE_OK on success
1970  * - LE_BAD_PARAMETER if nameStr is NULL
1971  * - LE_OVERFLOW if the Home Network Name can't fit in nameStr
1972  * - LE_FAULT on any other failure
1973  *
1974  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
1975  * function won't return.
1976  *
1977  * @note <b>multi-app safe</b>
1978  */
1979 //--------------------------------------------------------------------------------------------------
1981 (
1982  char* nameStr,
1983  ///< [OUT] the home network Name
1984  size_t nameStrSize
1985  ///< [IN]
1986 );
1987 
1988 //--------------------------------------------------------------------------------------------------
1989 /**
1990  * This function must be called to get the current network PLMN information.
1991  *
1992  * @return
1993  * - LE_OK on success
1994  * - LE_FAULT on any other failure
1995  *
1996  * @note <b>multi-app safe</b>
1997  */
1998 //--------------------------------------------------------------------------------------------------
2000 (
2001  char* mccStr,
2002  ///< [OUT] the mobile country code
2003  size_t mccStrSize,
2004  ///< [IN]
2005  char* mncStr,
2006  ///< [OUT] the mobile network code
2007  size_t mncStrSize
2008  ///< [IN]
2009 );
2010 
2011 //--------------------------------------------------------------------------------------------------
2012 /**
2013  * This function must be called to get the current Radio Access Technology in use.
2014  *
2015  * @return LE_OK Function succeeded.
2016  * @return LE_BAD_PARAMETER Invalid parameter.
2017  * @return LE_FAULT Function failed to get the Radio Access Technology.
2018  *
2019  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2020  * function won't return.
2021  *
2022  * @note The API returns the RAT only if the device is registered on the network.
2023  * le_mrc_GetNetRegState() function can be called first to obtain the network registration
2024  * state.
2025  *
2026  * @note <b>multi-app safe</b>
2027  */
2028 //--------------------------------------------------------------------------------------------------
2030 (
2031  le_mrc_Rat_t* ratPtr
2032  ///< [OUT] The Radio Access Technology.
2033 );
2034 
2035 //--------------------------------------------------------------------------------------------------
2036 /**
2037  * This function must be called to retrieve the Neighboring Cells information. It creates and
2038  * returns a reference to the Neighboring Cells information.
2039  *
2040  * @return A reference to the Neighboring Cells information.
2041  * @return NULL if no Cells Information are available.
2042  *
2043  * @note <b>multi-app safe</b>
2044  */
2045 //--------------------------------------------------------------------------------------------------
2046 le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo
2047 (
2048  void
2049 );
2050 
2051 //--------------------------------------------------------------------------------------------------
2052 /**
2053  * This function must be called to delete the Neighboring Cells information.
2054  *
2055  * @note On failure, the process exits, so you don't have to worry about checking the returned
2056  * reference for validity.
2057  *
2058  * @note <b>multi-app safe</b>
2059  */
2060 //--------------------------------------------------------------------------------------------------
2062 (
2063  le_mrc_NeighborCellsRef_t ngbrCellsRef
2064  ///< [IN] Neighboring Cells reference.
2065 );
2066 
2067 //--------------------------------------------------------------------------------------------------
2068 /**
2069  * This function must be called to get the first Cell Information reference in the list of
2070  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
2071  *
2072  * @return NULL No Cell information object found.
2073  * @return le_mrc_CellInfoRef_t The Cell information object reference.
2074  *
2075  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2076  * function won't return.
2077  *
2078  * @note <b>multi-app safe</b>
2079  */
2080 //--------------------------------------------------------------------------------------------------
2081 le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo
2082 (
2083  le_mrc_NeighborCellsRef_t ngbrCellsRef
2084  ///< [IN] Neighboring Cells reference.
2085 );
2086 
2087 //--------------------------------------------------------------------------------------------------
2088 /**
2089  * This function must be called to get the next Cell Information reference in the list of
2090  * Neighboring Cells information retrieved with le_mrc_GetNeighborCellsInfo().
2091  *
2092  * @return NULL No Cell information object found.
2093  * @return le_mrc_CellInfoRef_t Cell information object reference.
2094  *
2095  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2096  * function won't return.
2097  *
2098  * @note <b>multi-app safe</b>
2099  */
2100 //--------------------------------------------------------------------------------------------------
2101 le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo
2102 (
2103  le_mrc_NeighborCellsRef_t ngbrCellsRef
2104  ///< [IN] Neighboring Cells reference.
2105 );
2106 
2107 //--------------------------------------------------------------------------------------------------
2108 /**
2109  * This function must be called to get the Physical Cell Identifier.
2110  *
2111  * @return The Physical Cell Identifier. UINT32_MAX value is returned if the Cell Identifier is not
2112  * available.
2113  *
2114  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2115  * function won't return.
2116  *
2117  * @note <b>multi-app safe</b>
2118  */
2119 //--------------------------------------------------------------------------------------------------
2120 uint32_t le_mrc_GetNeighborCellId
2121 (
2122  le_mrc_CellInfoRef_t ngbrCellInfoRef
2123  ///< [IN] Cell information reference.
2124 );
2125 
2126 //--------------------------------------------------------------------------------------------------
2127 /**
2128  * This function must be called to get the Location Area Code of a cell.
2129  *
2130  * @return The Location Area Code of a cell. UINT16_MAX value is returned if the value is not
2131  * available.
2132  *
2133  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2134  * function won't return.
2135  *
2136  * @note <b>multi-app safe</b>
2137  */
2138 //--------------------------------------------------------------------------------------------------
2140 (
2141  le_mrc_CellInfoRef_t ngbrCellInfoRef
2142  ///< [IN] Cell information reference.
2143 );
2144 
2145 //--------------------------------------------------------------------------------------------------
2146 /**
2147  * This function must be called to get the signal strength of a cell.
2148  *
2149  * @return The signal strength of a cell in dBm.
2150  *
2151  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2152  * function won't return.
2153  *
2154  * @note <b>multi-app safe</b>
2155  */
2156 //--------------------------------------------------------------------------------------------------
2158 (
2159  le_mrc_CellInfoRef_t ngbrCellInfoRef
2160  ///< [IN] Cell information reference.
2161 );
2162 
2163 //--------------------------------------------------------------------------------------------------
2164 /**
2165  * This function must be called to get the Radio Access Technology of a cell.
2166  *
2167  * @return The Radio Access Technology of a cell.
2168  *
2169  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2170  * function won't return.
2171  *
2172  * @note <b>multi-app safe</b>
2173  */
2174 //--------------------------------------------------------------------------------------------------
2175 le_mrc_Rat_t le_mrc_GetNeighborCellRat
2176 (
2177  le_mrc_CellInfoRef_t ngbrCellInfoRef
2178  ///< [IN] Cell information reference.
2179 );
2180 
2181 //--------------------------------------------------------------------------------------------------
2182 /**
2183  * This function must be called to get the Ec/Io; the received energy per chip divided by the power
2184  * density in the band measured in dBm on the primary CPICH channel of serving cell (negative value)
2185  *
2186  * @return
2187  * - The Ec/Io of a cell given in dB with 1 decimal place. (only applicable for UMTS network).
2188  * - INT32_MAX when the value isn't available.
2189  *
2190  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2191  * function won't return.
2192  *
2193  * @note <b>multi-app safe</b>
2194  */
2195 //--------------------------------------------------------------------------------------------------
2197 (
2198  le_mrc_CellInfoRef_t ngbrCellInfoRef
2199  ///< [IN] Cell information reference.
2200 );
2201 
2202 //--------------------------------------------------------------------------------------------------
2203 /**
2204  * This function must be called to get the RSRP and RSRQ of the Intrafrequency of a LTE cell.
2205  *
2206  * @return
2207  * - LE_OK on success
2208  * - LE_FAULT on failure
2209  *
2210  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2211  * function won't return.
2212  *
2213  * @note <b>multi-app safe</b>
2214  */
2215 //--------------------------------------------------------------------------------------------------
2217 (
2218  le_mrc_CellInfoRef_t ngbrCellInfoRef,
2219  ///< [IN] Cell information reference.
2220  int32_t* rsrqPtr,
2221  ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
2222  ///< place
2223  int32_t* rsrpPtr
2224  ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
2225  ///< place
2226 );
2227 
2228 //--------------------------------------------------------------------------------------------------
2229 /**
2230  * This function must be called to get the RSRP and RSRQ of the Interfrequency of a LTE cell.
2231  *
2232  * @return
2233  * - LE_OK on success
2234  * - LE_FAULT on failure
2235  *
2236  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2237  * function won't return.
2238  *
2239  * @note <b>multi-app safe</b>
2240  */
2241 //--------------------------------------------------------------------------------------------------
2243 (
2244  le_mrc_CellInfoRef_t ngbrCellInfoRef,
2245  ///< [IN] Cell information reference.
2246  int32_t* rsrqPtr,
2247  ///< [OUT] Reference Signal Received Quality value in dB with 1 decimal
2248  ///< place
2249  int32_t* rsrpPtr
2250  ///< [OUT] Reference Signal Receiver Power value in dBm with 1 decimal
2251  ///< place
2252 );
2253 
2254 //--------------------------------------------------------------------------------------------------
2255 /**
2256  * This function must be called to measure the signal metrics. It creates and returns a reference
2257  * to the signal metrics.
2258  *
2259  * @return A reference to the signal metrics.
2260  * @return NULL if no signal metrics are available.
2261  *
2262  * @note <b>multi-app safe</b>
2263  */
2264 //--------------------------------------------------------------------------------------------------
2265 le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics
2266 (
2267  void
2268 );
2269 
2270 //--------------------------------------------------------------------------------------------------
2271 /**
2272  * This function must be called to delete the the signal metrics.
2273  *
2274  * @note On failure, the process exits, so you don't have to worry about checking the returned
2275  * reference for validity.
2276  *
2277  * @note <b>multi-app safe</b>
2278  */
2279 //--------------------------------------------------------------------------------------------------
2281 (
2282  le_mrc_MetricsRef_t MetricsRef
2283  ///< [IN] Signal metrics reference.
2284 );
2285 
2286 //--------------------------------------------------------------------------------------------------
2287 /**
2288  * This function returns the Radio Access Technology of the signal metrics.
2289  *
2290  * @return The Radio Access Technology of the signal measure.
2291  *
2292  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2293  * function won't return.
2294  *
2295  * @note <b>multi-app safe</b>
2296  */
2297 //--------------------------------------------------------------------------------------------------
2298 le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics
2299 (
2300  le_mrc_MetricsRef_t MetricsRef
2301  ///< [IN] Signal metrics reference.
2302 );
2303 
2304 //--------------------------------------------------------------------------------------------------
2305 /**
2306  * This function returns the signal strength in dBm and the bit error rate measured on GSM network.
2307  *
2308  * @return
2309  * - LE_OK on success
2310  * - LE_FAULT on failure
2311  *
2312  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2313  * function won't return.
2314  *
2315  * @note <b>multi-app safe</b>
2316  */
2317 //--------------------------------------------------------------------------------------------------
2319 (
2320  le_mrc_MetricsRef_t MetricsRef,
2321  ///< [IN] Signal metrics reference.
2322  int32_t* rssiPtr,
2323  ///< [OUT] Signal strength in dBm
2324  uint32_t* berPtr
2325  ///< [OUT] Bit error rate.
2326 );
2327 
2328 //--------------------------------------------------------------------------------------------------
2329 /**
2330  * This function returns the signal metrics measured on UMTS or TD-SCDMA networks.
2331  *
2332  * @return
2333  * - LE_OK on success
2334  * - LE_FAULT on failure
2335  *
2336  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2337  * function won't return.
2338  *
2339  * @note <b>multi-app safe</b>
2340  */
2341 //--------------------------------------------------------------------------------------------------
2343 (
2344  le_mrc_MetricsRef_t MetricsRef,
2345  ///< [IN] Signal metrics reference.
2346  int32_t* ssPtr,
2347  ///< [OUT] Signal strength in dBm
2348  uint32_t* blerPtr,
2349  ///< [OUT] Block error rate
2350  int32_t* ecioPtr,
2351  ///< [OUT] Ec/Io value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
2352  ///< value)
2353  int32_t* rscpPtr,
2354  ///< [OUT] Measured RSCP in dBm (negative value, value INT32_MAX means
2355  ///< that RSCP is not available)
2356  int32_t* sinrPtr
2357  ///< [OUT] Measured SINR in dB (only applicable for TD-SCDMA network, value
2358  ///< INT32_MAX means that the SINR is not available)
2359 );
2360 
2361 //--------------------------------------------------------------------------------------------------
2362 /**
2363  * This function returns the signal metrics measured on LTE network.
2364  *
2365  * @return
2366  * - LE_OK on success
2367  * - LE_FAULT on failure
2368  * - sinrPtr and ioPtr return INT32_MAX when the value isn't available.
2369  *
2370  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2371  * function won't return.
2372  *
2373  * @note <b>multi-app safe</b>
2374  */
2375 //--------------------------------------------------------------------------------------------------
2377 (
2378  le_mrc_MetricsRef_t MetricsRef,
2379  ///< [IN] Signal metrics reference.
2380  int32_t* ssPtr,
2381  ///< [OUT] Signal strength in dBm
2382  uint32_t* blerPtr,
2383  ///< [OUT] Block error rate
2384  int32_t* rsrqPtr,
2385  ///< [OUT] RSRQ value in dB as measured by L1 with 1 decimal place
2386  int32_t* rsrpPtr,
2387  ///< [OUT] Current RSRP in dBm as measured by L1 with 1 decimal place
2388  int32_t* snrPtr
2389  ///< [OUT] SNR level in dB with 1 decimal place (15 = 1.5 dB)
2390 );
2391 
2392 //--------------------------------------------------------------------------------------------------
2393 /**
2394  * This function returns the signal metrics measured on CDMA network.
2395  *
2396  * @return
2397  * - LE_OK on success
2398  * - LE_FAULT on failure
2399  * - rscpPtr and sinrPtr return INT32_MAX when the value isn't available.
2400  *
2401  * @note If the caller is passing a bad pointer into this function, it's a fatal error, the
2402  * function won't return.
2403  *
2404  * @note <b>multi-app safe</b>
2405  */
2406 //--------------------------------------------------------------------------------------------------
2408 (
2409  le_mrc_MetricsRef_t MetricsRef,
2410  ///< [IN] Signal metrics reference.
2411  int32_t* ssPtr,
2412  ///< [OUT] Signal strength in dBm
2413  uint32_t* erPtr,
2414  ///< [OUT] Frame/Packet error rate
2415  int32_t* ecioPtr,
2416  ///< [OUT] ECIO value in dB with 1 decimal place (-15 = -1.5 dB) (Negative
2417  ///< value)
2418  int32_t* sinrPtr,
2419  ///< [OUT] SINR level in dB with 1 decimal place, (only applicable for
2420  ///< 1xEV-DO, value INT32_MAX means that the value is not available)
2421  int32_t* ioPtr
2422  ///< [OUT] Received IO in dBm (only applicable for 1xEV-DO, value INT32_MAX
2423  ///< means that the value is not available)
2424 );
2425 
2426 //--------------------------------------------------------------------------------------------------
2427 /**
2428  * This function must be called to get the serving Cell Identifier.
2429  *
2430  * @return The Cell Identifier. UINT32_MAX value is returned if the value is not available.
2431  *
2432  * @note When the module is in UMTS network, the API returns the serving UTRAN Cell Identity (UC-Id)
2433  * which is used to identify the cell uniquely.
2434  * It is composed of the Controlling Radio Network Controller Identifier (CRNC-Id, 12 bits) and the
2435  * Cell Identifier (C-Id, 16 bits). (3GPP 25.401, section 6.1.5)
2436  * The Cell Identifier is coded in the lower 2 bytes of the 4 bytes UC-Id and the CRNC-Id is coded
2437  * in the upper 2 bytes.
2438  * Example: the API returns 7807609 -> 0x772279 (CRNC-Id = 0x77 , cell ID = 0x2279)
2439  *
2440  * @note <b>multi-app safe</b>
2441  */
2442 //--------------------------------------------------------------------------------------------------
2443 uint32_t le_mrc_GetServingCellId
2444 (
2445  void
2446 );
2447 
2448 //--------------------------------------------------------------------------------------------------
2449 /**
2450  * This function must be called to get the Location Area Code of the serving cell.
2451  *
2452  * @return The Location Area Code. UINT32_MAX value is returned if the value is not available.
2453  *
2454  * @note <b>multi-app safe</b>
2455  */
2456 //--------------------------------------------------------------------------------------------------
2458 (
2459  void
2460 );
2461 
2462 //--------------------------------------------------------------------------------------------------
2463 /**
2464  * This function must be called to get the Tracking Area Code of the serving cell (LTE only).
2465  *
2466  * @return The Tracking Area Code. UINT16_MAX value is returned if the value is not available.
2467  *
2468  * @note <b>multi-app safe</b>
2469  */
2470 //--------------------------------------------------------------------------------------------------
2472 (
2473  void
2474 );
2475 
2476 //--------------------------------------------------------------------------------------------------
2477 /**
2478  * Get the Bit mask for 2G/3G Band capabilities.
2479  *
2480  * @return
2481  * - LE_OK on success
2482  * - LE_FAULT on failure
2483  * - LE_UNSUPPORTED Unable to get the 2G/3G Band capabilities on this platform
2484  *
2485  * @note <b>multi-app safe</b>
2486  */
2487 //--------------------------------------------------------------------------------------------------
2489 (
2490  le_mrc_BandBitMask_t* bandMaskPtrPtr
2491  ///< [OUT] Bit mask for 2G/3G Band capabilities.
2492 );
2493 
2494 //--------------------------------------------------------------------------------------------------
2495 /**
2496  * Get the Bit mask for LTE Band capabilities.
2497  *
2498  * @return
2499  * - LE_OK on success
2500  * - LE_FAULT on failure
2501  * - LE_UNSUPPORTED Unable to get the LTE Band capabilities on this platform
2502  *
2503  * @note <b>multi-app safe</b>
2504  */
2505 //--------------------------------------------------------------------------------------------------
2507 (
2508  le_mrc_LteBandBitMask_t* bandMaskPtrPtr
2509  ///< [OUT] Bit mask for LTE Band capabilities.
2510 );
2511 
2512 //--------------------------------------------------------------------------------------------------
2513 /**
2514  * Get the Bit mask for TD-SCDMA Band capabilities.
2515  *
2516  * @return
2517  * - LE_OK on success
2518  * - LE_FAULT on failure
2519  * - LE_UNSUPPORTED Unable to get the TD-SCDMA Band Capabilities on this platform
2520  *
2521  * @note <b>multi-app safe</b>
2522  */
2523 //--------------------------------------------------------------------------------------------------
2525 (
2526  le_mrc_TdScdmaBandBitMask_t* bandMaskPtrPtr
2527  ///< [OUT] Bit mask for TD-SCDMA Band capabilities.
2528 );
2529 
2530 //--------------------------------------------------------------------------------------------------
2531 /**
2532  * Add handler function for EVENT 'le_mrc_NetworkReject'
2533  *
2534  * Event to report network reject indication.
2535  *
2536  */
2537 //--------------------------------------------------------------------------------------------------
2538 le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler
2539 (
2540  le_mrc_NetworkRejectHandlerFunc_t handlerPtr,
2541  ///< [IN]
2542  void* contextPtr
2543  ///< [IN]
2544 );
2545 
2546 //--------------------------------------------------------------------------------------------------
2547 /**
2548  * Remove handler function for EVENT 'le_mrc_NetworkReject'
2549  */
2550 //--------------------------------------------------------------------------------------------------
2552 (
2553  le_mrc_NetworkRejectHandlerRef_t handlerRef
2554  ///< [IN]
2555 );
2556 
2557 //--------------------------------------------------------------------------------------------------
2558 /**
2559  * Add handler function for EVENT 'le_mrc_NetRegReject'
2560  *
2561  * Event to report network registration reject indication.
2562  * NetworkReject will be deprecated.
2563  */
2564 //--------------------------------------------------------------------------------------------------
2565 le_mrc_NetRegRejectHandlerRef_t le_mrc_AddNetRegRejectHandler
2566 (
2567  le_mrc_NetRegRejectHandlerFunc_t handlerPtr,
2568  ///< [IN]
2569  void* contextPtr
2570  ///< [IN]
2571 );
2572 
2573 //--------------------------------------------------------------------------------------------------
2574 /**
2575  * Remove handler function for EVENT 'le_mrc_NetRegReject'
2576  */
2577 //--------------------------------------------------------------------------------------------------
2579 (
2580  le_mrc_NetRegRejectHandlerRef_t handlerRef
2581  ///< [IN]
2582 );
2583 
2584 //--------------------------------------------------------------------------------------------------
2585 /**
2586  * Add handler function for EVENT 'le_mrc_JammingDetectionEvent'
2587  *
2588  * This event provides information on jamming detection.
2589  */
2590 //--------------------------------------------------------------------------------------------------
2591 le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler
2592 (
2593  le_mrc_JammingDetectionHandlerFunc_t handlerPtr,
2594  ///< [IN]
2595  void* contextPtr
2596  ///< [IN]
2597 );
2598 
2599 //--------------------------------------------------------------------------------------------------
2600 /**
2601  * Remove handler function for EVENT 'le_mrc_JammingDetectionEvent'
2602  */
2603 //--------------------------------------------------------------------------------------------------
2605 (
2606  le_mrc_JammingDetectionEventHandlerRef_t handlerRef
2607  ///< [IN]
2608 );
2609 
2610 //--------------------------------------------------------------------------------------------------
2611 /**
2612  * Start the jamming detection monitoring.
2613  *
2614  * @warning The jamming detection feature might be limited by the platform.
2615  * Please refer to the platform documentation @ref platformConstraintsMdc.
2616  *
2617  * @return
2618  * - LE_OK The function succeeded.
2619  * - LE_FAULT The function failed.
2620  * - LE_DUPLICATE The feature is already activated and an activation is requested.
2621  * - LE_UNSUPPORTED The feature is not supported.
2622  */
2623 //--------------------------------------------------------------------------------------------------
2625 (
2626  void
2627 );
2628 
2629 //--------------------------------------------------------------------------------------------------
2630 /**
2631  * Stop the jamming detection monitoring.
2632  *
2633  * @return
2634  * - LE_OK The function succeeded.
2635  * - LE_FAULT The function failed or the application did not start the jamming detection.
2636  * - LE_UNSUPPORTED The feature is not supported.
2637  */
2638 //--------------------------------------------------------------------------------------------------
2640 (
2641  void
2642 );
2643 
2644 //--------------------------------------------------------------------------------------------------
2645 /**
2646  * Set the SAR backoff state
2647  *
2648  * @warning The SAR backoff feature might be unsupported by some platforms.
2649  * Please refer to the platform documentation @ref platformConstraintsMdc.
2650  *
2651  * @return
2652  * - LE_OK The function succeeded.
2653  * - LE_FAULT The function failed.
2654  * - LE_UNSUPPORTED The feature is not supported.
2655  * - LE_OUT_OF_RANGE The provided index is out of range.
2656  */
2657 //--------------------------------------------------------------------------------------------------
2659 (
2660  uint8_t state
2661  ///< [IN] New state to enable. By default, SAR is disabled (state = 0).
2662  ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
2663 );
2664 
2665 //--------------------------------------------------------------------------------------------------
2666 /**
2667  * Get the SAR backoff state
2668  *
2669  * @warning The SAR backoff feature might be unsupported by some platforms.
2670  * Please refer to the platform documentation @ref platformConstraintsMdc.
2671  *
2672  * @return
2673  * - LE_OK The function succeeded.
2674  * - LE_FAULT The function failed.
2675  * - LE_UNSUPPORTED The feature is not supported.
2676  */
2677 //--------------------------------------------------------------------------------------------------
2679 (
2680  uint8_t* statePtr
2681  ///< [OUT] Current state. By default, SAR is disabled (state = 0).
2682  ///< Refer to @ref platformConstraitsMdc for the number of maximum states.
2683 );
2684 
2685 #endif // LE_MRC_INTERFACE_H_INCLUDE_GUARD
le_result_t le_mrc_GetLteBandCapabilities(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
uint32_t le_mrc_GetNeighborCellId(le_mrc_CellInfoRef_t ngbrCellInfoRef)
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_result_t le_mrc_GetGsmSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *rssiPtr, uint32_t *berPtr)
le_result_t le_mrc_GetSignalQual(uint32_t *qualityPtr)
uint16_t le_mrc_GetServingCellLteTracAreaCode(void)
void le_mrc_DeleteNeighborCellsInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
le_mrc_CellInfoRef_t le_mrc_GetNextNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
void le_mrc_RemovePacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerRef_t handlerRef)
le_result_t le_mrc_GetNetRegState(le_mrc_NetRegState_t *statePtr)
le_mrc_RatChangeHandlerRef_t le_mrc_AddRatChangeHandler(le_mrc_RatChangeHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_mrc_SetAutomaticRegisterMode(void)
le_result_t le_mrc_SetSignalStrengthIndThresholds(le_mrc_Rat_t rat, int32_t lowerRangeThreshold, int32_t upperRangeThreshold)
le_result_t le_mrc_RemovePreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
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_result_t le_mrc_GetRadioPower(le_onoff_t *powerPtr)
uint32_t le_mrc_GetServingCellId(void)
le_mrc_NetRegStateEventHandlerRef_t le_mrc_AddNetRegStateEventHandler(le_mrc_NetRegStateHandlerFunc_t handlerPtr, void *contextPtr)
void(* le_mrc_DisconnectHandler_t)(void *)
Definition: le_mrc_interface.h:505
le_result_t
Definition: le_basics.h:35
le_result_t le_mrc_SetRadioPower(le_onoff_t power)
le_mrc_PlmnInformationRef_t le_mrc_GetFirstPlmnInfo(le_mrc_PciScanInformationRef_t pciScanInformationRef)
le_result_t le_mrc_GetCurrentNetworkMccMnc(char *mccStr, size_t mccStrSize, char *mncStr, size_t mncStrSize)
le_result_t le_mrc_SetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t bandMask)
le_result_t le_mrc_GetPacketSwitchedState(le_mrc_NetRegState_t *statePtr)
le_mrc_Rat_t le_mrc_GetRatOfSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_result_t le_mrc_GetTdScdmaBandPreferences(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
void le_mrc_DeleteSignalMetrics(le_mrc_MetricsRef_t MetricsRef)
le_mrc_CellInfoRef_t le_mrc_GetFirstNeighborCellInfo(le_mrc_NeighborCellsRef_t ngbrCellsRef)
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_result_t le_mrc_SetManualRegisterMode(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc)
le_result_t le_mrc_GetNeighborCellLteIntraFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
le_mrc_PlmnInformationRef_t le_mrc_GetNextPlmnInfo(le_mrc_PciScanInformationRef_t plmnRef)
le_result_t le_mrc_TryConnectService(void)
le_mrc_NetRegRejectHandlerRef_t le_mrc_AddNetRegRejectHandler(le_mrc_NetRegRejectHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_mrc_SetSignalStrengthIndDelta(le_mrc_Rat_t rat, uint16_t delta)
le_result_t le_mrc_GetRatPreferences(le_mrc_RatBitMask_t *ratMaskPtrPtr)
le_mrc_ScanInformationListRef_t le_mrc_PerformCellularNetworkScan(le_mrc_RatBitMask_t ratMask)
le_result_t le_mrc_SetBandPreferences(le_mrc_BandBitMask_t bandMask)
le_result_t le_mrc_SetRatPreferences(le_mrc_RatBitMask_t ratMask)
void le_mrc_DeleteCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
int32_t le_mrc_GetNeighborCellRxLevel(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_PacketSwitchedChangeHandlerRef_t le_mrc_AddPacketSwitchedChangeHandler(le_mrc_PacketSwitchedChangeHandlerFunc_t packetHandlerPtr, void *contextPtr)
le_result_t le_mrc_GetNeighborCellLteInterFreq(le_mrc_CellInfoRef_t ngbrCellInfoRef, int32_t *rsrqPtr, int32_t *rsrpPtr)
void le_mrc_RemoveSignalStrengthChangeHandler(le_mrc_SignalStrengthChangeHandlerRef_t handlerRef)
le_result_t le_mrc_SetSarBackoffState(uint8_t state)
le_mrc_NeighborCellsRef_t le_mrc_GetNeighborCellsInfo(void)
le_result_t le_mrc_GetPciScanMccMnc(le_mrc_PlmnInformationRef_t plmnRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
le_mrc_Rat_t le_mrc_GetCellularNetworkRat(le_mrc_ScanInformationRef_t scanInformationRef)
uint32_t le_mrc_GetPciScanGlobalCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
void le_mrc_RemoveRatChangeHandler(le_mrc_RatChangeHandlerRef_t handlerRef)
void le_mrc_RemoveNetRegRejectHandler(le_mrc_NetRegRejectHandlerRef_t handlerRef)
le_result_t le_mrc_GetSarBackoffState(uint8_t *statePtr)
uint32_t le_mrc_GetServingCellLocAreaCode(void)
le_mrc_PreferredOperatorRef_t le_mrc_GetFirstPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_PciScanInformationRef_t le_mrc_GetFirstPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
void le_mrc_PerformCellularNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_CellularNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_mrc_GetLteSignalMetrics(le_mrc_MetricsRef_t MetricsRef, int32_t *ssPtr, uint32_t *blerPtr, int32_t *rsrqPtr, int32_t *rsrpPtr, int32_t *snrPtr)
void le_mrc_RemoveNetworkRejectHandler(le_mrc_NetworkRejectHandlerRef_t handlerRef)
le_mrc_PciScanInformationRef_t le_mrc_GetNextPciScanInfo(le_mrc_PciScanInformationListRef_t scanInformationListRef)
int32_t le_mrc_GetPlatformSpecificRegistrationErrorCode(void)
le_mrc_PreferredOperatorRef_t le_mrc_GetNextPreferredOperator(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
void le_mrc_SetManualRegisterModeAsync(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_ManualSelectionHandlerFunc_t handlerPtr, void *contextPtr)
LE_FULL_API void le_mrc_SetServerDisconnectHandler(le_mrc_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_result_t le_mrc_GetTdScdmaBandCapabilities(le_mrc_TdScdmaBandBitMask_t *bandMaskPtrPtr)
le_result_t le_mrc_GetRegisterMode(bool *isManualPtrPtr, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
le_result_t le_mrc_SetLteBandPreferences(le_mrc_LteBandBitMask_t bandMask)
bool le_mrc_IsCellularNetworkForbidden(le_mrc_ScanInformationRef_t scanInformationRef)
int32_t le_mrc_GetNeighborCellUmtsEcIo(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_result_t le_mrc_GetCellularNetworkMccMnc(le_mrc_ScanInformationRef_t scanInformationRef, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
le_mrc_ScanInformationRef_t le_mrc_GetNextCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
le_result_t le_mrc_GetCurrentNetworkName(char *nameStr, size_t nameStrSize)
le_result_t le_mrc_GetRadioAccessTechInUse(le_mrc_Rat_t *ratPtr)
le_mrc_PreferredOperatorListRef_t le_mrc_GetPreferredOperatorsList(void)
le_result_t le_mrc_GetLteBandPreferences(le_mrc_LteBandBitMask_t *bandMaskPtrPtr)
le_result_t le_mrc_AddPreferredOperator(const char *LE_NONNULL mcc, const char *LE_NONNULL mnc, le_mrc_RatBitMask_t ratMask)
le_result_t le_mrc_GetBandCapabilities(le_mrc_BandBitMask_t *bandMaskPtrPtr)
bool le_mrc_IsCellularNetworkHome(le_mrc_ScanInformationRef_t scanInformationRef)
le_mrc_PciScanInformationListRef_t le_mrc_PerformPciNetworkScan(le_mrc_RatBitMask_t ratMask)
le_result_t le_mrc_GetCellularNetworkName(le_mrc_ScanInformationRef_t scanInformationRef, char *namePtr, size_t namePtrSize)
void le_mrc_ConnectService(void)
void le_mrc_DeletePreferredOperatorsList(le_mrc_PreferredOperatorListRef_t preferredOperatorListRef)
le_mrc_JammingDetectionEventHandlerRef_t le_mrc_AddJammingDetectionEventHandler(le_mrc_JammingDetectionHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_mrc_StartJammingDetection(void)
le_result_t le_mrc_StopJammingDetection(void)
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)
void le_mrc_DisconnectService(void)
bool le_mrc_IsCellularNetworkInUse(le_mrc_ScanInformationRef_t scanInformationRef)
void le_mrc_PerformPciNetworkScanAsync(le_mrc_RatBitMask_t ratMask, le_mrc_PciNetworkScanHandlerFunc_t handlerPtr, void *contextPtr)
#define LE_FULL_API
Definition: le_basics.h:288
uint32_t le_mrc_GetNeighborCellLocAreaCode(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_mrc_MetricsRef_t le_mrc_MeasureSignalMetrics(void)
bool le_mrc_IsCellularNetworkAvailable(le_mrc_ScanInformationRef_t scanInformationRef)
void le_mrc_DeletePciNetworkScan(le_mrc_PciScanInformationListRef_t scanInformationListRef)
uint16_t le_mrc_GetPciScanCellId(le_mrc_PciScanInformationRef_t pciScanInformationRef)
void le_mrc_RemoveJammingDetectionEventHandler(le_mrc_JammingDetectionEventHandlerRef_t handlerRef)
le_mrc_NetworkRejectHandlerRef_t le_mrc_AddNetworkRejectHandler(le_mrc_NetworkRejectHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_mrc_GetBandPreferences(le_mrc_BandBitMask_t *bandMaskPtrPtr)
void le_mrc_RemoveNetRegStateEventHandler(le_mrc_NetRegStateEventHandlerRef_t handlerRef)
le_mrc_ScanInformationRef_t le_mrc_GetFirstCellularNetworkScan(le_mrc_ScanInformationListRef_t scanInformationListRef)
le_mrc_Rat_t le_mrc_GetNeighborCellRat(le_mrc_CellInfoRef_t ngbrCellInfoRef)
le_onoff_t
Definition: le_basics.h:71