le_sms_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_sms SMS
14  *
15  * @ref le_sms_interface.h "API Reference"
16  *
17  * <HR>
18  *
19  * This file contains data structures and prototypes definitions for high level SMS APIs.
20  *
21  * SMS is a common way to communicate in the M2M world.
22  *
23  * It's an easy, fast way to send a small amount of data (e.g., sensor values for gas telemetry).
24  * Usually, the radio module requests small power resources to send or receive a message.
25  * It's often a good way to wake-up a device that was disconnected from the network or that was
26  * operating in low power mode.
27  *
28  * @section le_sms_binding IPC interfaces binding
29  *
30  * All the functions of this API are provided by the @b modemService.
31  *
32  * Here's a code sample binding to modem services:
33  * @verbatim
34  bindings:
35  {
36  clientExe.clientComponent.le_sms -> modemService.le_sms
37  }
38  @endverbatim
39  *
40  * @section le_sms_ops_creating_msg Creating a Message object
41  * There are 3 kinds of supported messages: text messages, binary messages, and PDU messages.
42  *
43  * You must create a Message object by calling @c le_sms_Create() before using the message
44  * APIs. It automatically allocates needed resources for the Message object, which is referenced by
45  * @c le_sms_MsgRef_t type.
46  *
47  * When the Message object is no longer needed, call @c le_sms_Delete() to free all
48  * allocated resources associated with the object.
49  *
50  * @section le_sms_ops_deleting_msg Deleting a Message object
51  * To delete a Message object, call le_sms_Delete(). This frees all the
52  * resources allocated for the Message object. If several users own the Message object
53  * (e.g., several handler functions registered for SMS message reception), the
54  * Message object will be deleted only after the last user deletes the Message object.
55  *
56  * @section le_sms_ops_sending Sending a message
57  * To send a message, create an @c le_sms_MsgRef_t object by calling the
58  * @c le_sms_Create() function. Then, set all the needed parameters for the message:
59  * - Destination telephone number with le_sms_SetDestination();
60  * - Text content with le_sms_SetText(), the total length are set as well with this API, maximum
61  * 160 characters as only the 7-bit alphabet is supported.
62  * - Binary content with le_sms_SetBinary(), total length is set with this API, maximum 140 bytes.
63  * - PDU content with le_sms_SetPDU(), total length is set with this API, max 36 (header) + 140
64  * (payload) bytes long.
65  * - UCS2 content (16-bit format) with le_sms_SetUCS2(), total length is set with this API, maximum
66  * 70 characters (140 bytes).
67  *
68  * When the Msg object is ready, call @c le_sms_Send() to transmit it.
69  *
70  * @c le_sms_Send() is a blocking function with a maximum timeout set to 240 seconds, it will return
71  * once the Modem has given back a positive or negative answer to the sending operation.
72  * The return of @c le_sms_Send() API provides definitive status of the sending operation.
73  * TP-Validity-Period(TP-VP) parameter value indicates the time period for which the short message
74  * is valid, i.e. for how long the Service Center (SC) shall guarantee its existence in the SC
75  * memory before delivery to the recipient has been carried out. The default validity period(TP-VP)
76  * is set to 7 days for MO SMS.
77  *
78  * When a message sending has failed and returned LE_FAULT, call le_sms_GetErrorCode() to retrieve
79  * the 3GPP message error code or le_sms_Get3GPP2ErrorCode() to retrieve the 3GPP2 message error
80  * code. If LE_SMS_ERROR_3GPP_PLATFORM_SPECIFIC or LE_SMS_ERROR_3GPP2_PLATFORM_SPECIFIC values is
81  * returned, call le_sms_GetPlatformSpecificErrorCode() to retrieve the platform specific error
82  * code.
83  *
84  * Please refer to @ref platformConstraintsSpecificErrorCodes for platform
85  * specific error code description.
86  *
87  * Please refer to @ref c_smsSampleMO page to get an example of SMS message sending.
88  *
89  * @section le_sms_ops_async_sending Sending asynchronously a message
90  *
91  * To send an asynchronous message, le_sms_SendAsync() API can be called instead of le_sms_Send().
92  * le_sms_SendAsync() is a non-blocking function, it queues the message to the SMS pool and returns
93  * immediatly. Then, Legato will internally attempt to send the SMS with a maximum timeout set
94  * to 240 seconds for each SMS in the pool.
95  * This function is usefull to stack a set of messages without blocking the user application.
96  * Moreover, a handler can be specified to le_sms_SendAsync() API in order to keep track of the
97  * transmission status.
98  *
99  * The default validity period(TP-VP) is set to 7 days for MO SMS.
100  *
101  * A text message can be sent with one simple function: le_sms_SendText(). You only have to pass
102  * the three following parameters:
103  * - the destination telephone number.
104  * - the text message, the total length are set as well with this function, maximum 160
105  * characters as only the 7-bit alphabet is supported.
106  * - the callback function to get a notification indicating the sending result: LE_SMS_SENT,
107  * LE_SMS_SENDING_FAILED or LE_SMS_SENDING_TIMEOUT.
108  * The default validity period(TP-VP) is set to 7 days for MO SMS.
109  *
110  * A PDU message can be sent using the le_sms_SendPdu() functions. The parameters to give are:
111  * - the PDU content, total length is set with this API, maximum 176 bytes long = 36 (header) +
112  * 140 (payload).
113  * - the callback function to get a notification indicating the sending result: LE_SMS_SENT,
114  * LE_SMS_SENDING_FAILED or LE_SMS_SENDING_TIMEOUT.
115  * The default validity period(TP-VP) is set to 7 days for MO SMS.
116  *
117  * When a message sending has failed, call le_sms_GetErrorCode() to retrieve the 3GPP message error
118  * code or le_sms_Get3GPP2ErrorCode() to retrieve the 3GPP2 message error code.
119  * If LE_SMS_ERROR_3GPP_PLATFORM_SPECIFIC or LE_SMS_ERROR_3GPP2_PLATFORM_SPECIFIC values is
120  * returned, call le_sms_GetPlatformSpecificErrorCode() to retrieve the platform specific error
121  * code.
122  *
123  * Message object is never deleted regardless of the sending result. Caller has to
124  * delete it. Message object once used for sending the message can not be reused to
125  * send another message regardless of success or failure. New object has to be created
126  * for new message.
127  *
128  * @section le_sms_ops_receiving Receiving a message
129  * To receive SMS messages, register a handler function to obtain incoming
130  * messages. Use @c le_sms_AddRxMessageHandler() to register that handler.
131  *
132  * The handler must satisfy the following prototype:
133  * @c typedef void (*le_sms_RxMessageHandlerFunc_t)(le_sms_MsgRef_t msg).
134  *
135  * When a new incoming message is received, a Message object is automatically created and the
136  * handler is called. This Message object is Read-Only, any calls of a le_sms_SetXXX API will
137  * return a LE_NOT_PERMITTED error.
138  *
139  * Use the following APIs to retrieve message information and data from the Message
140  * object:
141  * - le_sms_GetFormat() - determine if it is a binary or a text message.
142  * - le_sms_GetSenderTel() - get the sender's Telephone number.
143  * - le_sms_GetTimeStamp() - get the timestamp sets by the Service Center.
144  * - le_sms_GetUserdataLen() - get the message content (text, binary or UCS2) length.
145  * - le_sms_GetPDULen() - get the PDU message length.
146  * - le_sms_GetText() - get the message text.
147  * - le_sms_GetUCS2() - get the UCS2 message content (16-bit format).
148  * - le_sms_GetBinary() - get the message binary content.
149  * - le_sms_GetPDU() - get the message PDU data.
150  * - le_sms_GetType() - get the message type.
151  *
152  * @note - If two (or more) registered handler functions exist, they are
153  * all called and get a different message object reference.
154  *
155  * @note - For incoming SMS, if the returned format is LE_SMS_FORMAT_PDU, the PDU length can be
156  * retrieved by calling le_sms_GetPDULen() and the content can be read by le_sms_GetPDU().
157  *
158  * If a succession of messages is received, a new Message object is created for each, and
159  * the handler is called for each new message.
160  *
161  * Uninstall the handler function by calling @c le_sms_RemoveRxMessageHandler().
162  * @note @c le_sms_RemoveRxMessageHandler() API does not delete the Message Object.
163  * The caller has to delete it.
164  *
165  * Please refer to @ref c_smsSampleMT page to get an example of SMS message reception handling.
166  *
167  * @section le_sms_ops_sms_storage Receiving a full SMS storage indication
168  * To receive a SMS full storage status, the application has to register a handler function.
169  * Use @c le_sms_AddFullStorageEventHandler() to register that handler.
170  *
171  * The handler must satisfy the following prototype:
172  * @c typedef void (*le_sms_FullStorageEventFunc_t)(le_sms_Storage_t storage).
173  *
174  * Uninstall the handler function by calling @c le_sms_RemoveFullStorageEventHandler().
175  *
176  * Please refer to @ref c_smsSampleMT page to get an example of SMS storage indication
177  * handling.
178  *
179  * @section le_sms_ops_listing Listing messages recorded in storage area
180  *
181  * Call @c le_sms_CreateRxMsgList() to create a List object that lists the received
182  * messages present in the storage area, which is referenced by @c le_sms_MsgListRef_t
183  * type.
184  *
185  * If messages are not present, the le_sms_CreateRxMsgList() returns NULL.
186  *
187  * Once the list is available, call @c le_sms_GetFirst() to get the first
188  * message from the list, and then call @c le_sms_GetNext() API to get the next message.
189  *
190  * Call @c le_sms_DeleteList() to free all allocated
191  * resources associated with the List object.
192  *
193  * Call @c le_sms_GetStatus() to read the status of a message (Received
194  * Read, Received Unread).
195  *
196  * To finish, you can also modify the received status of a message with
197  * @c le_sms_MarkRead() and @c le_sms_MarkUnread().
198  *
199  * @section le_sms_ops_deleting Deleting a message from the storage area
200  *
201  * @c le_sms_DeleteFromStorage() deletes the message from the storage area. Message is
202  * identified with @c le_sms_MsgRef_t object. The API returns an error if the deletion cannot be
203  * performed or if it is a broadcast or a non stored message.
204  *
205  * @note If several users own the Message object on new reception
206  * (e.g., several handler functions registered for SMS message reception), the
207  * Message will be deleted from the storage area only after the last user deletes
208  * the Message object reference (not necessary from storage). API returns always LE_OK in this case.
209  *
210  * @note If one client creates a list and deletes all sms from storage, other clients won’t see sms
211  * stored If they have not created a sms list too. Sms List creation locks and
212  * delays sms deletion from storage until all references have been deleted.
213  *
214  * @section le_sms_ops_broadcast SMS Cell Broadcast
215  *
216  * The Cell Broadcast service permits a number of unacknowledged general messages to be broadcast
217  * to all receivers within a particular region. Cell Broadcast messages are broadcast to defined
218  * geographical areas known as cell broadcast areas. These areas may comprise of one or more cells,
219  * or may comprise the entire PLMN.
220  *
221  * GSM or UMTS SMS cell broadcast service can be activated or deactivated with
222  * le_sms_ActivateCellBroadcast() and le_sms_DeactivateCellBroadcast() APIs.
223  *
224  * CDMA cell broadcast service can be activated or deactivated with
225  * le_sms_ActivateCdmaCellBroadcast() and le_sms_DeactivateCdmaCellBroadcast() APIs.
226  *
227  * Cell broadcast message receptions are notify by the SMS handler like a SMS message reception,
228  * but there are neither stored in SIM nor in the modem. So le_sms_DeleteFromStorage()
229  * can't be used but the message reference shall be delete with le_sms_Delete().
230  *
231  * - le_sms_GetFormat() - determine if it is a binary or a text message.
232  * - le_sms_GetUserdataLen() - get the message content (text, binary or UCS2) length.
233  * - le_sms_GetPDULen() - get the PDU message received length.
234  * - le_sms_GetText() - get the message text.
235  * - le_sms_GetBinary() - get the message binary content.
236  * - le_sms_GetUCS2() - get the UCS2 message content (16-bit format).
237  * - le_sms_GetPDU() - get the message PDU data received length.
238  * - le_sms_GetCellBroadcastId() - get the message identifier received (3GPP 23.41).
239  * - le_sms_GetCellBroadcastSerialNumber() get the message Serial Number received (3GPP 23.41).
240  *
241  * A sample code that implements a function for SMS Cell Broadcast reception can be found in
242  * \b smsCBTest.c file (please refer to @ref c_smsCbSample page).
243  *
244  * @b Serial @b Number
245  *
246  * Cell Broadcast Serial Number parameter is a 16-bit integer which identifies a particular
247  * CBS message from the source and type indicated by the Message Identifier and is altered every
248  * time the CBS message with a given Message Identifier is changed.
249  *
250  * The two bytes of the Serial Number field are divided into a 2-bit Geographical Scope (GS)
251  * indicator, a 10-bit Message Code and a 4-bit Update Number as shown below:
252  *
253  * - GS code (bit 14 and 15): The Geographical Scope (GS) indicates the geographical area over
254  * which the Message Code is unique, and the display mode.
255  *
256  * - Message Code (bit 4 to 13) : The Message Code differentiates between CBS messages from
257  * the same source and type (i.e. with the same Message Identifier). Message Codes are for
258  * allocation by PLMN operators. The Message Code identifies different message themes.
259  * For example, let the value for the Message Identifier be "Automotive Association" (= source),
260  * "Traffic Reports" (= type). Then "Crash on A1 J5" could be one value for the message code,
261  * "Cow on A32 J4" could be another, and "Slow vehicle on M3 J3" yet another.
262  *
263  * - Update Number (bit 0 to 3) : The Update Number indicates a change of the message content of
264  * the same CBS message, i.e. the CBS message with the same Message Identifier, Geographical
265  * Scope, and Message Code.
266  *
267  * Serial Number fields meaning are defined in the 3GPP 23.041 (9.4.1.2.1 Serial Number).
268  *
269  * @b Message @b Identifier
270  *
271  * Message Identifier parameter identifies the source and type of the CBS message. For example,
272  * "Automotive Association" (= source), "Traffic Reports" (= type) could correspond to one value.
273  * A number of CBS messages may originate from the same source and/or be of the same type.
274  * These will be distinguished by the Serial Number.
275  *
276  * Message identifier meaning ranges are defined in the 3GPP 23.041 (9.4.1.2.2 Message Identifier).
277  *
278  * @section le_sms_ops_broadcast_configuration SMS Cell Broadcast configuration
279  *
280  * GSM or UMTS Cell broadcast Message identifiers range can be added or removed with
281  * le_sms_AddCellBroadcastIds() and le_sms_RemoveCellBroadcastIds() APIs. All Message identifiers
282  * can be removed with le_sms_ClearCellBroadcastIds() API.
283  *
284  * CDMA Cell broadcast Service categories can be added or removed with
285  * le_sms_AddCdmaCellBroadcastServices() and le_sms_RemoveCdmaCellBroadcastServices() APIs. All
286  * Service categories can be removed with le_sms_ClearCdmaCellBroadcastServices() API.
287  *
288  * @section le_sms_ops_statusReport SMS Status Report
289  *
290  * SMS Status Report may be sent by the SMS Center (SMSC) to inform the originating device about the
291  * final outcome of the message delivery.
292  *
293  * SMS Status Report can be activated or deactivated for outgoing messages with
294  * le_sms_EnableStatusReport() and le_sms_DisableStatusReport(). The current activation state can
295  * be retrieved with le_sms_IsStatusReportEnabled().
296  *
297  * The reception of a SMS Status Report is notified by the SMS handler like a SMS message reception,
298  * but the message is neither stored in SIM nor in the modem. So le_sms_DeleteFromStorage()
299  * can't be used, but the message reference shall be delete with le_sms_Delete(). Received SMS
300  * Status Reports are identified by a specific type: @ref LE_SMS_TYPE_STATUS_REPORT.
301  *
302  * The different elements of the SMS Status Report can be retrieved with the following APIs:
303  * - le_sms_GetTpMr() gives the Message Reference, defined in 3GPP TS 23.040 section 9.2.3.6.
304  * - le_sms_GetTpRa() gives the Recipient Address, defined in 3GPP TS 23.040 section 9.2.3.14, and
305  * the Recipient Address Type of Address, defined in 3GPP TS 24.011 section 8.2.5.2.
306  * - le_sms_GetTpScTs() gives the Service Centre Time Stamp, defined in 3GPP TS 23.040
307  * section 9.2.3.11.
308  * - le_sms_GetTpDt() gives the Discharge Time, defined in 3GPP TS 23.040 section 9.2.3.13.
309  * - le_sms_GetTpSt() gives the Status, defined in 3GPP TS 23.040 section 9.2.3.15.
310  *
311  * @section le_sms_ops_configuration SMS configuration
312  *
313  * Modem SMS Center Address can be set or get with le_sms_SetSmsCenterAddress() and
314  * le_sms_GetSmsCenterAddress() functions
315  *
316  * @section le_sms_ops_storage_configuration Preferred SMS storage configuration
317  *
318  * Preferred SMS storage for incoming messages can be set or get with le_sms_SetPreferredStorage()
319  * and le_sms_GetPreferredStorage() functions.
320  *
321  * @section le_sms_ops_statistics SMS statistics
322  *
323  * The number of SMS successfully sent or received through the Legato API can be counted.
324  * This feature is activated by default. le_sms_GetCount() allows retrieving the message count
325  * for each SMS type (cf. @ref le_sms_Type_t).
326  *
327  * le_sms_StopCount() stops the message counting and le_sms_StartCount() restarts it.
328  * le_sms_ResetCount() can be used to reset the message counters.
329  *
330  * @note The activation state of this feature is persistent even after a reboot of the platform.
331  *
332  * @section le_sms_ops_samples Sample codes
333  * A sample code that implements a function for Mobile Originated SMS message can be found in
334  * \b smsMO.c file (please refer to @ref c_smsSampleMO page).
335  *
336  * A sample code that implements a function for Mobile Terminated SMS message can be found in
337  * \b smsMT.c file (please refer to @ref c_smsSampleMT page).
338  *
339  * These two samples can be easily compiled and run into the \b sms app, to install and use
340  * this app:
341  *
342  * @verbatim
343  $ make ar7
344  $ bin/instapp build/ar7/bin/samples/sms.ar7 <ipaddress>
345  @endverbatim
346  * where ipaddress is the address of your target device.
347  *
348  * Then on your target, just run:
349  * @verbatim
350  $ app start sms
351  @endverbatim
352  *
353  * The sample replies to the sender by the message "Message from <phone number> received". Where
354  * "phone number" is the sender's phone number.
355  *
356  * Sample code for that application can be seen in the following pages:
357  * - @subpage c_smsSampleMO <br>
358  * - @subpage c_smsSampleMT
359  *
360  * <HR>
361  *
362  * Copyright (C) Sierra Wireless Inc.
363  */
364 /**
365  * @file le_sms_interface.h
366  *
367  * Legato @ref c_sms include file.
368  *
369  * Copyright (C) Sierra Wireless Inc.
370  */
371 /**
372  * @page c_smsSampleMO Sample code for Mobile Originated SMS message
373  *
374  * @include "apps/sample/sms/smsClient/smsMO.c"
375  */
376 /**
377  * @page c_smsSampleMT Sample code for Mobile Terminated SMS message
378  *
379  * @include "apps/sample/sms/smsClient/smsMT.c"
380  */
381 /**
382  * @page c_smsCbSample Sample code for SMS Cell Broadcast reception
383  *
384  * @include "apps/test/modemServices/sms/smsIntegrationTest/smsCBTest/smsCBTest.c"
385  */
386 
387 #ifndef LE_SMS_INTERFACE_H_INCLUDE_GUARD
388 #define LE_SMS_INTERFACE_H_INCLUDE_GUARD
389 
390 
391 #include "legato.h"
392 
393 // Interface specific includes
394 #include "le_mdmDefs_interface.h"
395 
396 // Internal includes for this interface
397 #include "le_sms_common.h"
398 //--------------------------------------------------------------------------------------------------
399 /**
400  * Type for handler called when a server disconnects.
401  */
402 //--------------------------------------------------------------------------------------------------
403 typedef void (*le_sms_DisconnectHandler_t)(void *);
404 
405 //--------------------------------------------------------------------------------------------------
406 /**
407  *
408  * Connect the current client thread to the service providing this API. Block until the service is
409  * available.
410  *
411  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
412  * called before any other functions in this API. Normally, ConnectService is automatically called
413  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
414  *
415  * This function is created automatically.
416  */
417 //--------------------------------------------------------------------------------------------------
419 (
420  void
421 );
422 
423 //--------------------------------------------------------------------------------------------------
424 /**
425  *
426  * Try to connect the current client thread to the service providing this API. Return with an error
427  * if the service is not available.
428  *
429  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
430  * called before any other functions in this API. Normally, ConnectService is automatically called
431  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
432  *
433  * This function is created automatically.
434  *
435  * @return
436  * - LE_OK if the client connected successfully to the service.
437  * - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
438  * bound.
439  * - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
440  * - LE_COMM_ERROR if the Service Directory cannot be reached.
441  */
442 //--------------------------------------------------------------------------------------------------
444 (
445  void
446 );
447 
448 //--------------------------------------------------------------------------------------------------
449 /**
450  * Set handler called when server disconnection is detected.
451  *
452  * When a server connection is lost, call this handler then exit with LE_FATAL. If a program wants
453  * to continue without exiting, it should call longjmp() from inside the handler.
454  */
455 //--------------------------------------------------------------------------------------------------
457 (
458  le_sms_DisconnectHandler_t disconnectHandler,
459  void *contextPtr
460 );
461 
462 //--------------------------------------------------------------------------------------------------
463 /**
464  *
465  * Disconnect the current client thread from the service providing this API.
466  *
467  * Normally, this function doesn't need to be called. After this function is called, there's no
468  * longer a connection to the service, and the functions in this API can't be used. For details, see
469  * @ref apiFilesC_client.
470  *
471  * This function is created automatically.
472  */
473 //--------------------------------------------------------------------------------------------------
475 (
476  void
477 );
478 
479 
480 //--------------------------------------------------------------------------------------------------
481 /**
482  * Message Format.
483  */
484 //--------------------------------------------------------------------------------------------------
485 
486 
487 //--------------------------------------------------------------------------------------------------
488 /**
489  * Message Type.
490  */
491 //--------------------------------------------------------------------------------------------------
492 
493 
494 //--------------------------------------------------------------------------------------------------
495 /**
496  * Message Status.
497  */
498 //--------------------------------------------------------------------------------------------------
499 
500 
501 //--------------------------------------------------------------------------------------------------
502 /**
503  * CDMA Cell broadcast message languages.
504  */
505 //--------------------------------------------------------------------------------------------------
506 
507 
508 //--------------------------------------------------------------------------------------------------
509 /**
510  * CDMA Cell broadcast Service Categories.
511  */
512 //--------------------------------------------------------------------------------------------------
513 
514 
515 //--------------------------------------------------------------------------------------------------
516 /**
517  * SMS storage area.
518  */
519 //--------------------------------------------------------------------------------------------------
520 
521 
522 //--------------------------------------------------------------------------------------------------
523 /**
524  * 3GPP2 Message Error code when the message sending has failed.
525  */
526 //--------------------------------------------------------------------------------------------------
527 
528 
529 //--------------------------------------------------------------------------------------------------
530 /**
531  * Message Error code when the message sending has failed.
532  */
533 //--------------------------------------------------------------------------------------------------
534 
535 
536 //--------------------------------------------------------------------------------------------------
537 /**
538  * Declare a reference type for referring to SMS Message objects.
539  */
540 //--------------------------------------------------------------------------------------------------
541 
542 
543 //--------------------------------------------------------------------------------------------------
544 /**
545  * Opaque type for SMS Message Listing.
546  */
547 //--------------------------------------------------------------------------------------------------
548 
549 
550 //--------------------------------------------------------------------------------------------------
551 /**
552  * Handler for Sending result.
553  */
554 //--------------------------------------------------------------------------------------------------
555 
556 
557 //--------------------------------------------------------------------------------------------------
558 /**
559  * Handler for New Message.
560  *
561  */
562 //--------------------------------------------------------------------------------------------------
563 
564 
565 //--------------------------------------------------------------------------------------------------
566 /**
567  * Reference type used by Add/Remove functions for EVENT 'le_sms_RxMessage'
568  */
569 //--------------------------------------------------------------------------------------------------
570 
571 
572 //--------------------------------------------------------------------------------------------------
573 /**
574  * Handler for full storage indication.
575  *
576  */
577 //--------------------------------------------------------------------------------------------------
578 
579 
580 //--------------------------------------------------------------------------------------------------
581 /**
582  * Reference type used by Add/Remove functions for EVENT 'le_sms_FullStorageEvent'
583  */
584 //--------------------------------------------------------------------------------------------------
585 
586 
587 //--------------------------------------------------------------------------------------------------
588 /**
589  * Add handler function for EVENT 'le_sms_RxMessage'
590  *
591  * This event provides information on new received messages.
592  *
593  */
594 //--------------------------------------------------------------------------------------------------
595 le_sms_RxMessageHandlerRef_t le_sms_AddRxMessageHandler
596 (
597  le_sms_RxMessageHandlerFunc_t handlerPtr,
598  ///< [IN]
599  void* contextPtr
600  ///< [IN]
601 );
602 
603 //--------------------------------------------------------------------------------------------------
604 /**
605  * Remove handler function for EVENT 'le_sms_RxMessage'
606  */
607 //--------------------------------------------------------------------------------------------------
609 (
610  le_sms_RxMessageHandlerRef_t handlerRef
611  ///< [IN]
612 );
613 
614 //--------------------------------------------------------------------------------------------------
615 /**
616  * Add handler function for EVENT 'le_sms_FullStorageEvent'
617  *
618  * This event provides information on full storage indication.
619  *
620  */
621 //--------------------------------------------------------------------------------------------------
622 le_sms_FullStorageEventHandlerRef_t le_sms_AddFullStorageEventHandler
623 (
624  le_sms_FullStorageHandlerFunc_t handlerPtr,
625  ///< [IN]
626  void* contextPtr
627  ///< [IN]
628 );
629 
630 //--------------------------------------------------------------------------------------------------
631 /**
632  * Remove handler function for EVENT 'le_sms_FullStorageEvent'
633  */
634 //--------------------------------------------------------------------------------------------------
636 (
637  le_sms_FullStorageEventHandlerRef_t handlerRef
638  ///< [IN]
639 );
640 
641 //--------------------------------------------------------------------------------------------------
642 /**
643  * Create an SMS Message data structure.
644  *
645  * @return Reference to the new Message object.
646  *
647  * @note
648  * On failure, the process exits, so you don't have to worry about checking the returned
649  * reference for validity.
650  */
651 //--------------------------------------------------------------------------------------------------
652 le_sms_MsgRef_t le_sms_Create
653 (
654  void
655 );
656 
657 //--------------------------------------------------------------------------------------------------
658 /**
659  * Set the timeout to send a SMS Message.
660  *
661  * @return
662  * - LE_FAULT Message is not in UNSENT state or is Read-Only.
663  * - LE_OK Function succeeded.
664  *
665  * @note
666  * On failure, the process exits, so you don't have to worry about checking the returned
667  * reference for validity.
668  *
669  * @deprecated
670  * This API should not be used for new applications and will be removed in a future version
671  * of Legato.
672  */
673 //--------------------------------------------------------------------------------------------------
675 (
676  le_sms_MsgRef_t msgRef,
677  ///< [IN] Reference to the message object.
678  uint32_t timeout
679  ///< [IN] Timeout in seconds.
680 );
681 
682 //--------------------------------------------------------------------------------------------------
683 /**
684  * Set the Telephone destination number.
685  *
686  * Telephone number is defined in ITU-T recommendations E.164/E.163.
687  * E.164 numbers can have a maximum of fifteen digits and are usually written with a '+' prefix.
688  *
689  * @return LE_NOT_PERMITTED Message is Read-Only.
690  * @return LE_BAD_PARAMETER Telephone destination number length is equal to zero.
691  * @return LE_OK Function succeeded.
692  *
693  * @note If telephone destination number is too long is too long (max LE_MDMDEFS_PHONE_NUM_MAX_LEN
694  * digits), it is a fatal error, the function will not return.
695  *
696  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
697  * function will not return.
698  */
699 //--------------------------------------------------------------------------------------------------
701 (
702  le_sms_MsgRef_t msgRef,
703  ///< [IN] Reference to the message object.
704  const char* LE_NONNULL dest
705  ///< [IN] Telephone number string.
706 );
707 
708 //--------------------------------------------------------------------------------------------------
709 /**
710  * This function must be called to set the Text Message content.
711  *
712  * @return LE_NOT_PERMITTED Message is Read-Only.
713  * @return LE_BAD_PARAMETER Text message length is equal to zero.
714  * @return LE_OK Function succeeded.
715  *
716  * @note Text Message is encoded in ASCII format (ISO8859-15) and characters have to exist in
717  * the GSM 23.038 7 bit alphabet.
718  *
719  * @note If message is too long (max LE_SMS_TEXT_MAX_LEN digits), it is a fatal error, the
720  * function will not return.
721  *
722  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
723  * function will not return.
724  */
725 //--------------------------------------------------------------------------------------------------
727 (
728  le_sms_MsgRef_t msgRef,
729  ///< [IN] Reference to the message object.
730  const char* LE_NONNULL text
731  ///< [IN] SMS text.
732 );
733 
734 //--------------------------------------------------------------------------------------------------
735 /**
736  * Set the binary message content.
737  *
738  * @return LE_NOT_PERMITTED Message is Read-Only.
739  * @return LE_BAD_PARAMETER Length of the data is equal to zero.
740  * @return LE_OK Function succeeded.
741  *
742  * @note If length of the data is too long (max LE_SMS_BINARY_MAX_BYTES bytes), it is a fatal
743  * error, the function will not return.
744  *
745  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
746  * function will not return.
747  */
748 //--------------------------------------------------------------------------------------------------
750 (
751  le_sms_MsgRef_t msgRef,
752  ///< [IN] Reference to the message object.
753  const uint8_t* binPtr,
754  ///< [IN] Binary data.
755  size_t binSize
756  ///< [IN]
757 );
758 
759 //--------------------------------------------------------------------------------------------------
760 /**
761  * Set the UCS2 message content (16-bit format).
762  *
763  * @return
764  * - LE_NOT_PERMITTED Message is Read-Only.
765  * - LE_BAD_PARAMETER Length of the data is equal to zero.
766  * - LE_OK Function succeeded.
767  *
768  * @note If length of the data is too long (max LE_SMS_UCS2_MAX_CHARS), it is a fatal
769  * error, the function will not return.
770  *
771  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
772  * function will not return.
773  */
774 //--------------------------------------------------------------------------------------------------
776 (
777  le_sms_MsgRef_t msgRef,
778  ///< [IN] Reference to the message object.
779  const uint16_t* ucs2Ptr,
780  ///< [IN] UCS2 message.
781  size_t ucs2Size
782  ///< [IN]
783 );
784 
785 //--------------------------------------------------------------------------------------------------
786 /**
787  * Set the PDU message content.
788  *
789  * @return LE_NOT_PERMITTED Message is Read-Only.
790  * @return LE_BAD_PARAMETER Length of the data is equal to zero.
791  * @return LE_OK Function succeeded.
792  *
793  * @note If length of the data is too long (max LE_SMS_PDU_MAX_BYTES bytes), it is a fatal error,
794  * the function will not return.
795  *
796  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
797  * function will not return.
798  */
799 //--------------------------------------------------------------------------------------------------
801 (
802  le_sms_MsgRef_t msgRef,
803  ///< [IN] Reference to the message object.
804  const uint8_t* pduPtr,
805  ///< [IN] PDU message.
806  size_t pduSize
807  ///< [IN]
808 );
809 
810 //--------------------------------------------------------------------------------------------------
811 /**
812  * Send an SMS message.
813  *
814  * Verifies first if the parameters are valid, then it checks the modem state can support
815  * message sending.
816  *
817  * @return LE_FORMAT_ERROR Message content is invalid.
818  * @return LE_FAULT Function failed to send the message.
819  * @return LE_OK Function succeeded.
820  * @return LE_TIMEOUT Timeout before the complete sending.
821  *
822  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
823  * function will not return.
824  */
825 //--------------------------------------------------------------------------------------------------
827 (
828  le_sms_MsgRef_t msgRef
829  ///< [IN] Reference to the message object.
830 );
831 
832 //--------------------------------------------------------------------------------------------------
833 /**
834  * Send an asynchronous SMS message.
835  *
836  * Verifies first if the parameters are valid, then it checks the modem state can support
837  * message sending.
838  *
839  * @return LE_FORMAT_ERROR Message content is invalid.
840  * @return LE_FAULT Function failed to send the message.
841  * @return LE_OK Function succeeded.
842  * @return LE_TIMEOUT Timeout before the complete sending.
843  *
844  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
845  * function will not return.
846  */
847 //--------------------------------------------------------------------------------------------------
849 (
850  le_sms_MsgRef_t msgRef,
851  ///< [IN] Reference to the message object.
852  le_sms_CallbackResultFunc_t handlerPtr,
853  ///< [IN] CallBack for sending result.
854  void* contextPtr
855  ///< [IN]
856 );
857 
858 //--------------------------------------------------------------------------------------------------
859 /**
860  * Get the error code when a 3GPP2 message sending has Failed.
861  *
862  * @return The error code
863  *
864  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
865  * function will not return.
866  *
867  * @note It is only applicable for 3GPP2 message sending failure, otherwise
868  * LE_SMS_ERROR_3GPP2_MAX is returned.
869  */
870 //--------------------------------------------------------------------------------------------------
871 le_sms_ErrorCode3GPP2_t le_sms_Get3GPP2ErrorCode
872 (
873  le_sms_MsgRef_t msgRef
874  ///< [IN] Reference to the message object.
875 );
876 
877 //--------------------------------------------------------------------------------------------------
878 /**
879  * Get the Radio Protocol and the Transfer Protocol error code when a 3GPP message sending has
880  * failed.
881  *
882  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
883  * function will not return.
884  *
885  * @note It is only applicable for 3GPP message sending failure, otherwise
886  * LE_SMS_ERROR_3GPP_MAX is returned.
887  */
888 //--------------------------------------------------------------------------------------------------
890 (
891  le_sms_MsgRef_t msgRef,
892  ///< [IN] Reference to the message object.
893  le_sms_ErrorCode_t* rpCausePtr,
894  ///< [OUT] Radio Protocol cause code.
895  le_sms_ErrorCode_t* tpCausePtr
896  ///< [OUT] Transfer Protocol cause code.
897 );
898 
899 //--------------------------------------------------------------------------------------------------
900 /**
901  * Called to get the platform specific error code.
902  *
903  * Refer to @ref platformConstraintsSpecificErrorCodes for platform specific error code description.
904  *
905  * @return The platform specific error code.
906  *
907  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
908  * function will not return.
909  */
910 //--------------------------------------------------------------------------------------------------
912 (
913  le_sms_MsgRef_t msgRef
914  ///< [IN] Reference to the message object.
915 );
916 
917 //--------------------------------------------------------------------------------------------------
918 /**
919  * Create and asynchronously send a text message.
920  *
921  * @return
922  * - le_sms_Msg Reference to the new Message object pooled.
923  * - NULL Not possible to pool a new message.
924  *
925  * @note If telephone destination number is too long is too long (max LE_MDMDEFS_PHONE_NUM_MAX_LEN
926  * digits), it is a fatal error, the function will not return.
927  * @note If message is too long (max LE_SMS_TEXT_MAX_LEN digits), it is a fatal error, the
928  * function will not return.
929  */
930 //--------------------------------------------------------------------------------------------------
931 le_sms_MsgRef_t le_sms_SendText
932 (
933  const char* LE_NONNULL destStr,
934  ///< [IN] Telephone number string.
935  const char* LE_NONNULL textStr,
936  ///< [IN] SMS text.
937  le_sms_CallbackResultFunc_t handlerPtr,
938  ///< [IN] CallBack for sending result.
939  void* contextPtr
940  ///< [IN]
941 );
942 
943 //--------------------------------------------------------------------------------------------------
944 /**
945  * Create and asynchronously send a PDU message.
946  *
947  * @return
948  * - le_sms_Msg Reference to the new Message object pooled.
949  * - NULL Not possible to pool a new message.
950  *
951  */
952 //--------------------------------------------------------------------------------------------------
953 le_sms_MsgRef_t le_sms_SendPdu
954 (
955  const uint8_t* pduPtr,
956  ///< [IN] PDU message.
957  size_t pduSize,
958  ///< [IN]
959  le_sms_CallbackResultFunc_t handlerPtr,
960  ///< [IN] CallBack for sending result.
961  void* contextPtr
962  ///< [IN]
963 );
964 
965 //--------------------------------------------------------------------------------------------------
966 /**
967  * Delete a Message data structure.
968  *
969  * It deletes the Message data structure and all the allocated memory is freed. If several
970  * users own the Message object (e.g., several handler functions registered for
971  * SMS message reception), the Message object will only be deleted if one User
972  * owns the Message object.
973  *
974  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
975  * function will not return.
976  */
977 //--------------------------------------------------------------------------------------------------
978 void le_sms_Delete
979 (
980  le_sms_MsgRef_t msgRef
981  ///< [IN] Reference to the message object.
982 );
983 
984 //--------------------------------------------------------------------------------------------------
985 /**
986  * Get the message format.
987  *
988  * @return Message format.
989  *
990  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
991  * function will not return.
992  *
993  */
994 //--------------------------------------------------------------------------------------------------
995 le_sms_Format_t le_sms_GetFormat
996 (
997  le_sms_MsgRef_t msgRef
998  ///< [IN] Reference to the message object.
999 );
1000 
1001 //--------------------------------------------------------------------------------------------------
1002 /**
1003  * Get the message type.
1004  *
1005  * @return Message type.
1006  *
1007  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1008  * function will not return.
1009  */
1010 //--------------------------------------------------------------------------------------------------
1011 le_sms_Type_t le_sms_GetType
1012 (
1013  le_sms_MsgRef_t msgRef
1014  ///< [IN] Reference to the message object.
1015 );
1016 
1017 //--------------------------------------------------------------------------------------------------
1018 /**
1019  * Get the Cell Broadcast Message Identifier.
1020  *
1021  * @return
1022  * - LE_FAULT Message is not a cell broadcast type.
1023  * - LE_OK Function succeeded.
1024  *
1025  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1026  * function will not return.
1027  */
1028 //--------------------------------------------------------------------------------------------------
1030 (
1031  le_sms_MsgRef_t msgRef,
1032  ///< [IN] Reference to the message object.
1033  uint16_t* messageIdPtr
1034  ///< [OUT] Cell Broadcast Message Identifier.
1035 );
1036 
1037 //--------------------------------------------------------------------------------------------------
1038 /**
1039  * Get the Cell Broadcast Message Serial Number.
1040  *
1041  * @return
1042  * - LE_FAULT Message is not a cell broadcast type.
1043  * - LE_OK Function succeeded.
1044  *
1045  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1046  * function will not return.
1047  */
1048 //--------------------------------------------------------------------------------------------------
1050 (
1051  le_sms_MsgRef_t msgRef,
1052  ///< [IN] Reference to the message object.
1053  uint16_t* serialNumberPtr
1054  ///< [OUT] Cell Broadcast Serial Number.
1055 );
1056 
1057 //--------------------------------------------------------------------------------------------------
1058 /**
1059  * Get the Sender Telephone number.
1060  *
1061  * Output parameter is updated with the Telephone number. If the Telephone number string exceeds
1062  * the value of 'len' parameter, LE_OVERFLOW error code is returned and 'tel' is filled until
1063  * 'len-1' characters and a null-character is implicitly appended at the end of 'tel'.
1064  *
1065  * @return LE_NOT_PERMITTED Message is not a received message.
1066  * @return LE_OVERFLOW Telephone number length exceed the maximum length.
1067  * @return LE_OK Function succeeded.
1068  *
1069  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1070  * function will not return.
1071  */
1072 //--------------------------------------------------------------------------------------------------
1074 (
1075  le_sms_MsgRef_t msgRef,
1076  ///< [IN] Reference to the message object.
1077  char* tel,
1078  ///< [OUT] Telephone number string.
1079  size_t telSize
1080  ///< [IN]
1081 );
1082 
1083 //--------------------------------------------------------------------------------------------------
1084 /**
1085  * Get the Service Center Time Stamp string.
1086  *
1087  * Output parameter is updated with the Time Stamp string. If the Time Stamp string exceeds the
1088  * value of 'len' parameter, a LE_OVERFLOW error code is returned and 'timestamp' is filled until
1089  * 'len-1' characters and a null-character is implicitly appended at the end of 'timestamp'.
1090  *
1091  * @return LE_NOT_PERMITTED Message is not a received message.
1092  * @return LE_OVERFLOW Timestamp number length exceed the maximum length.
1093  * @return LE_OK Function succeeded.
1094  *
1095  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1096  * function will not return.
1097  */
1098 //--------------------------------------------------------------------------------------------------
1100 (
1101  le_sms_MsgRef_t msgRef,
1102  ///< [IN] Reference to the message object.
1103  char* timestamp,
1104  ///< [OUT] Message time stamp (in text mode).
1105  ///< string format: "yy/MM/dd,hh:mm:ss+/-zz"
1106  ///< (Year/Month/Day,Hour:Min:Seconds+/-TimeZone)
1107  ///< The time zone indicates the difference, expressed
1108  ///< in quarters of an hours between the local time
1109  ///< and GMT.
1110  size_t timestampSize
1111  ///< [IN]
1112 );
1113 
1114 //--------------------------------------------------------------------------------------------------
1115 /**
1116  * Get the message Length value.
1117  *
1118  * @return Number of characters for text and UCS2 messages, or the length of the data in bytes for
1119  * raw binary messages.
1120  *
1121  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1122  * function will not return.
1123  */
1124 //--------------------------------------------------------------------------------------------------
1125 size_t le_sms_GetUserdataLen
1126 (
1127  le_sms_MsgRef_t msgRef
1128  ///< [IN] Reference to the message object.
1129 );
1130 
1131 //--------------------------------------------------------------------------------------------------
1132 /**
1133  * Get the text Message.
1134  *
1135  * Output parameter is updated with the text string encoded in ASCII format. If the text string
1136  * exceeds the value of 'len' parameter, LE_OVERFLOW error code is returned and 'text' is filled
1137  * until 'len-1' characters and a null-character is implicitly appended at the end of 'text'.
1138  *
1139  * @return LE_OVERFLOW Message length exceed the maximum length.
1140  * @return LE_OK Function succeeded.
1141  *
1142  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1143  * function will not return.
1144  */
1145 //--------------------------------------------------------------------------------------------------
1147 (
1148  le_sms_MsgRef_t msgRef,
1149  ///< [IN] Reference to the message object.
1150  char* text,
1151  ///< [OUT] SMS text.
1152  size_t textSize
1153  ///< [IN]
1154 );
1155 
1156 //--------------------------------------------------------------------------------------------------
1157 /**
1158  * Get the binary Message.
1159  *
1160  * Output parameters are updated with the binary message content and the length of the raw
1161  * binary message in bytes. If the binary data exceed the value of 'len' input parameter, a
1162  * LE_OVERFLOW error code is returned and 'raw' is filled until 'len' bytes.
1163  *
1164  * @return LE_FORMAT_ERROR Message is not in binary format
1165  * @return LE_OVERFLOW Message length exceed the maximum length.
1166  * @return LE_OK Function succeeded.
1167  *
1168  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1169  * function will not return.
1170  */
1171 //--------------------------------------------------------------------------------------------------
1173 (
1174  le_sms_MsgRef_t msgRef,
1175  ///< [IN] Reference to the message object.
1176  uint8_t* binPtr,
1177  ///< [OUT] Binary message.
1178  size_t* binSizePtr
1179  ///< [INOUT]
1180 );
1181 
1182 //--------------------------------------------------------------------------------------------------
1183 /**
1184  * Get the UCS2 Message (16-bit format).
1185  *
1186  * Output parameters are updated with the UCS2 message content and the number of characters. If
1187  * the UCS2 data exceed the value of the length input parameter, a LE_OVERFLOW error
1188  * code is returned and 'ucs2Ptr' is filled until of the number of chars specified.
1189  *
1190  * @return
1191  * - LE_FORMAT_ERROR Message is not in binary format
1192  * - LE_OVERFLOW Message length exceed the maximum length.
1193  * - LE_OK Function succeeded.
1194  *
1195  */
1196 //--------------------------------------------------------------------------------------------------
1198 (
1199  le_sms_MsgRef_t msgRef,
1200  ///< [IN] Reference to the message object.
1201  uint16_t* ucs2Ptr,
1202  ///< [OUT] UCS2 message.
1203  size_t* ucs2SizePtr
1204  ///< [INOUT]
1205 );
1206 
1207 //--------------------------------------------------------------------------------------------------
1208 /**
1209  * Get the PDU message.
1210  *
1211  * Output parameters are updated with the PDU message content and the length of the PDU message
1212  * in bytes. If the PDU data exceed the value of 'len' input parameter, a LE_OVERFLOW error code is
1213  * returned and 'pdu' is filled until 'len' bytes.
1214  *
1215  * @return LE_FORMAT_ERROR Unable to encode the message in PDU (only for outgoing messages).
1216  * @return LE_OVERFLOW Message length exceed the maximum length.
1217  * @return LE_OK Function succeeded.
1218  *
1219  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1220  * function will not return.
1221  */
1222 //--------------------------------------------------------------------------------------------------
1224 (
1225  le_sms_MsgRef_t msgRef,
1226  ///< [IN] Reference to the message object.
1227  uint8_t* pduPtr,
1228  ///< [OUT] PDU message.
1229  size_t* pduSizePtr
1230  ///< [INOUT]
1231 );
1232 
1233 //--------------------------------------------------------------------------------------------------
1234 /**
1235  * Get the message Length value.
1236  *
1237  * @return Length of the data in bytes of the PDU message.
1238  *
1239  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1240  * function will not return.
1241  */
1242 //--------------------------------------------------------------------------------------------------
1243 size_t le_sms_GetPDULen
1244 (
1245  le_sms_MsgRef_t msgRef
1246  ///< [IN] Reference to the message object.
1247 );
1248 
1249 //--------------------------------------------------------------------------------------------------
1250 /**
1251  * Delete an SMS message from the storage area.
1252  *
1253  * Verifies first if the parameter is valid, then it checks the modem state can support
1254  * message deleting.
1255  *
1256  * @return LE_FAULT Function failed to perform the deletion.
1257  * @return LE_NO_MEMORY The message is not present in storage area.
1258  * @return LE_OK Function succeeded.
1259  *
1260  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1261  * function will not return.
1262  */
1263 //--------------------------------------------------------------------------------------------------
1265 (
1266  le_sms_MsgRef_t msgRef
1267  ///< [IN] Reference to the message object.
1268 );
1269 
1270 //--------------------------------------------------------------------------------------------------
1271 /**
1272  * Create an object's reference of the list of received messages
1273  * saved in the SMS message storage area.
1274  *
1275  * @return
1276  * Reference to the List object. Null pointer if no messages have been retrieved.
1277  */
1278 //--------------------------------------------------------------------------------------------------
1279 le_sms_MsgListRef_t le_sms_CreateRxMsgList
1280 (
1281  void
1282 );
1283 
1284 //--------------------------------------------------------------------------------------------------
1285 /**
1286  * Delete the list of the Messages retrieved from the message
1287  * storage.
1288  *
1289  * @note
1290  * On failure, the process exits, so you don't have to worry about checking the returned
1291  * reference for validity.
1292  */
1293 //--------------------------------------------------------------------------------------------------
1294 void le_sms_DeleteList
1295 (
1296  le_sms_MsgListRef_t msgListRef
1297  ///< [IN] Messages list.
1298 );
1299 
1300 //--------------------------------------------------------------------------------------------------
1301 /**
1302  * Get the first Message object reference in the list of messages
1303  * retrieved with le_sms_CreateRxMsgList().
1304  *
1305  * @return NULL No message found.
1306  * @return Msg Message object reference.
1307  *
1308  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1309  * function will not return.
1310  */
1311 //--------------------------------------------------------------------------------------------------
1312 le_sms_MsgRef_t le_sms_GetFirst
1313 (
1314  le_sms_MsgListRef_t msgListRef
1315  ///< [IN] Messages list.
1316 );
1317 
1318 //--------------------------------------------------------------------------------------------------
1319 /**
1320  * Get the next Message object reference in the list of messages
1321  * retrieved with le_sms_CreateRxMsgList().
1322  *
1323  * @return NULL No message found.
1324  * @return Msg Message object reference.
1325  *
1326  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1327  * function will not return.
1328  */
1329 //--------------------------------------------------------------------------------------------------
1330 le_sms_MsgRef_t le_sms_GetNext
1331 (
1332  le_sms_MsgListRef_t msgListRef
1333  ///< [IN] Messages list.
1334 );
1335 
1336 //--------------------------------------------------------------------------------------------------
1337 /**
1338  * Read the Message status (Received Read, Received Unread, Stored
1339  * Sent, Stored Unsent).
1340  *
1341  * @return Status of the message.
1342  *
1343  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1344  * function will not return.
1345  */
1346 //--------------------------------------------------------------------------------------------------
1347 le_sms_Status_t le_sms_GetStatus
1348 (
1349  le_sms_MsgRef_t msgRef
1350  ///< [IN] Messages list.
1351 );
1352 
1353 //--------------------------------------------------------------------------------------------------
1354 /**
1355  * Mark a message as 'read'.
1356  *
1357  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1358  * function will not return.
1359  */
1360 //--------------------------------------------------------------------------------------------------
1361 void le_sms_MarkRead
1362 (
1363  le_sms_MsgRef_t msgRef
1364  ///< [IN] Messages list.
1365 );
1366 
1367 //--------------------------------------------------------------------------------------------------
1368 /**
1369  * Mark a message as 'unread'.
1370  *
1371  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1372  * function will not return.
1373  */
1374 //--------------------------------------------------------------------------------------------------
1375 void le_sms_MarkUnread
1376 (
1377  le_sms_MsgRef_t msgRef
1378  ///< [IN] Messages list.
1379 );
1380 
1381 //--------------------------------------------------------------------------------------------------
1382 /**
1383  * Get the SMS center address.
1384  *
1385  * Output parameter is updated with the SMS Service center address. If the Telephone number string exceeds
1386  * the value of 'len' parameter, LE_OVERFLOW error code is returned and 'tel' is filled until
1387  * 'len-1' characters and a null-character is implicitly appended at the end of 'tel'.
1388  *
1389  * @return
1390  * - LE_FAULT Service is not available.
1391  * - LE_OVERFLOW Telephone number length exceed the maximum length.
1392  * - LE_OK Function succeeded.
1393  *
1394  */
1395 //--------------------------------------------------------------------------------------------------
1397 (
1398  char* tel,
1399  ///< [OUT] SMS center address number string.
1400  size_t telSize
1401  ///< [IN]
1402 );
1403 
1404 //--------------------------------------------------------------------------------------------------
1405 /**
1406  * Set the SMS center address.
1407  *
1408  * SMS center address number is defined in ITU-T recommendations E.164/E.163.
1409  * E.164 numbers can have a maximum of fifteen digits and are usually written with a '+' prefix.
1410  *
1411  * @return
1412  * - LE_FAULT Service is not available..
1413  * - LE_OK Function succeeded.
1414  *
1415  * @note If the SMS center address number is too long (max LE_MDMDEFS_PHONE_NUM_MAX_LEN digits), it
1416  * is a fatal error, the function will not return.
1417  */
1418 //--------------------------------------------------------------------------------------------------
1420 (
1421  const char* LE_NONNULL tel
1422  ///< [IN] SMS center address number string.
1423 );
1424 
1425 //--------------------------------------------------------------------------------------------------
1426 /**
1427  * Set the preferred SMS storage for incoming messages.
1428  * @return
1429  * - LE_FAULT Function failed.
1430  * - LE_OK Function succeeded.
1431  */
1432 //--------------------------------------------------------------------------------------------------
1434 (
1435  le_sms_Storage_t prefStorage
1436  ///< [IN] storage parameter.
1437 );
1438 
1439 //--------------------------------------------------------------------------------------------------
1440 /**
1441  * Get the preferred SMS storage for incoming messages.
1442  * @return
1443  * - LE_FAULT Function failed.
1444  * - LE_OK Function succeeded.
1445  */
1446 //--------------------------------------------------------------------------------------------------
1448 (
1449  le_sms_Storage_t* prefStoragePtr
1450  ///< [OUT] storage parameter.
1451 );
1452 
1453 //--------------------------------------------------------------------------------------------------
1454 /**
1455  * Activate Cell Broadcast message notification
1456  *
1457  * @return
1458  * - LE_FAULT Function failed.
1459  * - LE_OK Function succeeded.
1460  */
1461 //--------------------------------------------------------------------------------------------------
1463 (
1464  void
1465 );
1466 
1467 //--------------------------------------------------------------------------------------------------
1468 /**
1469  * Deactivate Cell Broadcast message notification
1470  *
1471  * @return
1472  * - LE_FAULT Function failed.
1473  * - LE_OK Function succeeded.
1474  */
1475 //--------------------------------------------------------------------------------------------------
1477 (
1478  void
1479 );
1480 
1481 //--------------------------------------------------------------------------------------------------
1482 /**
1483  * Activate CDMA Cell Broadcast message notification
1484  *
1485  * @return
1486  * - LE_FAULT Function failed.
1487  * - LE_OK Function succeeded.
1488  */
1489 //--------------------------------------------------------------------------------------------------
1491 (
1492  void
1493 );
1494 
1495 //--------------------------------------------------------------------------------------------------
1496 /**
1497  * Deactivate CDMA Cell Broadcast message notification
1498  *
1499  * @return
1500  * - LE_FAULT Function failed.
1501  * - LE_OK Function succeeded.
1502  */
1503 //--------------------------------------------------------------------------------------------------
1505 (
1506  void
1507 );
1508 
1509 //--------------------------------------------------------------------------------------------------
1510 /**
1511  * Add Cell Broadcast message Identifiers range.
1512  *
1513  * @return
1514  * - LE_FAULT Function failed.
1515  * - LE_OK Function succeeded.
1516  */
1517 //--------------------------------------------------------------------------------------------------
1519 (
1520  uint16_t fromId,
1521  ///< [IN] Starting point of the range of cell broadcast message identifier.
1522  uint16_t toId
1523  ///< [IN] Ending point of the range of cell broadcast message identifier.
1524 );
1525 
1526 //--------------------------------------------------------------------------------------------------
1527 /**
1528  * Remove Cell Broadcast message Identifiers range.
1529  *
1530  * @return
1531  * - LE_FAULT Function failed.
1532  * - LE_OK Function succeeded.
1533  */
1534 //--------------------------------------------------------------------------------------------------
1536 (
1537  uint16_t fromId,
1538  ///< [IN] Starting point of the range of cell broadcast message identifier.
1539  uint16_t toId
1540  ///< [IN] Ending point of the range of cell broadcast message identifier.
1541 );
1542 
1543 //--------------------------------------------------------------------------------------------------
1544 /**
1545  * Clear Cell Broadcast message Identifiers.
1546  *
1547  * @return
1548  * - LE_FAULT Function failed.
1549  * - LE_OK Function succeeded.
1550  */
1551 //--------------------------------------------------------------------------------------------------
1553 (
1554  void
1555 );
1556 
1557 //--------------------------------------------------------------------------------------------------
1558 /**
1559  * Add CDMA Cell Broadcast category services.
1560  *
1561  * @return
1562  * - LE_FAULT Function failed.
1563  * - LE_BAD_PARAMETER Parameter is invalid.
1564  * - LE_OK Function succeeded.
1565  */
1566 //--------------------------------------------------------------------------------------------------
1568 (
1569  le_sms_CdmaServiceCat_t serviceCat,
1570  ///< [IN] Service category assignment. Reference to 3GPP2 C.R1001-D
1571  ///< v1.0 Section 9.3.1 Standard Service Category Assignments.
1572  le_sms_Languages_t language
1573  ///< [IN] Language Indicator. Reference to
1574  ///< 3GPP2 C.R1001-D v1.0 Section 9.2.1 Language Indicator
1575  ///< Value Assignments
1576 );
1577 
1578 //--------------------------------------------------------------------------------------------------
1579 /**
1580  * Remove CDMA Cell Broadcast category services.
1581  *
1582  * @return
1583  * - LE_FAULT Function failed.
1584  * - LE_BAD_PARAMETER Parameter is invalid.
1585  * - LE_OK Function succeeded.
1586  */
1587 //--------------------------------------------------------------------------------------------------
1589 (
1590  le_sms_CdmaServiceCat_t serviceCat,
1591  ///< [IN] Service category assignment. Reference to 3GPP2 C.R1001-D
1592  ///< v1.0 Section 9.3.1 Standard Service Category Assignments.
1593  le_sms_Languages_t language
1594  ///< [IN] Language Indicator. Reference to
1595  ///< 3GPP2 C.R1001-D v1.0 Section 9.2.1 Language Indicator
1596  ///< Value Assignments
1597 );
1598 
1599 //--------------------------------------------------------------------------------------------------
1600 /**
1601  * Clear CDMA Cell Broadcast category services.
1602  *
1603  * @return
1604  * - LE_FAULT Function failed.
1605  * - LE_OK Function succeeded.
1606  */
1607 //--------------------------------------------------------------------------------------------------
1609 (
1610  void
1611 );
1612 
1613 //--------------------------------------------------------------------------------------------------
1614 /**
1615  * Get the number of messages successfully received or sent since last counter reset.
1616  *
1617  * @return
1618  * - LE_OK Function succeeded.
1619  * - LE_BAD_PARAMETER A parameter is invalid.
1620  *
1621  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1622  * function will not return.
1623  */
1624 //--------------------------------------------------------------------------------------------------
1626 (
1627  le_sms_Type_t messageType,
1628  ///< [IN] Message type
1629  int32_t* messageCountPtr
1630  ///< [OUT] Number of messages
1631 );
1632 
1633 //--------------------------------------------------------------------------------------------------
1634 /**
1635  * Start to count the messages successfully received and sent.
1636  */
1637 //--------------------------------------------------------------------------------------------------
1638 void le_sms_StartCount
1639 (
1640  void
1641 );
1642 
1643 //--------------------------------------------------------------------------------------------------
1644 /**
1645  * Stop to count the messages successfully received and sent.
1646  */
1647 //--------------------------------------------------------------------------------------------------
1648 void le_sms_StopCount
1649 (
1650  void
1651 );
1652 
1653 //--------------------------------------------------------------------------------------------------
1654 /**
1655  * Reset the count of messages successfully received and sent.
1656  */
1657 //--------------------------------------------------------------------------------------------------
1658 void le_sms_ResetCount
1659 (
1660  void
1661 );
1662 
1663 //--------------------------------------------------------------------------------------------------
1664 /**
1665  * Enable SMS Status Report for outgoing messages.
1666  *
1667  * @return
1668  * - LE_OK Function succeeded.
1669  * - LE_FAULT Function failed.
1670  */
1671 //--------------------------------------------------------------------------------------------------
1673 (
1674  void
1675 );
1676 
1677 //--------------------------------------------------------------------------------------------------
1678 /**
1679  * Disable SMS Status Report for outgoing messages.
1680  *
1681  * @return
1682  * - LE_OK Function succeeded.
1683  * - LE_FAULT Function failed.
1684  */
1685 //--------------------------------------------------------------------------------------------------
1687 (
1688  void
1689 );
1690 
1691 //--------------------------------------------------------------------------------------------------
1692 /**
1693  * Get SMS Status Report activation state.
1694  *
1695  * @return
1696  * - LE_OK Function succeeded.
1697  * - LE_BAD_PARAMETER Parameter is invalid.
1698  * - LE_FAULT Function failed.
1699  */
1700 //--------------------------------------------------------------------------------------------------
1702 (
1703  bool* enabledPtr
1704  ///< [OUT] True when SMS Status Report is enabled, false otherwise.
1705 );
1706 
1707 //--------------------------------------------------------------------------------------------------
1708 /**
1709  * Get TP-Message-Reference of a message. Message type should be either a SMS Status Report or an
1710  * outgoing SMS.
1711  * TP-Message-Reference is defined in 3GPP TS 23.040 section 9.2.3.6.
1712  *
1713  * @return
1714  * - LE_OK Function succeeded.
1715  * - LE_BAD_PARAMETER Parameter is invalid.
1716  * - LE_FAULT Function failed.
1717  * - LE_UNAVAILABLE Outgoing SMS message is not sent.
1718  */
1719 //--------------------------------------------------------------------------------------------------
1721 (
1722  le_sms_MsgRef_t msgRef,
1723  ///< [IN] Reference to the message object.
1724  uint8_t* tpMrPtr
1725  ///< [OUT] 3GPP TS 23.040 TP-Message-Reference.
1726 );
1727 
1728 //--------------------------------------------------------------------------------------------------
1729 /**
1730  * Get TP-Recipient-Address of SMS Status Report.
1731  * TP-Recipient-Address is defined in 3GPP TS 23.040 section 9.2.3.14.
1732  * TP-Recipient-Address Type-of-Address is defined in 3GPP TS 24.011 section 8.2.5.2.
1733  *
1734  * @return
1735  * - LE_OK Function succeeded.
1736  * - LE_BAD_PARAMETER A parameter is invalid.
1737  * - LE_OVERFLOW The Recipient Address length exceeds the length of the provided buffer.
1738  * - LE_FAULT Function failed.
1739  */
1740 //--------------------------------------------------------------------------------------------------
1742 (
1743  le_sms_MsgRef_t msgRef,
1744  ///< [IN] Reference to the message object.
1745  uint8_t* toraPtr,
1746  ///< [OUT] 3GPP TS 24.011 TP-Recipient-Address
1747  ///< Type-of-Address.
1748  char* ra,
1749  ///< [OUT] 3GPP TS 23.040 TP-Recipient-Address.
1750  size_t raSize
1751  ///< [IN]
1752 );
1753 
1754 //--------------------------------------------------------------------------------------------------
1755 /**
1756  * Get TP-Service-Centre-Time-Stamp of SMS Status Report.
1757  * TP-Service-Centre-Time-Stamp is defined in 3GPP TS 23.040 section 9.2.3.11.
1758  *
1759  * @return
1760  * - LE_OK Function succeeded.
1761  * - LE_BAD_PARAMETER A parameter is invalid.
1762  * - LE_OVERFLOW The SC Timestamp length exceeds the length of the provided buffer.
1763  * - LE_FAULT Function failed.
1764  */
1765 //--------------------------------------------------------------------------------------------------
1767 (
1768  le_sms_MsgRef_t msgRef,
1769  ///< [IN] Reference to the message object.
1770  char* scts,
1771  ///< [OUT] 3GPP TS 23.040 TP-Service-Centre-Time-Stamp.
1772  size_t sctsSize
1773  ///< [IN]
1774 );
1775 
1776 //--------------------------------------------------------------------------------------------------
1777 /**
1778  * Get TP-Discharge-Time of SMS Status Report.
1779  * TP-Discharge-Time is defined in 3GPP TS 23.040 section 9.2.3.13.
1780  *
1781  * @return
1782  * - LE_OK Function succeeded.
1783  * - LE_BAD_PARAMETER A parameter is invalid.
1784  * - LE_OVERFLOW The Discharge Time length exceeds the length of the provided buffer.
1785  * - LE_FAULT Function failed.
1786  */
1787 //--------------------------------------------------------------------------------------------------
1789 (
1790  le_sms_MsgRef_t msgRef,
1791  ///< [IN] Reference to the message object.
1792  char* dt,
1793  ///< [OUT] 3GPP TS 23.040 TP-Discharge-Time.
1794  size_t dtSize
1795  ///< [IN]
1796 );
1797 
1798 //--------------------------------------------------------------------------------------------------
1799 /**
1800  * Get TP-Status of SMS Status Report.
1801  * TP-Status is defined in 3GPP TS 23.040 section 9.2.3.15.
1802  *
1803  * @return
1804  * - LE_OK Function succeeded.
1805  * - LE_BAD_PARAMETER A parameter is invalid.
1806  * - LE_FAULT Function failed.
1807  */
1808 //--------------------------------------------------------------------------------------------------
1810 (
1811  le_sms_MsgRef_t msgRef,
1812  ///< [IN] Reference to the message object.
1813  uint8_t* stPtr
1814  ///< [OUT] 3GPP TS 23.040 TP-Status.
1815 );
1816 
1817 #endif // LE_SMS_INTERFACE_H_INCLUDE_GUARD
LE_FULL_API void le_sms_SetServerDisconnectHandler(le_sms_DisconnectHandler_t disconnectHandler, void *contextPtr)
void le_sms_Delete(le_sms_MsgRef_t msgRef)
le_result_t le_sms_GetPDU(le_sms_MsgRef_t msgRef, uint8_t *pduPtr, size_t *pduSizePtr)
le_result_t le_sms_GetCellBroadcastId(le_sms_MsgRef_t msgRef, uint16_t *messageIdPtr)
le_result_t le_sms_ClearCdmaCellBroadcastServices(void)
le_result_t le_sms_GetSmsCenterAddress(char *tel, size_t telSize)
void le_sms_StartCount(void)
le_result_t
Definition: le_basics.h:35
le_sms_ErrorCode3GPP2_t le_sms_Get3GPP2ErrorCode(le_sms_MsgRef_t msgRef)
le_result_t le_sms_ClearCellBroadcastIds(void)
void le_sms_MarkUnread(le_sms_MsgRef_t msgRef)
le_sms_MsgRef_t le_sms_Create(void)
le_result_t le_sms_SetUCS2(le_sms_MsgRef_t msgRef, const uint16_t *ucs2Ptr, size_t ucs2Size)
size_t le_sms_GetUserdataLen(le_sms_MsgRef_t msgRef)
le_result_t le_sms_GetTpRa(le_sms_MsgRef_t msgRef, uint8_t *toraPtr, char *ra, size_t raSize)
le_result_t le_sms_SetTimeout(le_sms_MsgRef_t msgRef, uint32_t timeout)
le_sms_MsgRef_t le_sms_SendPdu(const uint8_t *pduPtr, size_t pduSize, le_sms_CallbackResultFunc_t handlerPtr, void *contextPtr)
void(* le_sms_DisconnectHandler_t)(void *)
Definition: le_sms_interface.h:403
void le_sms_GetErrorCode(le_sms_MsgRef_t msgRef, le_sms_ErrorCode_t *rpCausePtr, le_sms_ErrorCode_t *tpCausePtr)
le_result_t le_sms_ActivateCellBroadcast(void)
le_sms_MsgRef_t le_sms_GetNext(le_sms_MsgListRef_t msgListRef)
le_result_t le_sms_GetBinary(le_sms_MsgRef_t msgRef, uint8_t *binPtr, size_t *binSizePtr)
le_sms_MsgListRef_t le_sms_CreateRxMsgList(void)
void le_sms_RemoveRxMessageHandler(le_sms_RxMessageHandlerRef_t handlerRef)
le_result_t le_sms_GetText(le_sms_MsgRef_t msgRef, char *text, size_t textSize)
le_result_t le_sms_ActivateCdmaCellBroadcast(void)
le_sms_FullStorageEventHandlerRef_t le_sms_AddFullStorageEventHandler(le_sms_FullStorageHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_sms_DeactivateCellBroadcast(void)
le_result_t le_sms_GetCellBroadcastSerialNumber(le_sms_MsgRef_t msgRef, uint16_t *serialNumberPtr)
le_result_t le_sms_DisableStatusReport(void)
void le_sms_DisconnectService(void)
le_result_t le_sms_TryConnectService(void)
le_result_t le_sms_AddCellBroadcastIds(uint16_t fromId, uint16_t toId)
le_result_t le_sms_SetText(le_sms_MsgRef_t msgRef, const char *LE_NONNULL text)
le_result_t le_sms_SetBinary(le_sms_MsgRef_t msgRef, const uint8_t *binPtr, size_t binSize)
le_result_t le_sms_SetPreferredStorage(le_sms_Storage_t prefStorage)
le_result_t le_sms_DeleteFromStorage(le_sms_MsgRef_t msgRef)
le_result_t le_sms_GetUCS2(le_sms_MsgRef_t msgRef, uint16_t *ucs2Ptr, size_t *ucs2SizePtr)
le_result_t le_sms_GetSenderTel(le_sms_MsgRef_t msgRef, char *tel, size_t telSize)
le_result_t le_sms_SendAsync(le_sms_MsgRef_t msgRef, le_sms_CallbackResultFunc_t handlerPtr, void *contextPtr)
le_sms_Status_t le_sms_GetStatus(le_sms_MsgRef_t msgRef)
le_result_t le_sms_GetPreferredStorage(le_sms_Storage_t *prefStoragePtr)
size_t le_sms_GetPDULen(le_sms_MsgRef_t msgRef)
le_result_t le_sms_DeactivateCdmaCellBroadcast(void)
le_result_t le_sms_RemoveCdmaCellBroadcastServices(le_sms_CdmaServiceCat_t serviceCat, le_sms_Languages_t language)
le_result_t le_sms_SetSmsCenterAddress(const char *LE_NONNULL tel)
le_sms_MsgRef_t le_sms_GetFirst(le_sms_MsgListRef_t msgListRef)
void le_sms_ResetCount(void)
#define LE_FULL_API
Definition: le_apiFeatures.h:40
le_result_t le_sms_SetPDU(le_sms_MsgRef_t msgRef, const uint8_t *pduPtr, size_t pduSize)
le_result_t le_sms_RemoveCellBroadcastIds(uint16_t fromId, uint16_t toId)
void le_sms_ConnectService(void)
le_sms_MsgRef_t le_sms_SendText(const char *LE_NONNULL destStr, const char *LE_NONNULL textStr, le_sms_CallbackResultFunc_t handlerPtr, void *contextPtr)
le_result_t le_sms_SetDestination(le_sms_MsgRef_t msgRef, const char *LE_NONNULL dest)
le_result_t le_sms_GetTpDt(le_sms_MsgRef_t msgRef, char *dt, size_t dtSize)
le_result_t le_sms_AddCdmaCellBroadcastServices(le_sms_CdmaServiceCat_t serviceCat, le_sms_Languages_t language)
le_result_t le_sms_GetTpMr(le_sms_MsgRef_t msgRef, uint8_t *tpMrPtr)
le_result_t le_sms_EnableStatusReport(void)
le_sms_Format_t le_sms_GetFormat(le_sms_MsgRef_t msgRef)
int32_t le_sms_GetPlatformSpecificErrorCode(le_sms_MsgRef_t msgRef)
le_result_t le_sms_GetCount(le_sms_Type_t messageType, int32_t *messageCountPtr)
le_sms_Type_t le_sms_GetType(le_sms_MsgRef_t msgRef)
void le_sms_RemoveFullStorageEventHandler(le_sms_FullStorageEventHandlerRef_t handlerRef)
le_result_t le_sms_GetTpSt(le_sms_MsgRef_t msgRef, uint8_t *stPtr)
le_result_t le_sms_GetTimeStamp(le_sms_MsgRef_t msgRef, char *timestamp, size_t timestampSize)
le_result_t le_sms_Send(le_sms_MsgRef_t msgRef)
void le_sms_DeleteList(le_sms_MsgListRef_t msgListRef)
le_sms_RxMessageHandlerRef_t le_sms_AddRxMessageHandler(le_sms_RxMessageHandlerFunc_t handlerPtr, void *contextPtr)
le_result_t le_sms_IsStatusReportEnabled(bool *enabledPtr)
void le_sms_MarkRead(le_sms_MsgRef_t msgRef)
le_result_t le_sms_GetTpScTs(le_sms_MsgRef_t msgRef, char *scts, size_t sctsSize)
void le_sms_StopCount(void)