le_mrc_interface.h

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